21aaceaed9
There has never really been a natural home for initial properties that aren't InitConfig, meaning information such as phases in the deck and other runspec information hasn't had a natural home. This patch introduces the Runspec object on EclipseState for phase information and other similar properties that are interesting and static for when setting up parameters etc. for simulation, that aren't all that interesting once simulation starts. An additional benefit is a leaner implementation for the phase enum and some stricter semantics via enum classes.
687 lines
21 KiB
C++
687 lines
21 KiB
C++
/*
|
|
Copyright 2013 Statoil 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/>.
|
|
*/
|
|
|
|
#include <string>
|
|
#include <stdexcept>
|
|
|
|
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
|
|
|
|
namespace Opm {
|
|
|
|
namespace WellCompletion {
|
|
|
|
std::string
|
|
DirectionEnum2String(const DirectionEnum enumValue)
|
|
{
|
|
std::string stringValue;
|
|
|
|
switch (enumValue) {
|
|
case DirectionEnum::X:
|
|
stringValue = "X";
|
|
break;
|
|
|
|
case DirectionEnum::Y:
|
|
stringValue = "Y";
|
|
break;
|
|
|
|
case DirectionEnum::Z:
|
|
stringValue = "Z";
|
|
break;
|
|
}
|
|
|
|
return stringValue;
|
|
}
|
|
|
|
DirectionEnum
|
|
DirectionEnumFromString(const std::string& s )
|
|
{
|
|
DirectionEnum direction;
|
|
|
|
if (s == "X") { direction = DirectionEnum::X; }
|
|
else if (s == "Y") { direction = DirectionEnum::Y; }
|
|
else if (s == "Z") { direction = DirectionEnum::Z; }
|
|
else {
|
|
std::string msg = "Unsupported completion direction " + s;
|
|
throw std::invalid_argument(msg);
|
|
}
|
|
|
|
return direction;
|
|
}
|
|
|
|
|
|
const std::string StateEnum2String( StateEnum enumValue ) {
|
|
switch( enumValue ) {
|
|
case OPEN:
|
|
return "OPEN";
|
|
case AUTO:
|
|
return "AUTO";
|
|
case SHUT:
|
|
return "SHUT";
|
|
default:
|
|
throw std::invalid_argument("Unhandled enum value");
|
|
}
|
|
}
|
|
|
|
|
|
StateEnum StateEnumFromString( const std::string& stringValue ) {
|
|
if (stringValue == "OPEN")
|
|
return OPEN;
|
|
else if (stringValue == "SHUT")
|
|
return SHUT;
|
|
else if (stringValue == "STOP")
|
|
return SHUT;
|
|
else if (stringValue == "AUTO")
|
|
return AUTO;
|
|
else
|
|
throw std::invalid_argument("Unknown enum state string: " + stringValue );
|
|
}
|
|
|
|
|
|
const std::string CompletionOrderEnum2String( CompletionOrderEnum enumValue ) {
|
|
switch( enumValue ) {
|
|
case DEPTH:
|
|
return "DEPTH";
|
|
case INPUT:
|
|
return "INPUT";
|
|
case TRACK:
|
|
return "TRACK";
|
|
default:
|
|
throw std::invalid_argument("Unhandled enum value");
|
|
}
|
|
|
|
}
|
|
|
|
CompletionOrderEnum CompletionOrderEnumFromString(const std::string& stringValue ) {
|
|
if (stringValue == "DEPTH")
|
|
return DEPTH;
|
|
else if (stringValue == "INPUT")
|
|
return INPUT;
|
|
else if (stringValue == "TRACK")
|
|
return TRACK;
|
|
else
|
|
throw std::invalid_argument("Unknown enum state string: " + stringValue );
|
|
}
|
|
}
|
|
|
|
|
|
/*****************************************************************/
|
|
|
|
namespace GroupInjection {
|
|
|
|
const std::string ControlEnum2String( ControlEnum enumValue ) {
|
|
switch( enumValue ) {
|
|
case NONE:
|
|
return "NONE";
|
|
case RATE:
|
|
return "RATE";
|
|
case RESV:
|
|
return "RESV";
|
|
case REIN:
|
|
return "REIN";
|
|
case VREP:
|
|
return "VREP";
|
|
case FLD:
|
|
return "FLD";
|
|
default:
|
|
throw std::invalid_argument("Unhandled enum value");
|
|
}
|
|
}
|
|
|
|
|
|
ControlEnum ControlEnumFromString( const std::string& stringValue ) {
|
|
if (stringValue == "NONE")
|
|
return NONE;
|
|
else if (stringValue == "RATE")
|
|
return RATE;
|
|
else if (stringValue == "RESV")
|
|
return RESV;
|
|
else if (stringValue == "REIN")
|
|
return REIN;
|
|
else if (stringValue == "VREP")
|
|
return VREP;
|
|
else if (stringValue == "FLD")
|
|
return FLD;
|
|
else
|
|
throw std::invalid_argument("Unknown enum state string: " + stringValue );
|
|
}
|
|
|
|
}
|
|
|
|
/*****************************************************************/
|
|
|
|
namespace GroupProduction {
|
|
|
|
const std::string ControlEnum2String( ControlEnum enumValue ) {
|
|
switch( enumValue ) {
|
|
case NONE:
|
|
return "NONE";
|
|
case ORAT:
|
|
return "ORAT";
|
|
case WRAT:
|
|
return "WRAT";
|
|
case GRAT:
|
|
return "GRAT";
|
|
case LRAT:
|
|
return "LRAT";
|
|
case CRAT:
|
|
return "CRAT";
|
|
case RESV:
|
|
return "RESV";
|
|
case PRBL:
|
|
return "PRBL";
|
|
case FLD:
|
|
return "FLD";
|
|
default:
|
|
throw std::invalid_argument("Unhandled enum value");
|
|
}
|
|
}
|
|
|
|
|
|
ControlEnum ControlEnumFromString( const std::string& stringValue ) {
|
|
if (stringValue == "NONE")
|
|
return NONE;
|
|
else if (stringValue == "ORAT")
|
|
return ORAT;
|
|
else if (stringValue == "WRAT")
|
|
return WRAT;
|
|
else if (stringValue == "GRAT")
|
|
return GRAT;
|
|
else if (stringValue == "LRAT")
|
|
return LRAT;
|
|
else if (stringValue == "CRAT")
|
|
return CRAT;
|
|
else if (stringValue == "RESV")
|
|
return RESV;
|
|
else if (stringValue == "PRBL")
|
|
return PRBL;
|
|
else if (stringValue == "FLD")
|
|
return FLD;
|
|
else
|
|
throw std::invalid_argument("Unknown enum state string: " + stringValue );
|
|
}
|
|
}
|
|
|
|
/*****************************************************************/
|
|
namespace GroupProductionExceedLimit {
|
|
|
|
const std::string ActionEnum2String( ActionEnum enumValue ) {
|
|
switch(enumValue) {
|
|
case NONE:
|
|
return "NONE";
|
|
case CON:
|
|
return "CON";
|
|
case CON_PLUS:
|
|
return "+CON";
|
|
case WELL:
|
|
return "WELL";
|
|
case PLUG:
|
|
return "PLUG";
|
|
case RATE:
|
|
return "RATE";
|
|
default:
|
|
throw std::invalid_argument("unhandled enum value");
|
|
}
|
|
}
|
|
|
|
|
|
ActionEnum ActionEnumFromString( const std::string& stringValue ) {
|
|
|
|
if (stringValue == "NONE")
|
|
return NONE;
|
|
else if (stringValue == "CON")
|
|
return CON;
|
|
else if (stringValue == "+CON")
|
|
return CON_PLUS;
|
|
else if (stringValue == "WELL")
|
|
return WELL;
|
|
else if (stringValue == "PLUG")
|
|
return PLUG;
|
|
else if (stringValue == "RATE")
|
|
return RATE;
|
|
else
|
|
throw std::invalid_argument("Unknown enum state string: " + stringValue );
|
|
}
|
|
|
|
}
|
|
|
|
/*****************************************************************/
|
|
|
|
namespace WellProducer {
|
|
|
|
const std::string ControlMode2String( ControlModeEnum enumValue ) {
|
|
switch( enumValue ) {
|
|
case ORAT:
|
|
return "ORAT";
|
|
case WRAT:
|
|
return "WRAT";
|
|
case GRAT:
|
|
return "GRAT";
|
|
case LRAT:
|
|
return "LRAT";
|
|
case CRAT:
|
|
return "CRAT";
|
|
case RESV:
|
|
return "RESV";
|
|
case BHP:
|
|
return "BHP";
|
|
case THP:
|
|
return "THP";
|
|
case GRUP:
|
|
return "GRUP";
|
|
default:
|
|
throw std::invalid_argument("unhandled enum value");
|
|
}
|
|
}
|
|
|
|
ControlModeEnum ControlModeFromString( const std::string& stringValue ) {
|
|
if (stringValue == "ORAT")
|
|
return ORAT;
|
|
else if (stringValue == "WRAT")
|
|
return WRAT;
|
|
else if (stringValue == "GRAT")
|
|
return GRAT;
|
|
else if (stringValue == "LRAT")
|
|
return LRAT;
|
|
else if (stringValue == "CRAT")
|
|
return CRAT;
|
|
else if (stringValue == "RESV")
|
|
return RESV;
|
|
else if (stringValue == "BHP")
|
|
return BHP;
|
|
else if (stringValue == "THP")
|
|
return THP;
|
|
else if (stringValue == "GRUP")
|
|
return GRUP;
|
|
else if (stringValue == "NONE")
|
|
return NONE;
|
|
else
|
|
throw std::invalid_argument("Unknown enum state string: " + stringValue );
|
|
}
|
|
}
|
|
|
|
|
|
namespace WellInjector {
|
|
|
|
const std::string Type2String( TypeEnum enumValue ) {
|
|
switch( enumValue ) {
|
|
case OIL:
|
|
return "OIL";
|
|
case GAS:
|
|
return "GAS";
|
|
case WATER:
|
|
return "WATER";
|
|
case MULTI:
|
|
return "MULTI";
|
|
default:
|
|
throw std::invalid_argument("unhandled enum value");
|
|
}
|
|
}
|
|
|
|
TypeEnum TypeFromString( const std::string& stringValue ) {
|
|
if (stringValue == "OIL")
|
|
return OIL;
|
|
else if (stringValue == "WATER")
|
|
return WATER;
|
|
else if (stringValue == "WAT")
|
|
return WATER;
|
|
else if (stringValue == "GAS")
|
|
return GAS;
|
|
else if (stringValue == "MULTI")
|
|
return MULTI;
|
|
else
|
|
throw std::invalid_argument("Unknown enum state string: " + stringValue );
|
|
}
|
|
|
|
/*****************************************************************/
|
|
|
|
const std::string ControlMode2String( ControlModeEnum enumValue ) {
|
|
switch( enumValue ) {
|
|
case RESV:
|
|
return "RESV";
|
|
case RATE:
|
|
return "RATE";
|
|
case BHP:
|
|
return "BHP";
|
|
case THP:
|
|
return "THP";
|
|
case GRUP:
|
|
return "GRUP";
|
|
default:
|
|
throw std::invalid_argument("unhandled enum value");
|
|
}
|
|
}
|
|
|
|
ControlModeEnum ControlModeFromString( const std::string& stringValue ) {
|
|
if (stringValue == "RATE")
|
|
return RATE;
|
|
else if (stringValue == "RESV")
|
|
return RESV;
|
|
else if (stringValue == "BHP")
|
|
return BHP;
|
|
else if (stringValue == "THP")
|
|
return THP;
|
|
else if (stringValue == "GRUP")
|
|
return GRUP;
|
|
else
|
|
throw std::invalid_argument("Unknown enum state string: " + stringValue );
|
|
}
|
|
|
|
}
|
|
|
|
|
|
namespace WellCommon {
|
|
|
|
const std::string Status2String(StatusEnum enumValue) {
|
|
switch( enumValue ) {
|
|
case OPEN:
|
|
return "OPEN";
|
|
case SHUT:
|
|
return "SHUT";
|
|
case AUTO:
|
|
return "AUTO";
|
|
case STOP:
|
|
return "STOP";
|
|
default:
|
|
throw std::invalid_argument("unhandled enum value");
|
|
}
|
|
}
|
|
|
|
|
|
StatusEnum StatusFromString(const std::string& stringValue) {
|
|
if (stringValue == "OPEN")
|
|
return OPEN;
|
|
else if (stringValue == "SHUT")
|
|
return SHUT;
|
|
else if (stringValue == "STOP")
|
|
return STOP;
|
|
else if (stringValue == "AUTO")
|
|
return AUTO;
|
|
else
|
|
throw std::invalid_argument("Unknown enum state string: " + stringValue );
|
|
}
|
|
|
|
}
|
|
|
|
namespace GuideRate {
|
|
|
|
const std::string GuideRatePhaseEnum2String( GuideRatePhaseEnum enumValue ) {
|
|
switch( enumValue ) {
|
|
case OIL:
|
|
return "OIL";
|
|
case WAT:
|
|
return "WAT";
|
|
case GAS:
|
|
return "GAS";
|
|
case LIQ:
|
|
return "LIQ";
|
|
case COMB:
|
|
return "COMB";
|
|
case WGA:
|
|
return "WGA";
|
|
case CVAL:
|
|
return "CVAL";
|
|
case RAT:
|
|
return "RAT";
|
|
case RES:
|
|
return "RES";
|
|
case UNDEFINED:
|
|
return "UNDEFINED";
|
|
default:
|
|
throw std::invalid_argument("unhandled enum value");
|
|
}
|
|
}
|
|
|
|
GuideRatePhaseEnum GuideRatePhaseEnumFromString( const std::string& stringValue ) {
|
|
|
|
if (stringValue == "OIL")
|
|
return OIL;
|
|
else if (stringValue == "WAT")
|
|
return WAT;
|
|
else if (stringValue == "GAS")
|
|
return GAS;
|
|
else if (stringValue == "LIQ")
|
|
return LIQ;
|
|
else if (stringValue == "COMB")
|
|
return COMB;
|
|
else if (stringValue == "WGA")
|
|
return WGA;
|
|
else if (stringValue == "CVAL")
|
|
return CVAL;
|
|
else if (stringValue == "RAT")
|
|
return RAT;
|
|
else if (stringValue == "RES")
|
|
return RES;
|
|
else if (stringValue == "UNDEFINED")
|
|
return UNDEFINED;
|
|
else
|
|
throw std::invalid_argument("Unknown enum state string: " + stringValue );
|
|
}
|
|
}
|
|
|
|
namespace RFTConnections {
|
|
const std::string RFTEnum2String(RFTEnum enumValue) {
|
|
switch (enumValue) {
|
|
case YES:
|
|
return "YES";
|
|
case REPT:
|
|
return "REPT";
|
|
case TIMESTEP:
|
|
return "TIMESTEP";
|
|
case FOPN:
|
|
return "FOPN";
|
|
case NO:
|
|
return "NO";
|
|
default:
|
|
throw std::invalid_argument("unhandled enum value");
|
|
}
|
|
}
|
|
|
|
RFTEnum RFTEnumFromString(const std::string& stringValue) {
|
|
|
|
if (stringValue == "YES")
|
|
return YES;
|
|
else if (stringValue == "REPT")
|
|
return REPT;
|
|
else if (stringValue == "TIMESTEP")
|
|
return TIMESTEP;
|
|
else if (stringValue == "FOPN")
|
|
return FOPN;
|
|
else if (stringValue == "NO")
|
|
return NO;
|
|
else
|
|
throw std::invalid_argument("Unknown enum state string: " + stringValue);
|
|
}
|
|
|
|
}
|
|
namespace PLTConnections {
|
|
const std::string PLTEnum2String(PLTEnum enumValue) {
|
|
switch (enumValue) {
|
|
case YES:
|
|
return "YES";
|
|
case REPT:
|
|
return "REPT";
|
|
case TIMESTEP:
|
|
return "TIMESTEP";
|
|
case NO:
|
|
return "NO";
|
|
default:
|
|
throw std::invalid_argument("unhandled enum value");
|
|
}
|
|
}
|
|
|
|
PLTEnum PLTEnumFromString( const std::string& stringValue ){
|
|
if (stringValue == "YES")
|
|
return YES;
|
|
else if (stringValue == "REPT")
|
|
return REPT;
|
|
else if (stringValue == "TIMESTEP")
|
|
return TIMESTEP;
|
|
else if (stringValue == "NO")
|
|
return NO;
|
|
else
|
|
throw std::invalid_argument("Unknown enum state string: " + stringValue );
|
|
}
|
|
}
|
|
|
|
namespace WellSegment{
|
|
|
|
const std::string LengthDepthEnumToString(LengthDepthEnum enumValue) {
|
|
switch (enumValue) {
|
|
case INC:
|
|
return "INC";
|
|
case ABS:
|
|
return "ABS";
|
|
default:
|
|
throw std::invalid_argument("unhandled LengthDepthEnum value");
|
|
}
|
|
}
|
|
|
|
LengthDepthEnum LengthDepthEnumFromString(const std::string& string ) {
|
|
if (string == "INC") {
|
|
return INC;
|
|
} else if (string == "ABS") {
|
|
return ABS;
|
|
} else {
|
|
throw std::invalid_argument("Unknown enum string: " + string + " for LengthDepthEnum");
|
|
}
|
|
}
|
|
|
|
const std::string CompPressureDropEnumToString(CompPressureDropEnum enumValue) {
|
|
switch (enumValue) {
|
|
case HFA:
|
|
return "HFA";
|
|
case HF_:
|
|
return "HF-";
|
|
case H__:
|
|
return "H--";
|
|
default:
|
|
throw std::invalid_argument("unhandled CompPressureDropEnum value");
|
|
}
|
|
}
|
|
|
|
CompPressureDropEnum CompPressureDropEnumFromString( const std::string& string ) {
|
|
|
|
if (string == "HFA") {
|
|
return HFA;
|
|
} else if (string == "HF-") {
|
|
return HF_;
|
|
} else if (string == "H--") {
|
|
return H__;
|
|
} else {
|
|
throw std::invalid_argument("Unknown enum string: " + string + " for CompPressureDropEnum");
|
|
}
|
|
}
|
|
|
|
const std::string MultiPhaseModelEnumToString(MultiPhaseModelEnum enumValue) {
|
|
switch (enumValue) {
|
|
case HO:
|
|
return "HO";
|
|
case DF:
|
|
return "DF";
|
|
default:
|
|
throw std::invalid_argument("unhandled MultiPhaseModelEnum value");
|
|
}
|
|
}
|
|
|
|
MultiPhaseModelEnum MultiPhaseModelEnumFromString(const std::string& string ) {
|
|
|
|
if ((string == "HO") || (string == "H0")) {
|
|
return HO;
|
|
} else if (string == "DF") {
|
|
return DF;
|
|
} else {
|
|
throw std::invalid_argument("Unknown enum string: " + string + " for MultiPhaseModelEnum");
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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");
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|