Added several enums - with namespcae container

2013-11-19 17:20:18 +01:00
parent f2aa193a32
commit 3170710303
8 changed files with 388 additions and 115 deletions
--- a/opm/parser/eclipse/EclipseState/Schedule/Group.cpp
+++ b/opm/parser/eclipse/EclipseState/Schedule/Group.cpp
@@ -23,15 +23,62 @@
 #include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>

 namespace Opm {
+    namespace GroupProduction {
+        struct ProductionData {
+            ProductionData(TimeMapConstPtr timeMap);
+            
+            boost::shared_ptr<DynamicState<GroupProduction::ControlEnum> > controlMode;
+            boost::shared_ptr<DynamicState<double> > oilTarget;
+            boost::shared_ptr<DynamicState<double> > waterTarget;
+            boost::shared_ptr<DynamicState<double> > gasTarget;
+            boost::shared_ptr<DynamicState<double> > liquidTarget;
+            
+        };
+        
+        ProductionData::ProductionData(TimeMapConstPtr timeMap) : 
+            controlMode( new DynamicState<GroupProduction::ControlEnum>(timeMap , GroupProduction::NONE)),
+            oilTarget( new DynamicState<double>(timeMap , 0)),
+            waterTarget( new DynamicState<double>(timeMap , 0)),
+            gasTarget( new DynamicState<double>(timeMap , 0)),
+            liquidTarget( new DynamicState<double>(timeMap , 0))
+        {
+        }
+        
+    }

-    Group::Group(const std::string& name , TimeMapConstPtr timeMap) 
-        : m_injectionPhase( new DynamicState<PhaseEnum>( timeMap , WATER )),
-          m_injectionControlMode( new DynamicState<GroupInjectionControlEnum>( timeMap , NONE )),
-          m_injectionRate( new DynamicState<double>( timeMap , 0 )),
-          m_surfaceFlowMaxRate( new DynamicState<double>( timeMap , 0)),
-          m_reservoirFlowMaxRate( new DynamicState<double>( timeMap , 0)),
-          m_targetReinjectFraction( new DynamicState<double>( timeMap , 0)),
-          m_targetVoidReplacementFraction( new DynamicState<double>( timeMap , 0))
+    
+    
+
+    namespace GroupInjection {
+        struct InjectionData {
+            InjectionData(TimeMapConstPtr timeMap);
+            
+            boost::shared_ptr<DynamicState<PhaseEnum> > phase;
+            boost::shared_ptr<DynamicState<GroupInjection::ControlEnum> > controlMode;
+            boost::shared_ptr<DynamicState<double> > rate;
+            boost::shared_ptr<DynamicState<double> > surfaceFlowMaxRate;
+            boost::shared_ptr<DynamicState<double> > reservoirFlowMaxRate;
+            boost::shared_ptr<DynamicState<double> > targetReinjectFraction;
+            boost::shared_ptr<DynamicState<double> > targetVoidReplacementFraction;                
+        };
+        
+        InjectionData::InjectionData(TimeMapConstPtr timeMap) : 
+            phase( new DynamicState<PhaseEnum>( timeMap , WATER )),
+            controlMode( new DynamicState<GroupInjection::ControlEnum>( timeMap , NONE )),
+            rate( new DynamicState<double>( timeMap , 0 )),
+            surfaceFlowMaxRate( new DynamicState<double>( timeMap , 0)),
+            reservoirFlowMaxRate( new DynamicState<double>( timeMap , 0)),
+            targetReinjectFraction( new DynamicState<double>( timeMap , 0)),
+            targetVoidReplacementFraction( new DynamicState<double>( timeMap , 0))
+        {
+        
+        }
+    }
+
+    /*****************************************************************/
+    
+    Group::Group(const std::string& name , TimeMapConstPtr timeMap) : 
+        m_injection( new GroupInjection::InjectionData(timeMap) )
    {
        m_name = name;
    }
@@ -43,8 +90,8 @@ namespace Opm {

    
    void Group::setInjectionPhase(size_t time_step , PhaseEnum phase){
-        if (m_injectionPhase->size() == time_step + 1) {
-            PhaseEnum currentPhase = m_injectionPhase->get(time_step);
+        if (m_injection->phase->size() == time_step + 1) {
+            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
@@ -66,63 +113,60 @@ namespace Opm {
            if (phase != currentPhase)
                throw std::invalid_argument("Sorry - we currently do not support injecting multiple phases at the same time.");
        }
-        m_injectionPhase->add( time_step , phase );
+        m_injection->phase->add( time_step , phase );
    }

    PhaseEnum Group::getInjectionPhase( size_t time_step ) const {
-        return m_injectionPhase->get( time_step );
+        return m_injection->phase->get( time_step );
    }

    void Group::setInjectionRate( size_t time_step , double rate) {
-        return m_injectionRate->add( time_step , rate);
+        return m_injection->rate->add( time_step , rate);
    }

    double Group::getInjectionRate( size_t time_step ) const {
-        return m_injectionRate->get( time_step );
+        return m_injection->rate->get( time_step );
    }

-    void Group::setInjectionControlMode(size_t time_step , GroupInjectionControlEnum controlMode) {
-        m_injectionControlMode->add( time_step , controlMode );
+    void Group::setInjectionControlMode(size_t time_step , GroupInjection::ControlEnum controlMode) {
+        m_injection->controlMode->add( time_step , controlMode );
    }

-    GroupInjectionControlEnum Group::getInjectionControlMode( size_t time_step) const {
-        return m_injectionControlMode->get( time_step );
+    GroupInjection::ControlEnum Group::getInjectionControlMode( size_t time_step) const {
+        return m_injection->controlMode->get( time_step );
    }

    void Group::setSurfaceMaxRate( size_t time_step , double rate) {
-        return m_surfaceFlowMaxRate->add( time_step , rate);
+        return m_injection->surfaceFlowMaxRate->add( time_step , rate);
    }

    double Group::getSurfaceMaxRate( size_t time_step ) const {
-        return m_surfaceFlowMaxRate->get( time_step );
+        return m_injection->surfaceFlowMaxRate->get( time_step );
    }

    void Group::setReservoirMaxRate( size_t time_step , double rate) {
-        return m_reservoirFlowMaxRate->add( time_step , rate);
+        return m_injection->reservoirFlowMaxRate->add( time_step , rate);
    }

    double Group::getReservoirMaxRate( size_t time_step ) const {
-        return m_reservoirFlowMaxRate->get( time_step );
+        return m_injection->reservoirFlowMaxRate->get( time_step );
    }

    void Group::setTargetReinjectFraction( size_t time_step , double rate) {
-        return m_targetReinjectFraction->add( time_step , rate);
+        return m_injection->targetReinjectFraction->add( time_step , rate);
    }

    double Group::getTargetReinjectFraction( size_t time_step ) const {
-        return m_targetReinjectFraction->get( time_step );
+        return m_injection->targetReinjectFraction->get( time_step );
    }

    void Group::setTargetVoidReplacementFraction( size_t time_step , double rate) {
-        return m_targetVoidReplacementFraction->add( time_step , rate);
+        return m_injection->targetVoidReplacementFraction->add( time_step , rate);
    }

    double Group::getTargetVoidReplacementFraction( size_t time_step ) const {
-        return m_targetVoidReplacementFraction->get( time_step );
+        return m_injection->targetVoidReplacementFraction->get( time_step );
    }
-
-    
-
 }


--- a/opm/parser/eclipse/EclipseState/Schedule/Group.hpp
+++ b/opm/parser/eclipse/EclipseState/Schedule/Group.hpp
@@ -30,6 +30,16 @@

 namespace Opm {

+    namespace GroupInjection {
+        struct InjectionData;
+    }
+
+    
+    namespace GroupProduction {
+        struct ProductionData;
+    }
+    
+
    class Group {
    public:
        Group(const std::string& name, TimeMapConstPtr timeMap);
@@ -37,13 +47,13 @@ namespace Opm {
        const std::string& name() const;
        void      setInjectionPhase(size_t time_step , PhaseEnum phase);
        PhaseEnum getInjectionPhase( size_t time_step) const;
-
-        void                      setInjectionControlMode(size_t time_step , GroupInjectionControlEnum ControlMode);
-        GroupInjectionControlEnum getInjectionControlMode( size_t time_step) const;
+        
+        void                      setInjectionControlMode(size_t time_step , GroupInjection::ControlEnum ControlMode);
+        GroupInjection::ControlEnum getInjectionControlMode( size_t time_step) const;

        void   setInjectionRate(size_t time_step , double rate);
        double getInjectionRate( size_t time_step) const;
-
+        
        void   setSurfaceMaxRate( size_t time_step , double rate);
        double getSurfaceMaxRate( size_t time_step ) const;

@@ -56,15 +66,11 @@ namespace Opm {
        void   setTargetVoidReplacementFraction( size_t time_step , double rate);
        double getTargetVoidReplacementFraction( size_t time_step ) const;

+
    private:
        std::string m_name;
-        boost::shared_ptr<DynamicState<PhaseEnum> > m_injectionPhase;
-        boost::shared_ptr<DynamicState<GroupInjectionControlEnum> > m_injectionControlMode;
-        boost::shared_ptr<DynamicState<double> > m_injectionRate;
-        boost::shared_ptr<DynamicState<double> > m_surfaceFlowMaxRate;
-        boost::shared_ptr<DynamicState<double> > m_reservoirFlowMaxRate;
-        boost::shared_ptr<DynamicState<double> > m_targetReinjectFraction;
-        boost::shared_ptr<DynamicState<double> > m_targetVoidReplacementFraction;
+        boost::shared_ptr<GroupInjection::InjectionData> m_injection;
+        boost::shared_ptr<GroupProduction::ProductionData> m_production;
    };
    typedef boost::shared_ptr<Group> GroupPtr;
    typedef boost::shared_ptr<const Group> GroupConstPtr;
--- a/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
+++ b/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
@@ -176,7 +176,7 @@ namespace Opm {
                group->setInjectionPhase( currentStep , phase );
            }
            {
-                GroupInjectionControlEnum controlMode = GroupInjectionControlEnumFromString( record->getItem("CONTROL_MODE")->getString(0) );
+                GroupInjection::ControlEnum controlMode = GroupInjection::ControlEnumFromString( record->getItem("CONTROL_MODE")->getString(0) );
                group->setInjectionControlMode( currentStep , controlMode );
            }
            group->setSurfaceMaxRate( currentStep , record->getItem("SURFACE_TARGET")->getDouble(0));
--- a/opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.cpp
+++ b/opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.cpp
@@ -50,42 +50,138 @@ namespace Opm {
    }

    /*****************************************************************/
+
+    namespace GroupInjection {
    
-    const std::string GroupInjectionControlEnum2String( GroupInjectionControlEnum 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");
+        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";
+            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
+                throw std::invalid_argument("Unknown enum state string: " + stringValue );
        }
    }
-    
-    
-    GroupInjectionControlEnum GroupInjectionControlEnumFromString( 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 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 );
+        }
+
    }

    /*****************************************************************/
--- a/opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp
+++ b/opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp
@@ -38,15 +38,54 @@ namespace Opm {
    };

    
-    enum GroupInjectionControlEnum {
-        NONE = 0,
-        RATE = 1,
-        RESV = 2,
-        REIN = 3,
-        VREP = 4,
-        FLD  = 5
-    };
+    namespace GroupInjection {
+        
+          enum ControlEnum {
+            NONE = 0,
+            RATE = 1,
+            RESV = 2,
+            REIN = 3,
+            VREP = 4,
+            FLD  = 5
+        };

+        const std::string ControlEnum2String( ControlEnum enumValue );
+        ControlEnum ControlEnumFromString( const std::string& stringValue );
+    }
+
+    
+    namespace GroupProductionExceedLimit {
+        enum ActionEnum {
+            NONE = 0,
+            CON = 1,
+            CON_PLUS = 2,   // String: "+CON"
+            WELL = 3,
+            PLUG = 4,
+            RATE = 5
+        };
+            
+        const std::string ActionEnum2String( ActionEnum enumValue );
+        ActionEnum ActionEnumFromString( const std::string& stringValue );
+    }
+    
+    
+
+    namespace GroupProduction {
+
+        enum ControlEnum {
+            NONE = 0,
+            ORAT = 1,
+            WRAT = 2,
+            GRAT = 3,
+            LRAT = 4,
+            CRAT = 5,
+            RESV = 6,
+            PRBL = 7
+        };
+        
+        const std::string ControlEnum2String( GroupProduction::ControlEnum enumValue );
+        GroupProduction::ControlEnum ControlEnumFromString( const std::string& stringValue );    
+    }


    const std::string CompletionStateEnum2String( CompletionStateEnum enumValue );
@@ -55,8 +94,7 @@ namespace Opm {
    const std::string PhaseEnum2String( PhaseEnum enumValue );
    PhaseEnum PhaseEnumFromString( const std::string& stringValue );

-    const std::string GroupInjectionControlEnum2String( GroupInjectionControlEnum enumValue );
-    GroupInjectionControlEnum GroupInjectionControlEnumFromString( const std::string& stringValue );
+    
    
 }

--- a/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTests.cpp
+++ b/opm/parser/eclipse/EclipseState/Schedule/tests/GroupTests.cpp
@@ -61,10 +61,10 @@ BOOST_AUTO_TEST_CASE(InjectRateOK) {
 BOOST_AUTO_TEST_CASE(ControlModeOK) {
    Opm::TimeMapPtr timeMap = createXDaysTimeMap(10);
    Opm::Group group("G1" , timeMap);
-    BOOST_CHECK_EQUAL( Opm::NONE , group.getInjectionControlMode( 0 ));
-    group.setInjectionControlMode( 2 , Opm::RESV );
-    BOOST_CHECK_EQUAL( Opm::RESV , group.getInjectionControlMode( 2 ));
-    BOOST_CHECK_EQUAL( Opm::RESV , group.getInjectionControlMode( 8 ));
+    BOOST_CHECK_EQUAL( Opm::GroupInjection::NONE , group.getInjectionControlMode( 0 ));
+    group.setInjectionControlMode( 2 , Opm::GroupInjection::RESV );
+    BOOST_CHECK_EQUAL( Opm::GroupInjection::RESV , group.getInjectionControlMode( 2 ));
+    BOOST_CHECK_EQUAL( Opm::GroupInjection::RESV , group.getInjectionControlMode( 8 ));
 }


--- a/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleEnumTests.cpp
+++ b/opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleEnumTests.cpp
@@ -54,45 +54,134 @@ BOOST_AUTO_TEST_CASE(TestCompletionStateEnumLoop) {
 /*****************************************************************/

 BOOST_AUTO_TEST_CASE(TestGroupInjectionControlEnum2String) {
-    BOOST_CHECK_EQUAL( "NONE" , GroupInjectionControlEnum2String(NONE));
-    BOOST_CHECK_EQUAL( "RATE" , GroupInjectionControlEnum2String(RATE));
-    BOOST_CHECK_EQUAL( "RESV" , GroupInjectionControlEnum2String(RESV));
-    BOOST_CHECK_EQUAL( "REIN" , GroupInjectionControlEnum2String(REIN));
-    BOOST_CHECK_EQUAL( "VREP" , GroupInjectionControlEnum2String(VREP));
-    BOOST_CHECK_EQUAL( "FLD"  , GroupInjectionControlEnum2String(FLD));
+    BOOST_CHECK_EQUAL( "NONE" , GroupInjection::ControlEnum2String(GroupInjection::NONE));
+    BOOST_CHECK_EQUAL( "RATE" , GroupInjection::ControlEnum2String(GroupInjection::RATE));
+    BOOST_CHECK_EQUAL( "RESV" , GroupInjection::ControlEnum2String(GroupInjection::RESV));
+    BOOST_CHECK_EQUAL( "REIN" , GroupInjection::ControlEnum2String(GroupInjection::REIN));
+    BOOST_CHECK_EQUAL( "VREP" , GroupInjection::ControlEnum2String(GroupInjection::VREP));
+    BOOST_CHECK_EQUAL( "FLD"  , GroupInjection::ControlEnum2String(GroupInjection::FLD));
 }


 BOOST_AUTO_TEST_CASE(TestGroupInjectionControlEnumFromString) {
-    BOOST_CHECK_THROW( GroupInjectionControlEnumFromString("XXX") , std::invalid_argument );
-    BOOST_CHECK_EQUAL( NONE , GroupInjectionControlEnumFromString("NONE"));
-    BOOST_CHECK_EQUAL( RATE , GroupInjectionControlEnumFromString("RATE"));
-    BOOST_CHECK_EQUAL( RESV , GroupInjectionControlEnumFromString("RESV"));
-    BOOST_CHECK_EQUAL( REIN , GroupInjectionControlEnumFromString("REIN"));
-    BOOST_CHECK_EQUAL( VREP , GroupInjectionControlEnumFromString("VREP"));
-    BOOST_CHECK_EQUAL( FLD  , GroupInjectionControlEnumFromString("FLD"));
+    BOOST_CHECK_THROW( GroupInjection::ControlEnumFromString("XXX") , std::invalid_argument );
+    BOOST_CHECK_EQUAL( GroupInjection::NONE , GroupInjection::ControlEnumFromString("NONE"));
+    BOOST_CHECK_EQUAL( GroupInjection::RATE , GroupInjection::ControlEnumFromString("RATE"));
+    BOOST_CHECK_EQUAL( GroupInjection::RESV , GroupInjection::ControlEnumFromString("RESV"));
+    BOOST_CHECK_EQUAL( GroupInjection::REIN , GroupInjection::ControlEnumFromString("REIN"));
+    BOOST_CHECK_EQUAL( GroupInjection::VREP , GroupInjection::ControlEnumFromString("VREP"));
+    BOOST_CHECK_EQUAL( GroupInjection::FLD  , GroupInjection::ControlEnumFromString("FLD"));
 }



 BOOST_AUTO_TEST_CASE(TestGroupInjectionControlEnumLoop) {
-    BOOST_CHECK_EQUAL( NONE , GroupInjectionControlEnumFromString( GroupInjectionControlEnum2String( NONE ) ));
-    BOOST_CHECK_EQUAL( RATE , GroupInjectionControlEnumFromString( GroupInjectionControlEnum2String( RATE ) ));
-    BOOST_CHECK_EQUAL( RESV , GroupInjectionControlEnumFromString( GroupInjectionControlEnum2String( RESV ) ));
-    BOOST_CHECK_EQUAL( REIN , GroupInjectionControlEnumFromString( GroupInjectionControlEnum2String( REIN ) ));
-    BOOST_CHECK_EQUAL( VREP , GroupInjectionControlEnumFromString( GroupInjectionControlEnum2String( VREP ) ));
-    BOOST_CHECK_EQUAL( FLD  , GroupInjectionControlEnumFromString( GroupInjectionControlEnum2String( FLD ) ));
+    BOOST_CHECK_EQUAL( GroupInjection::NONE , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::NONE ) ));
+    BOOST_CHECK_EQUAL( GroupInjection::RATE , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::RATE ) ));
+    BOOST_CHECK_EQUAL( GroupInjection::RESV , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::RESV ) ));
+    BOOST_CHECK_EQUAL( GroupInjection::REIN , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::REIN ) ));
+    BOOST_CHECK_EQUAL( GroupInjection::VREP , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::VREP ) ));
+    BOOST_CHECK_EQUAL( GroupInjection::FLD  , GroupInjection::ControlEnumFromString( GroupInjection::ControlEnum2String( GroupInjection::FLD ) ));

