From 2a1d42edcbb3324556fff0fd98d757bb93d78d0b Mon Sep 17 00:00:00 2001 From: Joakim Hove Date: Mon, 22 Jul 2019 17:05:26 +0200 Subject: [PATCH] Use class Group2 from opm-common --- opm/core/wells/WellCollection.cpp | 8 +++---- opm/core/wells/WellCollection.hpp | 6 ++--- opm/core/wells/WellsGroup.cpp | 36 +++++++++++++++------------- opm/core/wells/WellsGroup.hpp | 4 ++-- opm/core/wells/WellsManager_impl.hpp | 4 ++-- tests/test_wellcollection.cpp | 14 +++++------ tests/test_wellsgroup.cpp | 36 +++++++++++++++------------- 7 files changed, 57 insertions(+), 51 deletions(-) diff --git a/opm/core/wells/WellCollection.cpp b/opm/core/wells/WellCollection.cpp index d76815143..9c22e9935 100644 --- a/opm/core/wells/WellCollection.cpp +++ b/opm/core/wells/WellCollection.cpp @@ -21,7 +21,7 @@ #include #include -#include +#include #include #include @@ -30,7 +30,7 @@ namespace Opm { - void WellCollection::addField(const Group& fieldGroup, size_t timeStep, const PhaseUsage& phaseUsage) { + void WellCollection::addField(const Group2& fieldGroup, size_t timeStep, const PhaseUsage& phaseUsage) { WellsGroupInterface* fieldNode = findNode(fieldGroup.name()); if (fieldNode) { OPM_THROW(std::runtime_error, "Trying to add FIELD node, but this already exists. Can only have one FIELD node."); @@ -39,7 +39,7 @@ namespace Opm roots_.push_back(createGroupWellsGroup(fieldGroup, timeStep, phaseUsage)); } - void WellCollection::addGroup(const Group& groupChild, std::string parent_name, + void WellCollection::addGroup(const Group2& groupChild, std::string parent_name, size_t timeStep, const PhaseUsage& phaseUsage) { WellsGroupInterface* parent = findNode(parent_name); if (!parent) { @@ -51,7 +51,7 @@ namespace Opm } - if (groupChild.isProductionGroup(timeStep) || groupChild.isInjectionGroup(timeStep)) { + if (groupChild.isProductionGroup() || groupChild.isInjectionGroup()) { group_control_active_ = true; } diff --git a/opm/core/wells/WellCollection.hpp b/opm/core/wells/WellCollection.hpp index 302463cb5..0c8392ade 100644 --- a/opm/core/wells/WellCollection.hpp +++ b/opm/core/wells/WellCollection.hpp @@ -27,7 +27,7 @@ #include #include -#include +#include namespace Opm { @@ -36,11 +36,11 @@ namespace Opm { public: - void addField(const Group& fieldGroup, size_t timeStep, const PhaseUsage& phaseUsage); + void addField(const Group2& fieldGroup, size_t timeStep, const PhaseUsage& phaseUsage); void addWell(const Well2& wellChild, const SummaryState& summaryState, size_t timeStep, const PhaseUsage& phaseUsage); - void addGroup(const Group& groupChild, std::string parent_name, + void addGroup(const Group2& groupChild, std::string parent_name, size_t timeStep, const PhaseUsage& phaseUsage); /// Adds the child to the collection diff --git a/opm/core/wells/WellsGroup.cpp b/opm/core/wells/WellsGroup.cpp index 6334090f4..e351cb808 100644 --- a/opm/core/wells/WellsGroup.cpp +++ b/opm/core/wells/WellsGroup.cpp @@ -1556,30 +1556,32 @@ namespace Opm } } // anonymous namespace - std::shared_ptr createGroupWellsGroup(const Group& group, size_t timeStep, const PhaseUsage& phase_usage ) + std::shared_ptr createGroupWellsGroup(const Group2& group, size_t timeStep, const PhaseUsage& phase_usage ) { InjectionSpecification injection_specification; ProductionSpecification production_specification; - if (group.isInjectionGroup(timeStep)) { - injection_specification.injector_type_ = toInjectorType(group.getInjectionPhase(timeStep)); - injection_specification.control_mode_ = toInjectionControlMode(GroupInjection::ControlEnum2String(group.getInjectionControlMode(timeStep))); - injection_specification.surface_flow_max_rate_ = group.getSurfaceMaxRate(timeStep); - injection_specification.reservoir_flow_max_rate_ = group.getReservoirMaxRate(timeStep); - injection_specification.reinjection_fraction_target_ = group.getTargetReinjectFraction(timeStep); - injection_specification.voidage_replacment_fraction_ = group.getTargetVoidReplacementFraction(timeStep); + if (group.isInjectionGroup()) { + const auto& injection = group.injectionProperties(); + injection_specification.injector_type_ = toInjectorType(injection.phase); + injection_specification.control_mode_ = toInjectionControlMode(GroupInjection::ControlEnum2String(injection.cmode)); + injection_specification.surface_flow_max_rate_ = injection.surface_max_rate; + injection_specification.reservoir_flow_max_rate_ = injection.resv_max_rate; + injection_specification.reinjection_fraction_target_ = injection.target_reinj_fraction; + injection_specification.voidage_replacment_fraction_ = injection.target_void_fraction; } - if (group.isProductionGroup(timeStep)) { - production_specification.oil_max_rate_ = group.getOilTargetRate(timeStep); - production_specification.control_mode_ = toProductionControlMode(GroupProduction::ControlEnum2String(group.getProductionControlMode(timeStep))); - production_specification.water_max_rate_ = group.getWaterTargetRate(timeStep); - production_specification.gas_max_rate_ = group.getGasTargetRate(timeStep); - production_specification.liquid_max_rate_ = group.getLiquidTargetRate(timeStep); - production_specification.procedure_ = toProductionProcedure(GroupProductionExceedLimit::ActionEnum2String(group.getProductionExceedLimitAction(timeStep))); - production_specification.reservoir_flow_max_rate_ = group.getReservoirVolumeTargetRate(timeStep); + if (group.isProductionGroup()) { + const auto& production = group.productionProperties(); + production_specification.oil_max_rate_ = production.oil_target; + production_specification.control_mode_ = toProductionControlMode(GroupProduction::ControlEnum2String(production.cmode)); + production_specification.water_max_rate_ = production.water_target; + production_specification.gas_max_rate_ = production.gas_target; + production_specification.liquid_max_rate_ = production.liquid_target; + production_specification.procedure_ = toProductionProcedure(GroupProductionExceedLimit::ActionEnum2String(production.exceed_action)); + production_specification.reservoir_flow_max_rate_ = production.resv_target; } - const double efficiency_factor = group.getGroupEfficiencyFactor(timeStep); + const double efficiency_factor = group.getGroupEfficiencyFactor(); std::shared_ptr wells_group(new WellsGroup(group.name(), efficiency_factor, production_specification, injection_specification, phase_usage)); return wells_group; diff --git a/opm/core/wells/WellsGroup.hpp b/opm/core/wells/WellsGroup.hpp index a1b3b3582..dc3aff107 100644 --- a/opm/core/wells/WellsGroup.hpp +++ b/opm/core/wells/WellsGroup.hpp @@ -26,7 +26,7 @@ #include #include -#include +#include #include #include @@ -549,7 +549,7 @@ namespace Opm /// \param[in] group the Group to construct object for /// \param[in] timeStep the time step in question /// \param[in] the phase usage - std::shared_ptr createGroupWellsGroup(const Group& group, size_t timeStep, + std::shared_ptr createGroupWellsGroup(const Group2& group, size_t timeStep, const PhaseUsage& phase_usage ); } diff --git a/opm/core/wells/WellsManager_impl.hpp b/opm/core/wells/WellsManager_impl.hpp index 1ef406351..4c3fb2d60 100644 --- a/opm/core/wells/WellsManager_impl.hpp +++ b/opm/core/wells/WellsManager_impl.hpp @@ -371,7 +371,7 @@ WellsManager::init(const Opm::EclipseState& eclipseState, setupWellControls(wells, summaryState, well_names, pu, wells_on_proc); { - const auto& fieldGroup = schedule.getGroup( "FIELD" ); + const auto& fieldGroup = schedule.getGroup2( "FIELD", timeStep); well_collection_.addField(fieldGroup, timeStep, pu); const auto& grouptree = schedule.getGroupTree( timeStep ); @@ -384,7 +384,7 @@ WellsManager::init(const Opm::EclipseState& eclipseState, group_stack.insert( group_stack.end(), children.begin(), children.end() ); for( const auto& child : children ) { - well_collection_.addGroup( schedule.getGroup( child ), parent, timeStep, pu ); + well_collection_.addGroup( schedule.getGroup2( child, timeStep ), parent, timeStep, pu ); } } while( !group_stack.empty() ); diff --git a/tests/test_wellcollection.cpp b/tests/test_wellcollection.cpp index a2f3837d3..8dcdd347e 100644 --- a/tests/test_wellcollection.cpp +++ b/tests/test_wellcollection.cpp @@ -29,7 +29,7 @@ #include #include #include -#include +#include #include using namespace Opm; @@ -50,11 +50,11 @@ BOOST_AUTO_TEST_CASE(AddWellsAndGroupToCollection) { WellCollection collection; // Add groups to WellCollection - const auto& fieldGroup = sched.getGroup("FIELD"); + const auto& fieldGroup = sched.getGroup2("FIELD", 2); collection.addField(fieldGroup, 2, pu); - collection.addGroup( sched.getGroup( "G1" ), fieldGroup.name(), 2, pu); - collection.addGroup( sched.getGroup( "G2" ), fieldGroup.name(), 2, pu); + collection.addGroup( sched.getGroup2( "G1", 2 ), fieldGroup.name(), 2, pu); + collection.addGroup( sched.getGroup2( "G2", 2 ), fieldGroup.name(), 2, pu); BOOST_CHECK_EQUAL("FIELD", collection.findNode("FIELD")->name()); BOOST_CHECK_EQUAL("FIELD", collection.findNode("G1")->getParent()->name()); @@ -89,10 +89,10 @@ BOOST_AUTO_TEST_CASE(EfficiencyFactor) { size_t timestep = 2; WellCollection collection; // Add groups to WellCollection - const auto& fieldGroup = sched.getGroup("FIELD"); + const auto& fieldGroup = sched.getGroup2("FIELD", timestep); collection.addField(fieldGroup, timestep, pu); - collection.addGroup( sched.getGroup( "G1" ), fieldGroup.name(), timestep, pu); - collection.addGroup( sched.getGroup( "G2" ), fieldGroup.name(), timestep, pu); + collection.addGroup( sched.getGroup2( "G1", timestep ), fieldGroup.name(), timestep, pu); + collection.addGroup( sched.getGroup2( "G2", timestep ), fieldGroup.name(), timestep, pu); BOOST_CHECK_EQUAL(1.0, collection.findNode("FIELD")->efficiencyFactor()); BOOST_CHECK_EQUAL(1.0, collection.findNode("G1")->getParent()->efficiencyFactor()); diff --git a/tests/test_wellsgroup.cpp b/tests/test_wellsgroup.cpp index bbe2f75ab..c951956ab 100644 --- a/tests/test_wellsgroup.cpp +++ b/tests/test_wellsgroup.cpp @@ -33,7 +33,7 @@ #include #include -#include +#include #include #include @@ -97,22 +97,26 @@ BOOST_AUTO_TEST_CASE(ConstructGroupFromGroup) { for( const auto& grp_name : sched.groupNames() ) { if( !nodes.exists( grp_name ) ) continue; - const auto& group = sched.getGroup(grp_name); + const auto& group = sched.getGroup2(grp_name, 2); std::shared_ptr wellsGroup = createGroupWellsGroup(group, 2, pu); BOOST_CHECK_EQUAL(group.name(), wellsGroup->name()); - if (group.isInjectionGroup(2)) { - BOOST_CHECK_EQUAL(group.getSurfaceMaxRate(2), wellsGroup->injSpec().surface_flow_max_rate_); - BOOST_CHECK_EQUAL(group.getReservoirMaxRate(2), wellsGroup->injSpec().reservoir_flow_max_rate_); - BOOST_CHECK_EQUAL(group.getTargetReinjectFraction(2), wellsGroup->injSpec().reinjection_fraction_target_); - BOOST_CHECK_EQUAL(group.getTargetVoidReplacementFraction(2), wellsGroup->injSpec().voidage_replacment_fraction_); + if (group.isInjectionGroup()) { + const auto& injection = group.injectionProperties(); + + BOOST_CHECK_EQUAL(injection.surface_max_rate, wellsGroup->injSpec().surface_flow_max_rate_); + BOOST_CHECK_EQUAL(injection.resv_max_rate, wellsGroup->injSpec().reservoir_flow_max_rate_); + BOOST_CHECK_EQUAL(injection.target_reinj_fraction, wellsGroup->injSpec().reinjection_fraction_target_); + BOOST_CHECK_EQUAL(injection.target_void_fraction, wellsGroup->injSpec().voidage_replacment_fraction_); } - if (group.isProductionGroup(2)) { - BOOST_CHECK_EQUAL(group.getReservoirVolumeTargetRate(2), wellsGroup->prodSpec().reservoir_flow_max_rate_); - BOOST_CHECK_EQUAL(group.getGasTargetRate(2), wellsGroup->prodSpec().gas_max_rate_); - BOOST_CHECK_EQUAL(group.getOilTargetRate(2), wellsGroup->prodSpec().oil_max_rate_); - BOOST_CHECK_EQUAL(group.getWaterTargetRate(2), wellsGroup->prodSpec().water_max_rate_); - BOOST_CHECK_EQUAL(group.getLiquidTargetRate(2), wellsGroup->prodSpec().liquid_max_rate_); + + if (group.isProductionGroup()) { + const auto& production = group.productionProperties(); + BOOST_CHECK_EQUAL(production.resv_target, wellsGroup->prodSpec().reservoir_flow_max_rate_); + BOOST_CHECK_EQUAL(production.gas_target, wellsGroup->prodSpec().gas_max_rate_); + BOOST_CHECK_EQUAL(production.oil_target, wellsGroup->prodSpec().oil_max_rate_); + BOOST_CHECK_EQUAL(production.water_target, wellsGroup->prodSpec().water_max_rate_); + BOOST_CHECK_EQUAL(production.liquid_target, wellsGroup->prodSpec().liquid_max_rate_); } } } @@ -133,12 +137,12 @@ BOOST_AUTO_TEST_CASE(EfficiencyFactor) { const auto& nodes = sched.getGroupTree(2); for( const auto& grp_name : sched.groupNames() ) { if( !nodes.exists( grp_name ) ) continue; - const auto& group = sched.getGroup(grp_name); + const auto& group = sched.getGroup2(grp_name, 2); std::shared_ptr wellsGroup = createGroupWellsGroup(group, 2, pu); BOOST_CHECK_EQUAL(group.name(), wellsGroup->name()); - BOOST_CHECK_EQUAL(group.getGroupEfficiencyFactor(2), wellsGroup->efficiencyFactor()); - BOOST_CHECK_EQUAL(group.getGroupEfficiencyFactor(2), wellsGroup->efficiencyFactor()); + BOOST_CHECK_EQUAL(group.getGroupEfficiencyFactor(), wellsGroup->efficiencyFactor()); + BOOST_CHECK_EQUAL(group.getGroupEfficiencyFactor(), wellsGroup->efficiencyFactor()); } }