TranCalculator.hpp

/*
  Copyright 2020 Equinor AS.
 
  This file is part of the Open Porous Media project (OPM).
 
  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef TRAN_CALCULATOR_HPP
#define TRAN_CALCULATOR_HPP
 
#include <string>
#include <unordered_map>
#include <vector>
 
namespace Opm
{
 
namespace Fieldprops
{
 
namespace keywords { template<class T> struct keyword_info; }
 
enum class ScalarOperation {
    ADD = 1,
    EQUAL = 2,
    MUL = 3,
    MIN = 4,
    MAX = 5
};
 
 
class TranCalculator {
public:
 
    struct TranAction {
        ScalarOperation op;
        std::string field;
 
        bool operator==(const TranAction& other) const {
            return this->op == other.op &&
                   this->field == other.field;
        }
 
        template<class Serializer>
        void serializeOp(Serializer& serializer)
        {
            serializer(op);
            serializer(field);
        }
    };
 
 
    explicit TranCalculator(const std::string& name_arg) :
        m_name(name_arg)
    {}
 
    TranCalculator() = default;
 
    std::string next_name() const {
        return this->m_name + std::to_string( this->actions.size() );
    }
 
    std::vector<TranAction>::const_iterator begin() const {
        return this->actions.begin();
    }
 
    std::vector<TranAction>::const_iterator end() const {
        return this->actions.end();
    }
 
    void add_action(ScalarOperation op, const std::string& field) {
        this->actions.push_back(TranAction{op, field});
    }
 
    std::size_t size() const {
        return this->actions.size();
    }
 
    const std::string& name() const {
        return this->m_name;
    }
 
    keywords::keyword_info<double> make_kw_info(ScalarOperation op,
                                                const std::string& target_kw);
 
    bool operator==(const TranCalculator& other) const {
        return this->m_name == other.m_name &&
               this->actions == other.actions;
    }
 
    template<class Serializer>
    void serializeOp(Serializer& serializer)
    {
        serializer(m_name);
        serializer(actions);
    }
 
    static TranCalculator serializationTestObject()
    {
        TranCalculator tran("test");
        tran.add_action(ScalarOperation::MIN, "FGOP");
        return tran;
    }
 
private:
    std::string m_name;
    std::vector<TranAction> actions;
};
 
} // namespace Fieldprops
} // end namespace Opm
#endif // TRAN_CALCULATOR_HPP