-    BOOST_CHECK_EQUAL( "NONE" , GroupInjectionControlEnum2String(GroupInjectionControlEnumFromString( "NONE" ) ));
-    BOOST_CHECK_EQUAL( "RATE" , GroupInjectionControlEnum2String(GroupInjectionControlEnumFromString( "RATE" ) ));
-    BOOST_CHECK_EQUAL( "RESV" , GroupInjectionControlEnum2String(GroupInjectionControlEnumFromString( "RESV" ) ));
-    BOOST_CHECK_EQUAL( "REIN" , GroupInjectionControlEnum2String(GroupInjectionControlEnumFromString( "REIN" ) ));
-    BOOST_CHECK_EQUAL( "VREP" , GroupInjectionControlEnum2String(GroupInjectionControlEnumFromString( "VREP" ) ));
-    BOOST_CHECK_EQUAL( "FLD"  , GroupInjectionControlEnum2String(GroupInjectionControlEnumFromString( "FLD"  ) ));
+    BOOST_CHECK_EQUAL( "NONE" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "NONE" ) ));
+    BOOST_CHECK_EQUAL( "RATE" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "RATE" ) ));
+    BOOST_CHECK_EQUAL( "RESV" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "RESV" ) ));
+    BOOST_CHECK_EQUAL( "REIN" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "REIN" ) ));
+    BOOST_CHECK_EQUAL( "VREP" , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "VREP" ) ));
+    BOOST_CHECK_EQUAL( "FLD"  , GroupInjection::ControlEnum2String(GroupInjection::ControlEnumFromString( "FLD"  ) ));
 }

 /*****************************************************************/

