UDQActive.hpp

/*
  Copyright 2019 Equinor ASA.

  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 UDQ_USAGE_HPP
#define UDQ_USAGE_HPP

#include <opm/input/eclipse/EclipseState/Phase.hpp>

#include <opm/input/eclipse/Schedule/UDQ/UDQEnums.hpp>

#include <opm/input/eclipse/Deck/UDAValue.hpp>

#include <cstddef>
#include <cstdlib>
#include <optional>
#include <string>
#include <vector>

namespace Opm {

class UDQConfig;
class UnitSystem;

} // namespace Opm

namespace Opm::RestartIO {
    struct RstState;
} // namespace Opm::RestartIO

namespace Opm {

class UDQActive
{
public:
    struct RstRecord
    {
        RstRecord(const UDAControl   control_arg,
                  const UDAValue&    value_arg,
                  const std::string& wgname_arg)
            : control { control_arg }
            , value   { value_arg }
            , wgname  { wgname_arg }
        {}

        RstRecord(const UDAControl   control_arg,
                  const UDAValue&    value_arg,
                  const std::string& wgname_arg,
                  const Phase        phase)
            : RstRecord { control_arg, value_arg, wgname_arg }
        {
            this->ig_phase = phase;
        }

        UDAControl control;

        UDAValue value;

        std::string wgname;

        std::optional<Phase> ig_phase{};
    };

    class OutputRecord
    {
    public:
        OutputRecord();

        OutputRecord(const std::string& udq_arg,
                     const std::size_t  input_index_arg,
                     const std::string& wgname_arg,
                     const UDAControl   control_arg);

        bool operator==(const OutputRecord& other) const;

        bool operator!=(const OutputRecord& other) const
        {
            return ! (*this == other);
        }

        template<class Serializer>
        void serializeOp(Serializer& serializer)
        {
            serializer(udq);
            serializer(input_index);
            serializer(wgname);
            serializer(control);
            serializer(uda_code);
            serializer(use_count);
        }

        std::string udq;

        std::size_t input_index;

        UDAControl control;

        int uda_code{};

        const std::string& wg_name() const
        {
            return this->wgname;
        }

        std::size_t use_count{};

    private:
        std::string wgname{};
    };

    class InputRecord
    {
    public:
        InputRecord();

        InputRecord(const std::size_t  input_index_arg,
                    const std::string& udq_arg,
                    const std::string& wgname_arg,
                    const UDAControl   control_arg);

        bool operator==(const InputRecord& other) const;

        template<class Serializer>
        void serializeOp(Serializer& serializer)
        {
            serializer(input_index);
            serializer(udq);
            serializer(wgname);
            serializer(control);
        }

        std::size_t input_index;

        std::string udq;

        std::string wgname;

        UDAControl control;
    };

    static UDQActive serializationTestObject();

    UDQActive() = default;

    static std::vector<RstRecord>
    load_rst(const UnitSystem&               units,
             const UDQConfig&                udq_config,
             const RestartIO::RstState&      rst_state,
             const std::vector<std::string>& well_names,
             const std::vector<std::string>& group_names);

    int update(const UDQConfig&   udq_config,
               const UDAValue&    uda,
               const std::string& wgname,
               const UDAControl   control);

    explicit operator bool() const;

    const std::vector<OutputRecord>& iuad() const;

    std::vector<InputRecord> iuap() const;

    bool operator==(const UDQActive& data) const;

    template<class Serializer>
    void serializeOp(Serializer& serializer)
    {
        serializer(input_data);
        serializer(output_data);
    }

private:
    std::vector<InputRecord> input_data{};

    mutable std::vector<OutputRecord> output_data{};

    void constructOutputRecords() const;
};

} // namespace Opm

#endif // UDQ_USAGE_HPP