Loading...
Searching...
No Matches
Group.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 OPM_GROUP_HPP
#define OPM_GROUP_HPP
#include <opm/input/eclipse/EclipseState/Phase.hpp>
#include <opm/input/eclipse/EclipseState/Util/IOrderSet.hpp>
#include <opm/input/eclipse/Schedule/Group/GPMaint.hpp>
#include <opm/input/eclipse/Deck/UDAValue.hpp>
#include <opm/input/eclipse/Units/UnitSystem.hpp>
#include <cstddef>
#include <cstdint>
#include <map>
#include <optional>
#include <string>
namespace Opm {
class SummaryState;
class UDQConfig;
class UDQActive;
} // namespace Opm
namespace Opm::RestartIO {
struct RstGroup;
} // namespace Opm::RestartIO
namespace Opm {
class Group
{
public:
// A group can have both injection controls and production controls set
// at the same time, i.e. this enum is used as a bitmask.
enum class GroupType : unsigned {
NONE = 0,
PRODUCTION = 1,
INJECTION = 2,
MIXED = 3,
};
enum class ExceedAction {
NONE = 0,
CON = 1,
CON_PLUS = 2, // String: "+CON"
WELL = 3,
PLUG = 4,
RATE = 5
};
static std::string ExceedAction2String(ExceedAction enumValue);
static ExceedAction ExceedActionFromString(const std::string& stringValue);
static ExceedAction ExceedActionFromInt(const int value);
enum class InjectionCMode : int {
NONE = 0,
RATE = 1,
RESV = 2,
REIN = 4,
VREP = 8,
FLD = 16,
SALE = 32
};
static std::string InjectionCMode2String(InjectionCMode enumValue);
static InjectionCMode InjectionCModeFromString(const std::string& stringValue);
static InjectionCMode InjectionCModeFromInt(int ecl_int);
static int InjectionCMode2Int(InjectionCMode enumValue);
enum class ProductionCMode : int {
NONE = 0,
ORAT = 1,
WRAT = 2,
GRAT = 4,
LRAT = 8,
CRAT = 16,
RESV = 32,
PRBL = 64,
FLD = 128
};
static std::string ProductionCMode2String(ProductionCMode enumValue);
static ProductionCMode ProductionCModeFromString(const std::string& stringValue);
static ProductionCMode ProductionCModeFromInt(int ecl_int);
static int ProductionCMode2Int(Group::ProductionCMode cmode);
enum class GuideRateProdTarget {
OIL = 0,
WAT = 1,
GAS = 2,
LIQ = 3,
RES = 4,
COMB = 5,
WGA = 6,
CVAL = 7,
INJV = 8,
POTN = 9,
FORM = 10,
NO_GUIDE_RATE = 11
};
static GuideRateProdTarget GuideRateProdTargetFromString(const std::string& stringValue);
static GuideRateProdTarget GuideRateProdTargetFromInt(int ecl_id);
enum class GuideRateInjTarget {
RATE = 1,
VOID = 2,
NETV = 3,
RESV = 4,
NO_GUIDE_RATE = 5
};
static GuideRateInjTarget GuideRateInjTargetFromString(const std::string& stringValue);
static GuideRateInjTarget GuideRateInjTargetFromInt(int ecl_id);
static int GuideRateInjTargetToInt(GuideRateInjTarget target);
struct GroupInjectionProperties
{
GroupInjectionProperties() = default;
explicit GroupInjectionProperties(std::string group_name_arg);
GroupInjectionProperties(std::string group_name_arg, Phase phase, const UnitSystem& unit_system);
std::string name{};
Phase phase = Phase::WATER;
InjectionCMode cmode = InjectionCMode::NONE;
UDAValue surface_max_rate;
UDAValue resv_max_rate;
UDAValue target_reinj_fraction;
UDAValue target_void_fraction;
std::optional<std::string> reinj_group;
std::optional<std::string> voidage_group;
bool available_group_control = true;
double guide_rate = 0;
GuideRateInjTarget guide_rate_def = GuideRateInjTarget::NO_GUIDE_RATE;
static GroupInjectionProperties serializationTestObject();
int injection_controls = 0;
bool operator==(const GroupInjectionProperties& other) const;
bool operator!=(const GroupInjectionProperties& other) const;
bool updateUDQActive(const UDQConfig& udq_config, UDQActive& active) const;
bool uda_phase() const;
void update_uda(const UDQConfig& udq_config, UDQActive& udq_active, UDAControl control, const UDAValue& value);
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(this->name);
serializer(phase);
serializer(cmode);
serializer(surface_max_rate);
serializer(resv_max_rate);
serializer(target_reinj_fraction);
serializer(target_void_fraction);
serializer(reinj_group);
serializer(voidage_group);
serializer(injection_controls);
serializer(available_group_control);
serializer(guide_rate);
serializer(guide_rate_def);
}
};
struct GroupLimitAction
{
// \Note: we do not use allRates in the simulation, while keeping it for now for RESTART output purpose
ExceedAction allRates{ExceedAction::NONE};
ExceedAction oil{ExceedAction::NONE};
ExceedAction water{ExceedAction::NONE};
ExceedAction gas{ExceedAction::NONE};
ExceedAction liquid{ExceedAction::NONE};
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(allRates);
serializer(oil);
serializer(water);
serializer(gas);
serializer(liquid);
}
bool operator==(const GroupLimitAction& other) const
{
return (this->allRates == other.allRates)
&& (this->oil == other.oil)
&& (this->water == other.water)
&& (this->gas == other.gas)
&& (this->liquid == other.liquid);
}
};
struct InjectionControls
{
Phase phase;
InjectionCMode cmode;
double surface_max_rate;
double resv_max_rate;
double target_reinj_fraction;
double target_void_fraction;
int injection_controls = 0;
std::string reinj_group;
std::string voidage_group;
double guide_rate;
GuideRateInjTarget guide_rate_def = GuideRateInjTarget::NO_GUIDE_RATE;
};
struct GroupProductionProperties
{
GroupProductionProperties();
GroupProductionProperties(const UnitSystem& unit_system, const std::string& gname);
std::string name;
ProductionCMode cmode = ProductionCMode::NONE;
GroupLimitAction group_limit_action;
UDAValue oil_target;
UDAValue water_target;
UDAValue gas_target;
UDAValue liquid_target;
double guide_rate = 0;
GuideRateProdTarget guide_rate_def = GuideRateProdTarget::NO_GUIDE_RATE;
UDAValue resv_target;
bool available_group_control = true;
static GroupProductionProperties serializationTestObject();
int production_controls = 0;
bool operator==(const GroupProductionProperties& other) const;
bool operator!=(const GroupProductionProperties& other) const;
bool updateUDQActive(const UDQConfig& udq_config, UDQActive& active) const;
void update_uda(const UDQConfig& udq_config, UDQActive& udq_active, UDAControl control, const UDAValue& value);
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(name);
serializer(cmode);
serializer(group_limit_action);
serializer(oil_target);
serializer(water_target);
serializer(gas_target);
serializer(liquid_target);
serializer(guide_rate);
serializer(guide_rate_def);
serializer(resv_target);
serializer(available_group_control);
serializer(production_controls);
}
};
struct ProductionControls
{
ProductionCMode cmode;
GroupLimitAction group_limit_action;
double oil_target;
double water_target;
double gas_target;
double liquid_target;
double guide_rate;
GuideRateProdTarget guide_rate_def = GuideRateProdTarget::NO_GUIDE_RATE;
double resv_target = 0;
int production_controls = 0;
};
Group();
Group(const std::string& group_name,
std::size_t insert_index_arg,
double udq_undefined_arg,
const UnitSystem& unit_system);
Group(const RestartIO::RstGroup& rst_group,
std::size_t insert_index_arg,
double udq_undefined_arg,
const UnitSystem& unit_system);
static Group serializationTestObject();
std::size_t insert_index() const;
const std::string& name() const;
bool is_field() const;
bool update_gefac(double gefac, bool use_efficiency_in_network);
// [[deprecated("use Group::control_group() or Group::flow_group()")]]
const std::string& parent() const;
std::optional<std::string> control_group() const;
std::optional<std::string> flow_group() const;
bool updateParent(const std::string& parent);
bool updateInjection(const GroupInjectionProperties& injection);
bool updateProduction(const GroupProductionProperties& production);
bool isProductionGroup() const;
bool isInjectionGroup() const;
void setProductionGroup();
void setInjectionGroup();
double getGroupEfficiencyFactor(bool network = false) const;
bool useEfficiencyInNetwork() const;
void recordSatelliteProduction();
bool hasSatelliteProduction() const;
void recordSatelliteInjection();
bool hasSatelliteInjection() const;
std::size_t numWells() const;
bool addGroup(const std::string& group_name);
bool hasGroup(const std::string& group_name) const;
void delGroup(const std::string& group_name);
bool addWell(const std::string& well_name);
bool hasWell(const std::string& well_name) const;
void delWell(const std::string& well_name);
const std::vector<std::string>& wells() const;
const std::vector<std::string>& groups() const;
bool wellgroup() const;
ProductionControls productionControls(const SummaryState& st) const;
InjectionControls injectionControls(Phase phase, const SummaryState& st) const;
bool hasInjectionControl(Phase phase) const;
const GroupProductionProperties& productionProperties() const;
const std::map<Phase , GroupInjectionProperties>& injectionProperties() const;
const GroupInjectionProperties& injectionProperties(Phase phase) const;
const GroupType& getGroupType() const;
ProductionCMode prod_cmode() const;
InjectionCMode injection_cmode() const;
Phase injection_phase() const;
bool has_control(ProductionCMode control) const;
bool has_control(Phase phase, InjectionCMode control) const;
bool productionGroupControlAvailable() const;
bool injectionGroupControlAvailable(const Phase phase) const;
const std::optional<GPMaint>& gpmaint() const;
void set_gpmaint(GPMaint gpmaint);
void set_gpmaint();
bool has_gpmaint_control(Phase phase, InjectionCMode cmode) const;
bool has_gpmaint_control(ProductionCMode cmode) const;
bool as_choke() const;
void as_choke(const std::string& group);
bool operator==(const Group& data) const;
const std::optional<Phase>& topup_phase() const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_name);
serializer(m_insert_index);
serializer(udq_undefined);
serializer(unit_system);
serializer(group_type);
serializer(gefac);
serializer(use_efficiency_in_network);
serializer(satellite_status);
serializer(parent_group);
serializer(m_wells);
serializer(m_groups);
serializer(injection_properties);
serializer(production_properties);
serializer(m_topup_phase);
serializer(m_gpmaint);
}
private:
bool hasType(GroupType gtype) const;
void addType(GroupType new_gtype);
std::string m_name{};
std::size_t m_insert_index{};
double udq_undefined{};
UnitSystem unit_system{};
GroupType group_type{};
double gefac{};
bool use_efficiency_in_network{};
std::uint_least8_t satellite_status{};
std::string parent_group{};
IOrderSet<std::string> m_wells{};
IOrderSet<std::string> m_groups{};
std::map<Phase, GroupInjectionProperties> injection_properties{};
GroupProductionProperties production_properties{};
std::optional<Phase> m_topup_phase{};
std::optional<GPMaint> m_gpmaint{};
std::optional<std::string> m_choke_group{};
};
Group::GroupType operator |(Group::GroupType lhs, Group::GroupType rhs);
Group::GroupType operator &(Group::GroupType lhs, Group::GroupType rhs);
} // namespace Opm
#endif // OPM_GROUP_HPP
Opm::GPMaint
Definition GPMaint.hpp:32
Opm::Group::hasSatelliteProduction
bool hasSatelliteProduction() const
Predicate for whether or not this group is tagged as a satellite producer.
Definition Group.cpp:915
Opm::Group::hasSatelliteInjection
bool hasSatelliteInjection() const
Predicate for whether or not this group is tagged as a satellite injector.
Definition Group.cpp:928
Opm::Group::recordSatelliteInjection
void recordSatelliteInjection()
Tag current group as being one with satellite injection.
Definition Group.cpp:921
Opm::Group::recordSatelliteProduction
void recordSatelliteProduction()
Tag current group as being one with satellite production.
Definition Group.cpp:908
Opm::Serializer
Class for (de-)serializing.
Definition Serializer.hpp:94
Opm::SummaryState
Definition SummaryState.hpp:72
Opm::UDAValue
Definition UDAValue.hpp:31
Opm::UDQActive
Internalised representation of all UDAs in a simulation run.
Definition UDQActive.hpp:50
Opm::UDQConfig
Collection of all user-defined quantities in the current simulation run.
Definition UDQConfig.hpp:69
Opm::UnitSystem
Definition UnitSystem.hpp:34
Opm
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30
Opm::Group::GroupInjectionProperties
Definition Group.hpp:132
Opm::Group::GroupLimitAction
Definition Group.hpp:179
Opm::Group::GroupProductionProperties
Definition Group.hpp:223
Opm::Group::InjectionControls
Definition Group.hpp:208
Opm::Group::ProductionControls
Definition Group.hpp:265
Opm::RestartIO::RstGroup
Definition group.hpp:38