+BOOST_AUTO_TEST_CASE(TestGroupProductionControlEnum2String) {
+    BOOST_CHECK_EQUAL( "NONE" , GroupProduction::ControlEnum2String(GroupProduction::NONE));
+    BOOST_CHECK_EQUAL( "ORAT" , GroupProduction::ControlEnum2String(GroupProduction::ORAT));
+    BOOST_CHECK_EQUAL( "WRAT" , GroupProduction::ControlEnum2String(GroupProduction::WRAT));
+    BOOST_CHECK_EQUAL( "GRAT" , GroupProduction::ControlEnum2String(GroupProduction::GRAT));
+    BOOST_CHECK_EQUAL( "LRAT" , GroupProduction::ControlEnum2String(GroupProduction::LRAT));
+    BOOST_CHECK_EQUAL( "CRAT" , GroupProduction::ControlEnum2String(GroupProduction::CRAT));
+    BOOST_CHECK_EQUAL( "RESV" , GroupProduction::ControlEnum2String(GroupProduction::RESV));
+    BOOST_CHECK_EQUAL( "PRBL" , GroupProduction::ControlEnum2String(GroupProduction::PRBL));
+}
+
+
+BOOST_AUTO_TEST_CASE(TestGroupProductionControlEnumFromString) {
+    BOOST_CHECK_THROW( GroupProduction::ControlEnumFromString("XXX") , std::invalid_argument );
+    BOOST_CHECK_EQUAL(GroupProduction::NONE  , GroupProduction::ControlEnumFromString("NONE"));
+    BOOST_CHECK_EQUAL(GroupProduction::ORAT  , GroupProduction::ControlEnumFromString("ORAT"));
+    BOOST_CHECK_EQUAL(GroupProduction::WRAT  , GroupProduction::ControlEnumFromString("WRAT"));
+    BOOST_CHECK_EQUAL(GroupProduction::GRAT  , GroupProduction::ControlEnumFromString("GRAT"));
+    BOOST_CHECK_EQUAL(GroupProduction::LRAT  , GroupProduction::ControlEnumFromString("LRAT"));
+    BOOST_CHECK_EQUAL(GroupProduction::CRAT  , GroupProduction::ControlEnumFromString("CRAT"));
+    BOOST_CHECK_EQUAL(GroupProduction::RESV  , GroupProduction::ControlEnumFromString("RESV"));
+    BOOST_CHECK_EQUAL(GroupProduction::PRBL  , GroupProduction::ControlEnumFromString("PRBL"));
+}
+
+
+
+BOOST_AUTO_TEST_CASE(TestGroupProductionControlEnumLoop) {
+    BOOST_CHECK_EQUAL( GroupProduction::NONE, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::NONE ) ));
+    BOOST_CHECK_EQUAL( GroupProduction::ORAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::ORAT ) ));
+    BOOST_CHECK_EQUAL( GroupProduction::WRAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::WRAT ) ));
+    BOOST_CHECK_EQUAL( GroupProduction::GRAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::GRAT ) ));
+    BOOST_CHECK_EQUAL( GroupProduction::LRAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::LRAT ) ));
+    BOOST_CHECK_EQUAL( GroupProduction::CRAT, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::CRAT ) ));
+    BOOST_CHECK_EQUAL( GroupProduction::RESV, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::RESV ) ));
+    BOOST_CHECK_EQUAL( GroupProduction::PRBL, GroupProduction::ControlEnumFromString( GroupProduction::ControlEnum2String( GroupProduction::PRBL ) ));
+
+    BOOST_CHECK_EQUAL( "NONE" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "NONE" ) ));
+    BOOST_CHECK_EQUAL( "ORAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "ORAT" ) ));
+    BOOST_CHECK_EQUAL( "WRAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "WRAT" ) ));
+    BOOST_CHECK_EQUAL( "GRAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "GRAT" ) ));
+    BOOST_CHECK_EQUAL( "LRAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "LRAT" ) ));
+    BOOST_CHECK_EQUAL( "CRAT" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "CRAT" ) ));
+    BOOST_CHECK_EQUAL( "RESV" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "RESV" ) ));
+    BOOST_CHECK_EQUAL( "PRBL" , GroupProduction::ControlEnum2String(GroupProduction::ControlEnumFromString( "PRBL" ) ));
+}
+
+/*****************************************************************/
+
+BOOST_AUTO_TEST_CASE(TestGroupProductionExceedLimitControlEnum2String) {
+    BOOST_CHECK_EQUAL( "NONE"     , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::NONE));
+    BOOST_CHECK_EQUAL( "CON"      , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::CON));
+    BOOST_CHECK_EQUAL( "+CON"     , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::CON_PLUS));
+    BOOST_CHECK_EQUAL( "WELL"     , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::WELL));
+    BOOST_CHECK_EQUAL( "PLUG"     , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::PLUG));
+    BOOST_CHECK_EQUAL( "RATE"     , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::RATE));
+}
+
+
+BOOST_AUTO_TEST_CASE(TestGroupProductionExceedLimitActionEnumFromString) {
+    BOOST_CHECK_THROW( GroupProductionExceedLimit::ActionEnumFromString("XXX") , std::invalid_argument );
+    
+    BOOST_CHECK_EQUAL(GroupProductionExceedLimit::NONE     , GroupProductionExceedLimit::ActionEnumFromString("NONE"));
+    BOOST_CHECK_EQUAL(GroupProductionExceedLimit::CON      , GroupProductionExceedLimit::ActionEnumFromString("CON" ));
+    BOOST_CHECK_EQUAL(GroupProductionExceedLimit::CON_PLUS , GroupProductionExceedLimit::ActionEnumFromString("+CON"));
+    BOOST_CHECK_EQUAL(GroupProductionExceedLimit::WELL     , GroupProductionExceedLimit::ActionEnumFromString("WELL"));
+    BOOST_CHECK_EQUAL(GroupProductionExceedLimit::PLUG     , GroupProductionExceedLimit::ActionEnumFromString("PLUG"));
+    BOOST_CHECK_EQUAL(GroupProductionExceedLimit::RATE     , GroupProductionExceedLimit::ActionEnumFromString("RATE"));
+}
+
+
+
+BOOST_AUTO_TEST_CASE(TestGroupProductionExceedLimitActionEnumLoop) {
+    BOOST_CHECK_EQUAL( GroupProductionExceedLimit::NONE     , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::NONE     ) ));
+    BOOST_CHECK_EQUAL( GroupProductionExceedLimit::CON      , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::CON      ) ));
+    BOOST_CHECK_EQUAL( GroupProductionExceedLimit::CON_PLUS , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::CON_PLUS ) ));
+    BOOST_CHECK_EQUAL( GroupProductionExceedLimit::WELL     , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::WELL     ) ));
+    BOOST_CHECK_EQUAL( GroupProductionExceedLimit::PLUG     , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::PLUG     ) ));
+    BOOST_CHECK_EQUAL( GroupProductionExceedLimit::RATE     , GroupProductionExceedLimit::ActionEnumFromString( GroupProductionExceedLimit::ActionEnum2String( GroupProductionExceedLimit::RATE     ) ));
+
+    BOOST_CHECK_EQUAL("NONE" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "NONE" ) ));
+    BOOST_CHECK_EQUAL("CON"  , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "CON"  ) ));
+    BOOST_CHECK_EQUAL("+CON" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "+CON" ) ));
+    BOOST_CHECK_EQUAL("WELL" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "WELL" ) ));
+    BOOST_CHECK_EQUAL("PLUG" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "PLUG" ) ));
+    BOOST_CHECK_EQUAL("RATE" , GroupProductionExceedLimit::ActionEnum2String(GroupProductionExceedLimit::ActionEnumFromString( "RATE" ) ));
+}
+
+
+/*****************************************************************/

 BOOST_AUTO_TEST_CASE(TestPhaseEnum2String) {
    BOOST_CHECK_EQUAL( "OIL" , PhaseEnum2String(OIL));
--- a/opm/parser/eclipse/IntegrationTests/ScheduleCreateFromDeck.cpp
+++ b/opm/parser/eclipse/IntegrationTests/ScheduleCreateFromDeck.cpp
@@ -135,13 +135,13 @@ BOOST_AUTO_TEST_CASE( WellTestGroups ) {

    GroupPtr group = sched->getGroup("INJ");
    BOOST_CHECK_EQUAL( WATER , group->getInjectionPhase( 3 ));
-    BOOST_CHECK_EQUAL( VREP , group->getInjectionControlMode( 3 ));
+    BOOST_CHECK_EQUAL( GroupInjection::VREP , group->getInjectionControlMode( 3 ));
    BOOST_CHECK_EQUAL( 10 , group->getSurfaceMaxRate( 3 ));
    BOOST_CHECK_EQUAL( 20 , group->getReservoirMaxRate( 3 ));
    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( RATE , group->getInjectionControlMode( 6 ));
+    BOOST_CHECK_EQUAL( GroupInjection::RATE , group->getInjectionControlMode( 6 ));
    BOOST_CHECK_EQUAL( 1000 , group->getSurfaceMaxRate( 6 ));
 }