From a464429388f83d13a2b3fb9554bfbaa7774f090c Mon Sep 17 00:00:00 2001 From: Joakim Hove Date: Tue, 28 Jan 2014 08:18:03 +0100 Subject: [PATCH] Added namespace Phase around the PhaseEnum enum. --- .../eclipse/EclipseState/EclipseState.cpp | 8 ++-- .../eclipse/EclipseState/EclipseState.hpp | 4 +- .../eclipse/EclipseState/Schedule/Group.cpp | 10 ++-- .../eclipse/EclipseState/Schedule/Group.hpp | 4 +- .../EclipseState/Schedule/Schedule.cpp | 2 +- .../EclipseState/Schedule/ScheduleEnums.cpp | 48 +++++++++---------- .../EclipseState/Schedule/ScheduleEnums.hpp | 28 +++++++---- .../Schedule/tests/GroupTests.cpp | 14 +++--- .../Schedule/tests/ScheduleEnumTests.cpp | 34 ++++++------- .../EclipseState/tests/EclipseStateTests.cpp | 6 +-- .../ScheduleCreateFromDeck.cpp | 4 +- 11 files changed, 88 insertions(+), 74 deletions(-) diff --git a/opm/parser/eclipse/EclipseState/EclipseState.cpp b/opm/parser/eclipse/EclipseState/EclipseState.cpp index d279a6a85..76d5c2bb4 100644 --- a/opm/parser/eclipse/EclipseState/EclipseState.cpp +++ b/opm/parser/eclipse/EclipseState/EclipseState.cpp @@ -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); } diff --git a/opm/parser/eclipse/EclipseState/EclipseState.hpp b/opm/parser/eclipse/EclipseState/EclipseState.hpp index c6d656388..594492204 100644 --- a/opm/parser/eclipse/EclipseState/EclipseState.hpp +++ b/opm/parser/eclipse/EclipseState/EclipseState.hpp @@ -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 phases; + std::set phases; }; typedef std::shared_ptr EclipseStatePtr; diff --git a/opm/parser/eclipse/EclipseState/Schedule/Group.cpp b/opm/parser/eclipse/EclipseState/Schedule/Group.cpp index 983a6e5ee..7af6514bd 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/Group.cpp +++ b/opm/parser/eclipse/EclipseState/Schedule/Group.cpp @@ -56,7 +56,7 @@ namespace Opm { struct InjectionData { InjectionData(TimeMapConstPtr timeMap); - std::shared_ptr > phase; + std::shared_ptr > phase; std::shared_ptr > controlMode; std::shared_ptr > rate; std::shared_ptr > surfaceFlowMaxRate; @@ -66,7 +66,7 @@ namespace Opm { }; InjectionData::InjectionData(TimeMapConstPtr timeMap) : - phase( new DynamicState( timeMap , WATER )), + phase( new DynamicState( timeMap , Phase::WATER )), controlMode( new DynamicState( timeMap , NONE )), rate( new DynamicState( timeMap , 0 )), surfaceFlowMaxRate( new DynamicState( 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 ); } diff --git a/opm/parser/eclipse/EclipseState/Schedule/Group.hpp b/opm/parser/eclipse/EclipseState/Schedule/Group.hpp index 3d4b25e2c..76347e85e 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/Group.hpp +++ b/opm/parser/eclipse/EclipseState/Schedule/Group.hpp @@ -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; diff --git a/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp b/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp index efd4c1b6a..1cb67095d 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp +++ b/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp @@ -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 ); } { diff --git a/opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.cpp b/opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.cpp index ed9b27c25..c18c443fb 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.cpp +++ b/opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.cpp @@ -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 ); - } - - } diff --git a/opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp b/opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp index ee6911bf6..cbcdb3335 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp +++ b/opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp @@ -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 ); - - } diff --git a/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTests.cpp b/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTests.cpp index f368d19ef..10853fb83 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTests.cpp +++ b/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTests.cpp @@ -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 )); } diff --git a/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleEnumTests.cpp b/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleEnumTests.cpp index 3c6759d3f..4bf2e5476 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleEnumTests.cpp +++ b/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleEnumTests.cpp @@ -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 ); } + + diff --git a/opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp b/opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp index e8c04db62..a75e23056 100644 --- a/opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp +++ b/opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp @@ -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 )); } diff --git a/opm/parser/eclipse/IntegrationTests/ScheduleCreateFromDeck.cpp b/opm/parser/eclipse/IntegrationTests/ScheduleCreateFromDeck.cpp index 34fc57ff1..7098a06a1 100644 --- a/opm/parser/eclipse/IntegrationTests/ScheduleCreateFromDeck.cpp +++ b/opm/parser/eclipse/IntegrationTests/ScheduleCreateFromDeck.cpp @@ -269,14 +269,14 @@ BOOST_AUTO_TEST_CASE( WellTestGroups ) { { GroupPtr group = sched->getGroup("INJ"); - BOOST_CHECK_EQUAL( WATER , group->getInjectionPhase( 3 )); + BOOST_CHECK_EQUAL( Phase::WATER , group->getInjectionPhase( 3 )); BOOST_CHECK_EQUAL( GroupInjection::VREP , group->getInjectionControlMode( 3 )); BOOST_CHECK_CLOSE( 10/Metric::Time , group->getSurfaceMaxRate( 3 ) , 0.001); BOOST_CHECK_CLOSE( 20/Metric::Time , group->getReservoirMaxRate( 3 ) , 0.001); BOOST_CHECK_EQUAL( 0.75 , group->getTargetReinjectFraction( 3 )); BOOST_CHECK_EQUAL( 0.95 , group->getTargetVoidReplacementFraction( 3 )); - BOOST_CHECK_EQUAL( OIL , group->getInjectionPhase( 6 )); + BOOST_CHECK_EQUAL( Phase::OIL , group->getInjectionPhase( 6 )); BOOST_CHECK_EQUAL( GroupInjection::RATE , group->getInjectionControlMode( 6 )); BOOST_CHECK_CLOSE( 1000/Metric::Time , group->getSurfaceMaxRate( 6 ) , 0.0001); }