OilfieldToolsNet/opm-common
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added namespace Phase around the PhaseEnum enum.

Browse Source
This commit is contained in:
Joakim Hove
2014-01-28 08:18:03 +01:00
parent af00558ec7
commit a464429388
11 changed files with 88 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
opm/parser/eclipse/EclipseState/EclipseState.cpp
View File

@@ -42,17 +42,17 @@ namespace Opm {
void EclipseState::initPhases(DeckConstPtr deck) {
if (deck->hasKeyword("OIL"))
phases.insert(PhaseEnum::OIL);
phases.insert(Phase::PhaseEnum::OIL);
if (deck->hasKeyword("GAS"))
phases.insert(PhaseEnum::GAS);
phases.insert(Phase::PhaseEnum::GAS);
if (deck->hasKeyword("WATER"))
phases.insert(PhaseEnum::WATER);
phases.insert(Phase::PhaseEnum::WATER);
}
bool EclipseState::hasPhase(enum PhaseEnum phase) const {
bool EclipseState::hasPhase(enum Phase::PhaseEnum phase) const {
return (phases.count(phase) == 1);
}

4
opm/parser/eclipse/EclipseState/EclipseState.hpp
View File

@@ -33,14 +33,14 @@ namespace Opm {
public:
EclipseState(DeckConstPtr deck);
ScheduleConstPtr getSchedule() const;
bool hasPhase(enum PhaseEnum phase) const;
bool hasPhase(enum Phase::PhaseEnum phase) const;
private:
void initSchedule(DeckConstPtr deck);
void initPhases(DeckConstPtr deck);
ScheduleConstPtr schedule;
std::set<enum PhaseEnum> phases;
std::set<enum Phase::PhaseEnum> phases;
};
typedef std::shared_ptr<EclipseState> EclipseStatePtr;

10
opm/parser/eclipse/EclipseState/Schedule/Group.cpp
View File

@@ -56,7 +56,7 @@ namespace Opm {
struct InjectionData {
InjectionData(TimeMapConstPtr timeMap);
std::shared_ptr<DynamicState<PhaseEnum> > phase;
std::shared_ptr<DynamicState<Phase::PhaseEnum> > phase;
std::shared_ptr<DynamicState<GroupInjection::ControlEnum> > controlMode;
std::shared_ptr<DynamicState<double> > rate;
std::shared_ptr<DynamicState<double> > surfaceFlowMaxRate;
@@ -66,7 +66,7 @@ namespace Opm {
};
InjectionData::InjectionData(TimeMapConstPtr timeMap) :
phase( new DynamicState<PhaseEnum>( timeMap , WATER )),
phase( new DynamicState<Phase::PhaseEnum>( timeMap , Phase::WATER )),
controlMode( new DynamicState<GroupInjection::ControlEnum>( timeMap , NONE )),
rate( new DynamicState<double>( timeMap , 0 )),
surfaceFlowMaxRate( new DynamicState<double>( timeMap , 0)),
@@ -107,9 +107,9 @@ namespace Opm {
void Group::setInjectionPhase(size_t time_step , PhaseEnum phase){
void Group::setInjectionPhase(size_t time_step , Phase::PhaseEnum phase){
if (m_injection->phase->size() == time_step + 1) {
PhaseEnum currentPhase = m_injection->phase->get(time_step);
Phase::PhaseEnum currentPhase = m_injection->phase->get(time_step);
/*
The ECLIPSE documentation of the GCONINJE keyword seems
to indicate that a group can inject more than one phase
@@ -134,7 +134,7 @@ namespace Opm {
m_injection->phase->add( time_step , phase );
}
PhaseEnum Group::getInjectionPhase( size_t time_step ) const {
Phase::PhaseEnum Group::getInjectionPhase( size_t time_step ) const {
return m_injection->phase->get( time_step );
}

4
opm/parser/eclipse/EclipseState/Schedule/Group.hpp
View File

@@ -46,8 +46,8 @@ namespace Opm {
Group(const std::string& name, TimeMapConstPtr timeMap , size_t creationTimeStep);
bool hasBeenDefined(size_t timeStep) const;
const std::string& name() const;
void setInjectionPhase(size_t time_step , PhaseEnum phase);
PhaseEnum getInjectionPhase( size_t time_step) const;
void setInjectionPhase(size_t time_step , Phase::PhaseEnum phase);
Phase::PhaseEnum getInjectionPhase(size_t time_step) const;
void setInjectionControlMode(size_t time_step , GroupInjection::ControlEnum ControlMode);
GroupInjection::ControlEnum getInjectionControlMode( size_t time_step) const;

2
opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
View File

@@ -221,7 +221,7 @@ namespace Opm {
GroupPtr group = getGroup(groupName);
{
PhaseEnum phase = PhaseEnumFromString( record->getItem("PHASE")->getString(0) );
Phase::PhaseEnum phase = Phase::PhaseEnumFromString( record->getItem("PHASE")->getString(0) );
group->setInjectionPhase( currentStep , phase );
}
{

48
opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.cpp
View File

@@ -185,31 +185,31 @@ namespace Opm {
}
/*****************************************************************/
const std::string PhaseEnum2String( PhaseEnum enumValue ) {
switch( enumValue ) {
case OIL:
return "OIL";
case GAS:
return "GAS";
case WATER:
return "WATER";
default:
throw std::invalid_argument("unhandled enum value");
namespace Phase {
const std::string PhaseEnum2String( PhaseEnum enumValue ) {
switch( enumValue ) {
case OIL:
return "OIL";
case GAS:
return "GAS";
case WATER:
return "WATER";
default:
throw std::invalid_argument("unhandled enum value");
}
}
PhaseEnum PhaseEnumFromString( const std::string& stringValue ) {
if (stringValue == "OIL")
return OIL;
else if (stringValue == "WATER")
return WATER;
else if (stringValue == "GAS")
return GAS;
else
throw std::invalid_argument("Unknown enum state string: " + stringValue );
}
}
PhaseEnum PhaseEnumFromString( const std::string& stringValue ) {
if (stringValue == "OIL")
return OIL;
else if (stringValue == "WATER")
return WATER;
else if (stringValue == "GAS")
return GAS;
else
throw std::invalid_argument("Unknown enum state string: " + stringValue );
}
}

28
opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp
View File

@@ -31,10 +31,26 @@ namespace Opm {
};
enum PhaseEnum {
OIL = 1,
GAS = 2,
WATER = 4
namespace Phase {
enum PhaseEnum {
OIL = 1,
GAS = 2,
WATER = 4
};
const std::string PhaseEnum2String( PhaseEnum enumValue );
PhaseEnum PhaseEnumFromString( const std::string& stringValue );
};
namespace Injector {
enum InjectorType {
WATER = 1,
GAS = 2,
OIL = 3,
MULTI = 4
};
};
@@ -91,10 +107,6 @@ namespace Opm {
const std::string CompletionStateEnum2String( CompletionStateEnum enumValue );
CompletionStateEnum CompletionStateEnumFromString( const std::string& stringValue );
const std::string PhaseEnum2String( PhaseEnum enumValue );
PhaseEnum PhaseEnumFromString( const std::string& stringValue );
}

14
opm/parser/eclipse/EclipseState/Schedule/tests/GroupTests.cpp
View File

@@ -81,13 +81,13 @@ BOOST_AUTO_TEST_CASE(ControlModeOK) {
BOOST_AUTO_TEST_CASE(GroupChangePhaseSameTimeThrows) {
Opm::TimeMapPtr timeMap = createXDaysTimeMap(10);
Opm::Group group("G1" , timeMap , 0);
BOOST_CHECK_EQUAL( Opm::WATER , group.getInjectionPhase( 0 )); // Default phase - assumed WATER
group.setInjectionPhase(5 , Opm::WATER );
BOOST_CHECK_THROW( group.setInjectionPhase( 5 , Opm::GAS ) , std::invalid_argument );
BOOST_CHECK_NO_THROW( group.setInjectionPhase( 5 , Opm::WATER ));
BOOST_CHECK_NO_THROW( group.setInjectionPhase( 6 , Opm::GAS ));
BOOST_CHECK_EQUAL( Opm::GAS , group.getInjectionPhase( 6 ));
BOOST_CHECK_EQUAL( Opm::GAS , group.getInjectionPhase( 8 ));
BOOST_CHECK_EQUAL( Opm::Phase::WATER , group.getInjectionPhase( 0 )); // Default phase - assumed WATER
group.setInjectionPhase(5 , Opm::Phase::WATER );
BOOST_CHECK_THROW( group.setInjectionPhase( 5 , Opm::Phase::GAS ) , std::invalid_argument );
BOOST_CHECK_NO_THROW( group.setInjectionPhase( 5 , Opm::Phase::WATER ));
BOOST_CHECK_NO_THROW( group.setInjectionPhase( 6 , Opm::Phase::GAS ));
BOOST_CHECK_EQUAL( Opm::Phase::GAS , group.getInjectionPhase( 6 ));
BOOST_CHECK_EQUAL( Opm::Phase::GAS , group.getInjectionPhase( 8 ));
}

34
opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleEnumTests.cpp
View File

@@ -184,36 +184,38 @@ BOOST_AUTO_TEST_CASE(TestGroupProductionExceedLimitActionEnumLoop) {
/*****************************************************************/
BOOST_AUTO_TEST_CASE(TestPhaseEnum2String) {
BOOST_CHECK_EQUAL( "OIL" , PhaseEnum2String(OIL));
BOOST_CHECK_EQUAL( "GAS" , PhaseEnum2String(GAS));
BOOST_CHECK_EQUAL( "WATER" , PhaseEnum2String(WATER));
BOOST_CHECK_EQUAL( "OIL" , Phase::PhaseEnum2String(Phase::OIL));
BOOST_CHECK_EQUAL( "GAS" , Phase::PhaseEnum2String(Phase::GAS));
BOOST_CHECK_EQUAL( "WATER" , Phase::PhaseEnum2String(Phase::WATER));
}
BOOST_AUTO_TEST_CASE(TestPhaseEnumFromString) {
BOOST_CHECK_THROW( PhaseEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( OIL , PhaseEnumFromString("OIL"));
BOOST_CHECK_EQUAL( WATER , PhaseEnumFromString("WATER"));
BOOST_CHECK_EQUAL( GAS , PhaseEnumFromString("GAS"));
BOOST_CHECK_THROW( Phase::PhaseEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( Phase::OIL , Phase::PhaseEnumFromString("OIL"));
BOOST_CHECK_EQUAL( Phase::WATER , Phase::PhaseEnumFromString("WATER"));
BOOST_CHECK_EQUAL( Phase::GAS , Phase::PhaseEnumFromString("GAS"));
}
BOOST_AUTO_TEST_CASE(TestPhaseEnumLoop) {
BOOST_CHECK_EQUAL( OIL , PhaseEnumFromString( PhaseEnum2String( OIL ) ));
BOOST_CHECK_EQUAL( WATER , PhaseEnumFromString( PhaseEnum2String( WATER ) ));
BOOST_CHECK_EQUAL( GAS , PhaseEnumFromString( PhaseEnum2String( GAS ) ));
BOOST_CHECK_EQUAL( Phase::OIL , Phase::PhaseEnumFromString( Phase::PhaseEnum2String( Phase::OIL ) ));
BOOST_CHECK_EQUAL( Phase::WATER , Phase::PhaseEnumFromString( Phase::PhaseEnum2String( Phase::WATER ) ));
BOOST_CHECK_EQUAL( Phase::GAS , Phase::PhaseEnumFromString( Phase::PhaseEnum2String( Phase::GAS ) ));
BOOST_CHECK_EQUAL( "OIL" , PhaseEnum2String(PhaseEnumFromString( "OIL" ) ));
BOOST_CHECK_EQUAL( "GAS" , PhaseEnum2String(PhaseEnumFromString( "GAS" ) ));
BOOST_CHECK_EQUAL( "WATER" , PhaseEnum2String(PhaseEnumFromString( "WATER" ) ));
BOOST_CHECK_EQUAL( "OIL" , Phase::PhaseEnum2String(Phase::PhaseEnumFromString( "OIL" ) ));
BOOST_CHECK_EQUAL( "GAS" , Phase::PhaseEnum2String(Phase::PhaseEnumFromString( "GAS" ) ));
BOOST_CHECK_EQUAL( "WATER" , Phase::PhaseEnum2String(Phase::PhaseEnumFromString( "WATER" ) ));
}
BOOST_AUTO_TEST_CASE(TestPhaseEnumMask) {
BOOST_CHECK_EQUAL( 0 , OIL & GAS );
BOOST_CHECK_EQUAL( 0 , OIL & WATER );
BOOST_CHECK_EQUAL( 0 , WATER & GAS );
BOOST_CHECK_EQUAL( 0 , Phase::OIL & Phase::GAS );
BOOST_CHECK_EQUAL( 0 , Phase::OIL & Phase::WATER );
BOOST_CHECK_EQUAL( 0 , Phase::WATER & Phase::GAS );
}

6
opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp
View File

@@ -81,7 +81,7 @@ BOOST_AUTO_TEST_CASE(PhasesCorrect) {
DeckPtr deck = createDeck();
EclipseState state(deck);
BOOST_CHECK( state.hasPhase( PhaseEnum::OIL ));
BOOST_CHECK( state.hasPhase( PhaseEnum::GAS ));
BOOST_CHECK( !state.hasPhase( PhaseEnum::WATER ));
BOOST_CHECK( state.hasPhase( Phase::PhaseEnum::OIL ));
BOOST_CHECK( state.hasPhase( Phase::PhaseEnum::GAS ));
BOOST_CHECK( !state.hasPhase( Phase::PhaseEnum::WATER ));
}