Enum refactor EconLimits

This commit is contained in:
Joakim Hove 2019-08-31 08:10:44 +02:00
parent 9e6f8bd1c1
commit a449636dde
7 changed files with 238 additions and 228 deletions

View File

@ -191,29 +191,6 @@ namespace Opm {
}
namespace WellEcon {
enum WorkoverEnum {
NONE = 0,
CON = 1, // CON
CONP = 2, // +CON
WELL = 3,
PLUG = 4,
// the following two only related to workover action
// on exceeding secondary water cut limit
LAST = 5,
RED = 6
};
const std::string WorkoverEnumToString(WorkoverEnum enumValue);
WorkoverEnum WorkoverEnumFromString(const std::string& stringValue);
enum QuantityLimitEnum {
RATE = 0,
POTN = 1
};
const std::string QuantityLimitEnumToString(QuantityLimitEnum enumValue);
QuantityLimitEnum QuantityLimitEnumFromString(const std::string& stringValue);
}
enum class GroupWellQueryMode {
Immediate,

View File

@ -58,6 +58,9 @@ struct WellGuideRate {
class Well2 {
public:
enum class Status {
OPEN = 1,
STOP = 2,

View File

@ -28,8 +28,33 @@ namespace Opm {
class DeckRecord;
class WellEconProductionLimits{
class WellEconProductionLimits {
public:
enum class QuantityLimit {
RATE = 0,
POTN = 1
};
static const std::string QuantityLimit2String(QuantityLimit enumValue);
static QuantityLimit QuantityLimitFromString(const std::string& stringValue);
enum class EconWorkover {
NONE = 0,
CON = 1, // CON
CONP = 2, // +CON
WELL = 3,
PLUG = 4,
// the following two only related to workover action
// on exceeding secondary water cut limit
LAST = 5,
RED = 6
};
static std::string EconWorkover2String(EconWorkover enumValue);
static EconWorkover EconWorkoverFromString(const std::string& stringValue);
explicit WellEconProductionLimits(const DeckRecord& record);
WellEconProductionLimits();
@ -37,128 +62,53 @@ namespace Opm {
// for the moment.
// limit switch on?
bool onAnyEffectiveLimit() const {
return (onAnyRatioLimit() ||
onAnyRateLimit());
};
bool onAnyRatioLimit() const {
return (onMaxWaterCut() ||
onMaxGasOilRatio() ||
onMaxWaterGasRatio() ||
onMaxGasLiquidRatio());
};
bool onAnyRateLimit() const {
return (onMinOilRate() ||
onMinGasRate() ||
onMinLiquidRate() ||
onMinReservoirFluidRate());
};
bool onMinOilRate() const {
return (m_min_oil_rate > 0.0);
};
bool onMinGasRate() const {
return (m_min_gas_rate > 0.0);
};
bool onMaxWaterCut() const {
return (m_max_water_cut > 0.0);
};
bool onMaxGasOilRatio() const {
return (m_max_gas_oil_ratio > 0.0);
};
bool onMaxWaterGasRatio() const {
return (m_max_water_gas_ratio > 0.0);
};
bool onSecondaryMaxWaterCut() const {
return (m_secondary_max_water_cut > 0.0);
};
bool onMaxGasLiquidRatio() const {
return (m_max_gas_oil_ratio > 0.0);
};
// assuming Celsius temperature is used internally
bool onMaxTemperature() const {
return (m_max_temperature > -273.15);
};
bool onMinLiquidRate() const {
return (m_min_liquid_rate > 0.0);
};
bool onMinReservoirFluidRate() const {
return (m_min_reservoir_fluid_rate > 0.0);
};
// not sure what will happen if the followon well is a well does not exist.
bool validFollowonWell() const {
return (m_followon_well != "'");
};
bool requireWorkover() const {
return (m_workover != WellEcon::NONE);
};
bool requireSecondaryWorkover() const {
return (m_workover_secondary != WellEcon::NONE);
}
bool endRun() const {
return m_end_run;
}
double minOilRate() const { return m_min_oil_rate; };
double minGasRate() const { return m_min_gas_rate; };
double maxWaterCut() const { return m_max_water_cut; };
double maxGasOilRatio() const { return m_max_gas_oil_ratio; };
double maxWaterGasRatio() const { return m_max_water_gas_ratio; };
WellEcon::WorkoverEnum workover() const { return m_workover; };
const std::string& followonWell() const { return m_followon_well; };
WellEcon::QuantityLimitEnum quantityLimit() const {return m_quantity_limit; };
double maxSecondaryMaxWaterCut() const { return m_secondary_max_water_cut; };
WellEcon::WorkoverEnum workoverSecondary() const { return m_workover_secondary; };
double maxGasLiquidRatio() const { return m_max_gas_liquid_ratio; };
double minLiquidRate() const { return m_min_liquid_rate; };
double maxTemperature() const { return m_max_temperature; };
double minReservoirFluidRate() const { return m_min_reservoir_fluid_rate; };
bool onAnyEffectiveLimit() const;
bool onAnyRatioLimit() const;
bool onAnyRateLimit() const;
bool onMinOilRate() const;
bool onMinGasRate() const;
bool onMaxWaterCut() const;
bool onMaxGasOilRatio() const;
bool onMaxWaterGasRatio() const;
bool onSecondaryMaxWaterCut() const;
bool onMaxGasLiquidRatio() const;
// assuming Celsius temperature is used internally;
bool onMaxTemperature() const;
bool onMinLiquidRate() const;
bool onMinReservoirFluidRate() const;
// not sure what will happen if the followon well is a well does not exist.;
bool validFollowonWell() const;
bool requireWorkover() const;
bool requireSecondaryWorkover() const;
bool endRun() const;
double minOilRate() const;
double minGasRate() const;
double maxWaterCut() const;
double maxGasOilRatio() const;
double maxWaterGasRatio() const;
EconWorkover workover() const;
const std::string& followonWell() const;
QuantityLimit quantityLimit() const;
double maxSecondaryMaxWaterCut() const;
EconWorkover workoverSecondary() const;
double maxGasLiquidRatio() const;
double minLiquidRate() const;
double maxTemperature() const;
double minReservoirFluidRate() const;
bool operator==(const WellEconProductionLimits& other) const;
bool operator!=(const WellEconProductionLimits& other) const;
private:
double m_min_oil_rate;
double m_min_gas_rate;
double m_max_water_cut;
double m_max_gas_oil_ratio;
double m_max_water_gas_ratio;
WellEcon::WorkoverEnum m_workover;
EconWorkover m_workover;
bool m_end_run;
std::string m_followon_well;
WellEcon::QuantityLimitEnum m_quantity_limit;
QuantityLimit m_quantity_limit;
double m_secondary_max_water_cut;
WellEcon::WorkoverEnum m_workover_secondary;
EconWorkover m_workover_secondary;
double m_max_gas_liquid_ratio;
double m_min_liquid_rate;
double m_max_temperature;

View File

@ -401,78 +401,6 @@ namespace Opm {
}
namespace WellEcon {
const std::string WorkoverEnumToString(WorkoverEnum enumValue) {
switch(enumValue) {
case NONE:
return "NONE";
case CON:
return "CON";
case CONP:
return "+CON";
case WELL:
return "WELL";
case PLUG:
return "PLUG";
case LAST:
return "LAST";
case RED:
return "RED";
default:
throw std::invalid_argument("unhandled WorkoverEnum value");
}
}
WorkoverEnum WorkoverEnumFromString( const std::string& string ) {
if (string == "NONE") {
return NONE;
} else if (string == "CON") {
return CON;
} else if (string == "+CON") {
return CONP;
} else if (string == "WELL") {
return WELL;
} else if (string == "PLUG") {
return PLUG;
} else if (string == "LAST") {
return LAST;
} else if (string == "RED") {
return RED;
} else {
throw std::invalid_argument("Unknown enum string: " + string + " for WorkoverEnum");
}
}
const std::string QuantityLimitEnumToString(QuantityLimitEnum enumValue) {
switch(enumValue) {
case RATE:
return "RATE";
case POTN:
return "POTN";
default:
throw std::invalid_argument("unhandled QuantityLimitvalue");
}
}
QuantityLimitEnum QuantityLimitEnumFromString(const std::string& string ) {
if (string == "RATE") {
return RATE;
} else if (string == "POTN") {
return POTN;
} else {
throw std::invalid_argument("Unknown enum string: " + string + " for QuantityLimitEnum");
}
}
}
GroupType operator|(GroupType lhs, GroupType rhs) {
return static_cast<GroupType>(static_cast<std::underlying_type<GroupType>::type>(lhs) | static_cast<std::underlying_type<GroupType>::type>(rhs));
}

View File

@ -962,4 +962,5 @@ Well2::ProducerCMode Well2::ProducerCModeFromString( const std::string& stringVa
else
throw std::invalid_argument("Unknown enum state string: " + stringValue );
}
}

View File

@ -34,10 +34,10 @@ namespace Opm {
, m_max_water_cut(0.0)
, m_max_gas_oil_ratio(0.0)
, m_max_water_gas_ratio(0.0)
, m_workover(WellEcon::NONE)
, m_workover(EconWorkover::NONE)
, m_end_run(false)
, m_followon_well("'")
, m_quantity_limit(WellEcon::RATE)
, m_quantity_limit(QuantityLimit::RATE)
, m_secondary_max_water_cut(0.0)
, m_workover_secondary(m_workover)
, m_max_gas_liquid_ratio(0.0)
@ -55,17 +55,17 @@ namespace Opm {
, m_max_water_cut(record.getItem("MAX_WATER_CUT").get<UDAValue>(0).get<double>())
, m_max_gas_oil_ratio(record.getItem("MAX_GAS_OIL_RATIO").get<UDAValue>(0).get<double>())
, m_max_water_gas_ratio(record.getItem("MAX_WATER_GAS_RATIO").get<UDAValue>(0).get<double>())
, m_workover(WellEcon::WorkoverEnumFromString(record.getItem("WORKOVER_RATIO_LIMIT").getTrimmedString(0)))
, m_workover(EconWorkoverFromString(record.getItem("WORKOVER_RATIO_LIMIT").getTrimmedString(0)))
, m_end_run(false)
, m_followon_well(record.getItem("FOLLOW_ON_WELL").getTrimmedString(0))
, m_quantity_limit(WellEcon::QuantityLimitEnumFromString(record.getItem("LIMITED_QUANTITY").getTrimmedString(0)))
, m_quantity_limit(QuantityLimitFromString(record.getItem("LIMITED_QUANTITY").getTrimmedString(0)))
, m_secondary_max_water_cut(record.getItem("SECOND_MAX_WATER_CUT").get<double>(0))
, m_max_gas_liquid_ratio(record.getItem("MAX_GAS_LIQUID_RATIO").get<double>(0))
, m_min_liquid_rate(record.getItem("MIN_LIQUID_PRODCUTION_RATE").getSIDouble(0))
, m_min_reservoir_fluid_rate(record.getItem("MIN_RES_FLUID_RATE").getSIDouble(0))
{
assert(m_workover != WellEcon::LAST);
assert(m_workover != WellEcon::RED);
assert(m_workover != EconWorkover::LAST);
assert(m_workover != EconWorkover::RED);
if (record.getItem("MAX_TEMP").hasValue(0)) {
m_max_temperature = record.getItem("MAX_TEMP").getSIDouble(0);
@ -76,7 +76,7 @@ namespace Opm {
if (record.getItem("WORKOVER_SECOND_WATER_CUT_LIMIT").hasValue(0)) {
const std::string string_workover = record.getItem("WORKOVER_SECOND_WATER_CUT_LIMIT").getTrimmedString(0);
m_workover_secondary = WellEcon::WorkoverEnumFromString(string_workover);
m_workover_secondary = EconWorkoverFromString(string_workover);
} else {
m_workover_secondary = m_workover;
}
@ -116,8 +116,159 @@ namespace Opm {
}
bool WellEconProductionLimits::operator!=(const WellEconProductionLimits& other) const {
return (!(*this == other));
bool WellEconProductionLimits::operator!=(const WellEconProductionLimits& other) const {
return (!(*this == other));
}
// limit switch on?
bool WellEconProductionLimits::onAnyEffectiveLimit() const {
return (onAnyRatioLimit() || onAnyRateLimit());
};
bool WellEconProductionLimits::onAnyRatioLimit() const {
return (onMaxWaterCut() || onMaxGasOilRatio() || onMaxWaterGasRatio() ||
onMaxGasLiquidRatio());
};
bool WellEconProductionLimits::onAnyRateLimit() const {
return (onMinOilRate() || onMinGasRate() || onMinLiquidRate() ||
onMinReservoirFluidRate());
};
bool WellEconProductionLimits::onMinOilRate() const { return (m_min_oil_rate > 0.0); };
bool WellEconProductionLimits::onMinGasRate() const { return (m_min_gas_rate > 0.0); };
bool WellEconProductionLimits::onMaxWaterCut() const { return (m_max_water_cut > 0.0); };
bool WellEconProductionLimits::onMaxGasOilRatio() const { return (m_max_gas_oil_ratio > 0.0); };
bool WellEconProductionLimits::onMaxWaterGasRatio() const { return (m_max_water_gas_ratio > 0.0); };
bool WellEconProductionLimits::onSecondaryMaxWaterCut() const {
return (m_secondary_max_water_cut > 0.0);
};
bool WellEconProductionLimits::onMaxGasLiquidRatio() const { return (m_max_gas_oil_ratio > 0.0); };
// assuming Celsius temperature is used internally
bool WellEconProductionLimits::onMaxTemperature() const { return (m_max_temperature > -273.15); };
bool WellEconProductionLimits::onMinLiquidRate() const { return (m_min_liquid_rate > 0.0); };
bool WellEconProductionLimits::onMinReservoirFluidRate() const {
return (m_min_reservoir_fluid_rate > 0.0);
};
// not sure what will happen if the followon well is a well does not exist.
bool WellEconProductionLimits::validFollowonWell() const { return (m_followon_well != "'"); };
bool WellEconProductionLimits::requireWorkover() const {
return (m_workover != EconWorkover::NONE);
};
bool WellEconProductionLimits::requireSecondaryWorkover() const {
return (m_workover_secondary != EconWorkover::NONE);
}
bool WellEconProductionLimits::endRun() const { return m_end_run; }
double WellEconProductionLimits::minOilRate() const { return m_min_oil_rate; };
double WellEconProductionLimits::minGasRate() const { return m_min_gas_rate; };
double WellEconProductionLimits::maxWaterCut() const { return m_max_water_cut; };
double WellEconProductionLimits::maxGasOilRatio() const { return m_max_gas_oil_ratio; };
double WellEconProductionLimits::maxWaterGasRatio() const { return m_max_water_gas_ratio; };
double WellEconProductionLimits::maxGasLiquidRatio() const { return m_max_gas_liquid_ratio; };
double WellEconProductionLimits::minLiquidRate() const { return m_min_liquid_rate; };
double WellEconProductionLimits::maxTemperature() const { return m_max_temperature; };
double WellEconProductionLimits::minReservoirFluidRate() const { return m_min_reservoir_fluid_rate; };
WellEconProductionLimits::EconWorkover WellEconProductionLimits::workover() const { return m_workover; };
const std::string& WellEconProductionLimits::followonWell() const { return m_followon_well; };
WellEconProductionLimits::QuantityLimit WellEconProductionLimits::quantityLimit() const {
return m_quantity_limit;
};
double WellEconProductionLimits::maxSecondaryMaxWaterCut() const {
return m_secondary_max_water_cut;
};
WellEconProductionLimits::EconWorkover WellEconProductionLimits::workoverSecondary() const {
return m_workover_secondary;
};
std::string WellEconProductionLimits::EconWorkover2String(EconWorkover enumValue) {
switch(enumValue) {
case EconWorkover::NONE:
return "NONE";
case EconWorkover::CON:
return "CON";
case EconWorkover::CONP:
return "+CON";
case EconWorkover::WELL:
return "WELL";
case EconWorkover::PLUG:
return "PLUG";
case EconWorkover::LAST:
return "LAST";
case EconWorkover::RED:
return "RED";
default:
throw std::invalid_argument("unhandled WorkoverEnum value");
}
}
WellEconProductionLimits::EconWorkover WellEconProductionLimits::EconWorkoverFromString(const std::string& stringValue) {
if (stringValue == "NONE")
return EconWorkover::NONE;
else if (stringValue == "CON")
return EconWorkover::CON;
else if (stringValue == "+CON")
return EconWorkover::CONP;
else if (stringValue == "WELL")
return EconWorkover::WELL;
else if (stringValue == "PLUG")
return EconWorkover::PLUG;
else if (stringValue == "LAST")
return EconWorkover::LAST;
else if (stringValue == "RED")
return EconWorkover::RED;
else
throw std::invalid_argument("Unknown enum stringValue: " + stringValue +
" for WorkoverEnum");
}
const std::string WellEconProductionLimits::QuantityLimit2String(QuantityLimit enumValue) {
switch(enumValue) {
case QuantityLimit::RATE:
return "RATE";
case QuantityLimit::POTN:
return "POTN";
default:
throw std::invalid_argument("unhandled QuantityLimitvalue");
}
}
WellEconProductionLimits::QuantityLimit WellEconProductionLimits::QuantityLimitFromString(const std::string& string ) {
if (string == "RATE") {
return QuantityLimit::RATE;
} else if (string == "POTN") {
return QuantityLimit::POTN;
} else {
throw std::invalid_argument("Unknown enum string: " + string + " for QuantityLimitEnum");
}
}
} // namespace Opm

View File

@ -707,9 +707,9 @@ BOOST_AUTO_TEST_CASE(WellTestWECON) {
BOOST_CHECK_EQUAL(econ_limit1.maxGasOilRatio(), 0.0);
BOOST_CHECK_EQUAL(econ_limit1.endRun(), false);
BOOST_CHECK_EQUAL(econ_limit1.followonWell(), "'");
BOOST_CHECK_EQUAL(econ_limit1.quantityLimit(), WellEcon::RATE);
BOOST_CHECK_EQUAL(econ_limit1.workover(), WellEcon::CON);
BOOST_CHECK_EQUAL(econ_limit1.workoverSecondary(), WellEcon::CON);
BOOST_CHECK(econ_limit1.quantityLimit() == WellEconProductionLimits::QuantityLimit::RATE);
BOOST_CHECK(econ_limit1.workover() == WellEconProductionLimits::EconWorkover::CON);
BOOST_CHECK(econ_limit1.workoverSecondary() == WellEconProductionLimits::EconWorkover::CON);
BOOST_CHECK(econ_limit1.requireWorkover());
BOOST_CHECK(econ_limit1.requireSecondaryWorkover());
BOOST_CHECK(!(econ_limit1.validFollowonWell()));
@ -729,9 +729,9 @@ BOOST_AUTO_TEST_CASE(WellTestWECON) {
BOOST_CHECK_EQUAL(econ_limit2.maxGasOilRatio(), 0.0);
BOOST_CHECK_EQUAL(econ_limit2.endRun(), false);
BOOST_CHECK_EQUAL(econ_limit2.followonWell(), "'");
BOOST_CHECK_EQUAL(econ_limit2.quantityLimit(), WellEcon::RATE);
BOOST_CHECK_EQUAL(econ_limit2.workover(), WellEcon::CON);
BOOST_CHECK_EQUAL(econ_limit2.workoverSecondary(), WellEcon::CON);
BOOST_CHECK(econ_limit2.quantityLimit() == WellEconProductionLimits::QuantityLimit::RATE);
BOOST_CHECK(econ_limit2.workover() == WellEconProductionLimits::EconWorkover::CON);
BOOST_CHECK(econ_limit2.workoverSecondary() == WellEconProductionLimits::EconWorkover::CON);
BOOST_CHECK(econ_limit2.requireWorkover());
BOOST_CHECK(econ_limit2.requireSecondaryWorkover());
BOOST_CHECK(!(econ_limit2.validFollowonWell()));
@ -753,9 +753,9 @@ BOOST_AUTO_TEST_CASE(WellTestWECON) {
BOOST_CHECK_EQUAL(econ_limit1.maxGasOilRatio(), 0.0);
BOOST_CHECK_EQUAL(econ_limit1.endRun(), false);
BOOST_CHECK_EQUAL(econ_limit1.followonWell(), "'");
BOOST_CHECK_EQUAL(econ_limit1.quantityLimit(), WellEcon::RATE);
BOOST_CHECK_EQUAL(econ_limit1.workover(), WellEcon::NONE);
BOOST_CHECK_EQUAL(econ_limit1.workoverSecondary(), WellEcon::NONE);
BOOST_CHECK(econ_limit1.quantityLimit() == WellEconProductionLimits::QuantityLimit::RATE);
BOOST_CHECK(econ_limit1.workover() == WellEconProductionLimits::EconWorkover::NONE);
BOOST_CHECK(econ_limit1.workoverSecondary() == WellEconProductionLimits::EconWorkover::NONE);
BOOST_CHECK(!(econ_limit1.requireWorkover()));
BOOST_CHECK(!(econ_limit1.requireSecondaryWorkover()));
BOOST_CHECK(!(econ_limit1.validFollowonWell()));
@ -775,9 +775,9 @@ BOOST_AUTO_TEST_CASE(WellTestWECON) {
BOOST_CHECK_EQUAL(econ_limit2.maxGasOilRatio(), 0.0);
BOOST_CHECK_EQUAL(econ_limit2.endRun(), false);
BOOST_CHECK_EQUAL(econ_limit2.followonWell(), "'");
BOOST_CHECK_EQUAL(econ_limit2.quantityLimit(), WellEcon::RATE);
BOOST_CHECK_EQUAL(econ_limit2.workover(), WellEcon::CON);
BOOST_CHECK_EQUAL(econ_limit2.workoverSecondary(), WellEcon::CON);
BOOST_CHECK(econ_limit2.quantityLimit() == WellEconProductionLimits::QuantityLimit::RATE);
BOOST_CHECK(econ_limit2.workover() == WellEconProductionLimits::EconWorkover::CON);
BOOST_CHECK(econ_limit2.workoverSecondary() == WellEconProductionLimits::EconWorkover::CON);
BOOST_CHECK(econ_limit2.requireWorkover());
BOOST_CHECK(econ_limit2.requireSecondaryWorkover());
BOOST_CHECK(!(econ_limit2.validFollowonWell()));