GasLiftOpt.hpp

/*
  Copyright 2020 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 GAS_LIFT_OPT_HPP
#define GAS_LIFT_OPT_HPP

#include <opm/io/eclipse/rst/group.hpp>
#include <opm/io/eclipse/rst/well.hpp>

#include <cstddef>
#include <map>
#include <optional>
#include <string>

namespace Opm {

class GasLiftGroup
{
public:
    GasLiftGroup() = default;

    explicit GasLiftGroup(const std::string& name)
        : m_name(name)
    {}

    explicit GasLiftGroup(const RestartIO::RstGroup& rst_group);

    static bool active(const RestartIO::RstGroup& rst_group);

    const std::optional<double>& max_lift_gas() const
    {
        return this->m_max_lift_gas;
    }

    void max_lift_gas(const double value)
    {
        if (! (value < 0.0)) {
            this->m_max_lift_gas = value;
        }
    }

    const std::optional<double>& max_total_gas() const
    {
        return this->m_max_total_gas;
    }

    void max_total_gas(const double value)
    {
        if (! (value < 0.0)) {
            this->m_max_total_gas = value;
        }
    }

    const std::string& name() const
    {
        return this->m_name;
    }

    template<class Serializer>
    void serializeOp(Serializer& serializer)
    {
        serializer(m_name);
        serializer(m_max_lift_gas);
        serializer(m_max_total_gas);
    }

    static GasLiftGroup serializationTestObject();

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

private:
    std::string m_name{};

    std::optional<double> m_max_lift_gas{};

    std::optional<double> m_max_total_gas{};
};

// ---------------------------------------------------------------------------

class GasLiftWell
{
public:
    GasLiftWell() = default;

    GasLiftWell(const std::string& name, const bool use_glo)
        : m_name    { name }
        , m_use_glo { use_glo }
    {}

    explicit GasLiftWell(const RestartIO::RstWell& rst_well);

    static bool active(const RestartIO::RstWell& rst_well);

    const std::string& name() const
    {
        return this->m_name;
    }

    bool use_glo() const
    {
        return this->m_use_glo;
    }

    void max_rate(const double value)
    {
        this->m_max_rate = value;
    }

    const std::optional<double>& max_rate() const
    {
        return this->m_max_rate;
    }

    void weight_factor(const double value)
    {
        if (this->m_use_glo) {
            this->m_weight = value;
        }
    }

    double weight_factor() const
    {
        return this->m_weight;
    }

    void inc_weight_factor(const double value)
    {
        if (this->m_use_glo) {
            this->m_inc_weight = value;
        }
    }

    double inc_weight_factor() const
    {
        return this->m_inc_weight;
    }

    void min_rate(const double value)
    {
        if (this->m_use_glo) {
            this->m_min_rate = value;
        }
    }

    double min_rate() const
    {
        return this->m_min_rate;
    }

    void alloc_extra_gas(const bool value)
    {
        if (this->m_use_glo) {
            this->m_alloc_extra_gas = value;
        }
    }

    bool alloc_extra_gas() const
    {
        return this->m_alloc_extra_gas;
    }

    template<class Serializer>
    void serializeOp(Serializer& serializer)
    {
        serializer(m_name);
        serializer(m_use_glo);
        serializer(m_max_rate);
        serializer(m_min_rate);
        serializer(m_weight);
        serializer(m_inc_weight);
        serializer(m_alloc_extra_gas);
    }

    static GasLiftWell serializationTestObject();

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

private:
    std::string m_name{};

    std::optional<double> m_max_rate{};

    double m_min_rate { 0.0 };

    bool m_use_glo { false };

    double m_weight { 1.0 };

    double m_inc_weight { 0.0 };

    bool m_alloc_extra_gas { false };
};

// ---------------------------------------------------------------------------

class GasLiftOpt
{
public:
    const GasLiftGroup& group(const std::string& gname) const;

    const GasLiftWell& well(const std::string& wname) const;

    double gaslift_increment() const;

    void gaslift_increment(double gaslift_increment);

    double min_eco_gradient() const;

    void min_eco_gradient(double min_eco_gradient);

    double min_wait() const;

    void min_wait(double min_wait);

    bool all_newton() const;

    void all_newton(bool all_newton);

    void add_group(const GasLiftGroup& group);

    void add_well(const GasLiftWell& well);

    bool active() const;

    bool has_well(const std::string& well) const;

    bool has_group(const std::string& group) const;

    std::size_t num_wells() const
    {
        return this->m_wells.size();
    }

    static GasLiftOpt serializationTestObject();

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

    template<class Serializer>
    void serializeOp(Serializer& serializer)
    {
        serializer(m_increment);
        serializer(m_min_eco_gradient);
        serializer(m_min_wait);
        serializer(m_all_newton);
        serializer(m_groups);
        serializer(m_wells);
    }

private:
    double m_increment { 0.0 };

    double m_min_eco_gradient { 0.0 };

    double m_min_wait { 0.0 };

    bool m_all_newton { true };

    std::map<std::string, GasLiftGroup> m_groups{};

    std::map<std::string, GasLiftWell> m_wells{};
};

} // namespace Opm

#endif // GAS_LIFT_OPT_HPP