From 57566ad768f7855ebf15f2ce3c572b3de8e1556e Mon Sep 17 00:00:00 2001 From: Joakim Hove Date: Thu, 5 Nov 2020 11:15:20 +0100 Subject: [PATCH] Revert "Igrp prod" --- opm/output/eclipse/VectorItems/group.hpp | 8 - .../EclipseState/Schedule/ScheduleTypes.hpp | 5 +- src/opm/output/eclipse/AggregateGroupData.cpp | 367 +++++++++--------- .../EclipseState/Schedule/ScheduleTypes.cpp | 32 +- 4 files changed, 205 insertions(+), 207 deletions(-) diff --git a/opm/output/eclipse/VectorItems/group.hpp b/opm/output/eclipse/VectorItems/group.hpp index 444a2bfb5..ec22a719e 100644 --- a/opm/output/eclipse/VectorItems/group.hpp +++ b/opm/output/eclipse/VectorItems/group.hpp @@ -61,8 +61,6 @@ namespace Opm { namespace RestartIO { namespace Helpers { namespace VectorItems WInjCMode = 16, GConProdCMode = 10, GInjCMode = 21, - GroupType = 26, - GroupLevel = 27, ParentGroup = 28, FlowingWells = 33, }; @@ -78,12 +76,6 @@ namespace Opm { namespace RestartIO { namespace Helpers { namespace VectorItems Form = 8, Comb = 9, }; - - enum GroupType : int { - WellGroup = 0, - TreeGroup = 1, - }; - } } diff --git a/opm/parser/eclipse/EclipseState/Schedule/ScheduleTypes.hpp b/opm/parser/eclipse/EclipseState/Schedule/ScheduleTypes.hpp index 468e5f043..a75dd2c02 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/ScheduleTypes.hpp +++ b/opm/parser/eclipse/EclipseState/Schedule/ScheduleTypes.hpp @@ -58,14 +58,13 @@ public: int ecl_phase() const; Phase preferred_phase() const; InjectorType injector_type() const; - Phase injection_phase() const; bool operator==(const WellType& other) const; template void serializeOp(Serializer& serializer) { serializer(m_producer); - serializer(m_injection_phase); + serializer(injection_phase); serializer(m_welspecs_phase); } @@ -84,7 +83,7 @@ private: used when initializing the well equations for a producer. */ - Phase m_injection_phase; + Phase injection_phase; Phase m_welspecs_phase; }; diff --git a/src/opm/output/eclipse/AggregateGroupData.cpp b/src/opm/output/eclipse/AggregateGroupData.cpp index 6e250386e..ead49af4b 100644 --- a/src/opm/output/eclipse/AggregateGroupData.cpp +++ b/src/opm/output/eclipse/AggregateGroupData.cpp @@ -116,72 +116,90 @@ int currentGroupLevel(const Opm::Schedule& sched, const Opm::Group& group, const } } -void groupProductionControllable(const Opm::Schedule& sched, const Opm::SummaryState& sumState, const Opm::Group& group, const size_t simStep, bool& controllable) +bool groupProductionControllable(const Opm::Schedule& sched, const Opm::SummaryState& sumState, const Opm::Group& group, const size_t simStep) { using wellCtrlMode = ::Opm::RestartIO::Helpers::VectorItems::IWell::Value::WellCtrlMode; - if (controllable) - return; - - for (const auto& group_name : group.groups()) - groupProductionControllable(sched, sumState, sched.getGroup(group_name, simStep), simStep, controllable); - - for (const auto& well_name : group.wells()) { - const auto& well = sched.getWell(well_name, simStep); - if (well.isProducer()) { - int cur_prod_ctrl = 0; - // Find control mode for well - const std::string sum_key = "WMCTL"; - if (sumState.has_well_var(well_name, sum_key)) { - cur_prod_ctrl = static_cast(sumState.get_well_var(well_name, sum_key)); - } - if (cur_prod_ctrl == wellCtrlMode::Group) { - controllable = true; - return; + bool controllable = false; + if (group.defined( simStep )) { + if (!group.wellgroup()) { + if(!group.groups().empty()) { + for (const auto& group_name : group.groups()) { + if (groupProductionControllable(sched, sumState, sched.getGroup(group_name, simStep), simStep)) { + controllable = true; + continue; + } + } } } + else { + for (const auto& well_name : group.wells()) { + const auto& well = sched.getWell(well_name, simStep); + if (well.isProducer()) { + int cur_prod_ctrl = 0; + // Find control mode for well + std::string well_key_1 = "WMCTL:" + well_name; + if (sumState.has(well_key_1)) { + cur_prod_ctrl = static_cast(sumState.get(well_key_1)); + } + if (cur_prod_ctrl == wellCtrlMode::Group) { + controllable = true; + continue; + } + } + } + } + return controllable; + } else { + std::stringstream str; + str << "actual group has not been defined at report time: " << simStep; + throw std::invalid_argument(str.str()); } } - -bool groupProductionControllable(const Opm::Schedule& sched, const Opm::SummaryState& sumState, const Opm::Group& group, const size_t simStep) { - bool controllable = false; - groupProductionControllable(sched, sumState, group, simStep, controllable); - return controllable; -} - - -void groupInjectionControllable(const Opm::Schedule& sched, const Opm::SummaryState& sumState, const Opm::Group& group, const Opm::Phase& iPhase, const size_t simStep, bool& controllable) +bool groupInjectionControllable(const Opm::Schedule& sched, const Opm::SummaryState& sumState, const Opm::Group& group, const Opm::Phase& iPhase, const size_t simStep) { using wellCtrlMode = ::Opm::RestartIO::Helpers::VectorItems::IWell::Value::WellCtrlMode; - if (controllable) - return; - - for (const auto& group_name : group.groups()) - groupInjectionControllable(sched, sumState, sched.getGroup(group_name, simStep), iPhase, simStep, controllable); - - for (const auto& well_name : group.wells()) { - const auto& well = sched.getWell(well_name, simStep); - if (well.isInjector() && iPhase == well.wellType().injection_phase()) { - int cur_inj_ctrl = 0; - // Find control mode for well - const std::string sum_key = "WMCTL"; - if (sumState.has_well_var(well_name, sum_key)) { - cur_inj_ctrl = static_cast(sumState.get_well_var(well_name, sum_key)); - } - - if (cur_inj_ctrl == wellCtrlMode::Group) { - controllable = true; - return; + bool controllable = false; + if (group.defined( simStep )) { + if (!group.wellgroup()) { + if(!group.groups().empty()) { + for (const auto& group_name : group.groups()) { + if (groupInjectionControllable(sched, sumState, sched.getGroup(group_name, simStep), iPhase, simStep)) { + controllable = true; + continue; + } + } } } + else { + for (const auto& well_name : group.wells()) { + const auto& well = sched.getWell(well_name, simStep); + if (well.isInjector()) { + if (((iPhase == Opm::Phase::WATER) && (well.injectionControls(sumState).injector_type == Opm::InjectorType::WATER)) || + ((iPhase == Opm::Phase::GAS) && (well.injectionControls(sumState).injector_type == Opm::InjectorType::GAS)) + ) { + int cur_inj_ctrl = 0; + // Find control mode for well + std::string well_key_1 = "WMCTL:" + well_name; + if (sumState.has(well_key_1)) { + cur_inj_ctrl = static_cast(sumState.get(well_key_1)); + } + if (cur_inj_ctrl == wellCtrlMode::Group) { + controllable = true; + continue; + } + } + } + } + } + return controllable; + } else { + std::stringstream str; + str << "actual group has not been defined at report time: " << simStep; + throw std::invalid_argument(str.str()); } } -bool groupInjectionControllable(const Opm::Schedule& sched, const Opm::SummaryState& sumState, const Opm::Group& group, const Opm::Phase& iPhase, const size_t simStep) { - bool controllable = false; - groupInjectionControllable(sched, sumState, group, iPhase, simStep, controllable); - return controllable; -} int higherLevelProdControlGroupSeqIndex(const Opm::Schedule& sched, @@ -377,6 +395,20 @@ int higherLevelInjCMode_NotNoneFld_SeqIndex(const Opm::Schedule& sched, } +int groupType(const Opm::Group& group) { + if (group.wellgroup()) + return 0; + else + return 1; +} + + +std::size_t groupSize(const Opm::Group& group) { + if (group.wellgroup()) + return group.wells().size(); + else + return group.groups().size(); +} namespace IGrp { std::size_t entriesPerGroup(const std::vector& inteHead) @@ -397,40 +429,6 @@ allocate(const std::vector& inteHead) -template -void gconprodCMode(const Opm::Group& group, - const int nwgmax, - IGrpArray& iGrp) { - using IGroup = ::Opm::RestartIO::Helpers::VectorItems::IGroup::index; - - const auto& prod_cmode = group.gconprod_cmode(); - switch (prod_cmode) { - case Opm::Group::ProductionCMode::NONE: - iGrp[nwgmax + IGroup::GConProdCMode] = 0; - break; - case Opm::Group::ProductionCMode::ORAT: - iGrp[nwgmax + IGroup::GConProdCMode] = 1; - break; - case Opm::Group::ProductionCMode::WRAT: - iGrp[nwgmax + IGroup::GConProdCMode] = 2; - break; - case Opm::Group::ProductionCMode::GRAT: - iGrp[nwgmax + IGroup::GConProdCMode] = 3; - break; - case Opm::Group::ProductionCMode::LRAT: - iGrp[nwgmax + IGroup::GConProdCMode] = 4; - break; - case Opm::Group::ProductionCMode::RESV: - iGrp[nwgmax + IGroup::GConProdCMode] = 5; - break; - case Opm::Group::ProductionCMode::FLD: - iGrp[nwgmax + IGroup::GConProdCMode] = 0; // need to be checked!! - break; - default: - iGrp[nwgmax + IGroup::GConProdCMode] = 0; // need to be checked!! - } -} - template void productionGroup(const Opm::Schedule& sched, @@ -443,23 +441,50 @@ void productionGroup(const Opm::Schedule& sched, { using IGroup = ::Opm::RestartIO::Helpers::VectorItems::IGroup::index; namespace Value = ::Opm::RestartIO::Helpers::VectorItems::IGroup::Value; - gconprodCMode(group, nwgmax, iGrp); - + const auto& prod_cmode = group.gconprod_cmode(); if (group.name() == "FIELD") { iGrp[nwgmax + IGroup::GuideRateDef] = Value::GuideRateMode::None; iGrp[nwgmax + 7] = 0; + switch (prod_cmode) { + case Opm::Group::ProductionCMode::NONE: + iGrp[nwgmax + IGroup::GConProdCMode] = 0; + break; + case Opm::Group::ProductionCMode::ORAT: + iGrp[nwgmax + IGroup::GConProdCMode] = 1; + break; + case Opm::Group::ProductionCMode::WRAT: + iGrp[nwgmax + IGroup::GConProdCMode] = 2; + break; + case Opm::Group::ProductionCMode::GRAT: + iGrp[nwgmax + IGroup::GConProdCMode] = 3; + break; + case Opm::Group::ProductionCMode::LRAT: + iGrp[nwgmax + IGroup::GConProdCMode] = 4; + break; + case Opm::Group::ProductionCMode::RESV: + iGrp[nwgmax + IGroup::GConProdCMode] = 5; + break; + case Opm::Group::ProductionCMode::FLD: + iGrp[nwgmax + IGroup::GConProdCMode] = 0; + break; + default: + iGrp[nwgmax + IGroup::GConProdCMode] = 0; + } return; } - const auto& production_controls = group.productionControls(sumState); - const auto& prod_guide_rate_def = production_controls.guide_rate_def; - Opm::Group::ProductionCMode active_cmode = Opm::Group::ProductionCMode::NONE; - { - auto cur_prod_ctrl = sumState.get_group_var(group.name(), "GMCTP", -1); - if (cur_prod_ctrl >= 0) - active_cmode = pCtrlToPCmode.at(static_cast(cur_prod_ctrl)); - } + const auto& prod_guide_rate_def = group.productionControls(sumState).guide_rate_def; + const auto& p_exceed_act = group.productionControls(sumState).exceed_action; + // Find production control mode for group + const double cur_prod_ctrl = sumState.get_group_var(group.name(), "GMCTP", -1); + Opm::Group::ProductionCMode pctl_mode = Opm::Group::ProductionCMode::NONE; + if (cur_prod_ctrl >= 0) { + const auto it_ctrl = pCtrlToPCmode.find(cur_prod_ctrl); + if (it_ctrl != pCtrlToPCmode.end()) { + pctl_mode = it_ctrl->second; + } + } #if ENABLE_GCNTL_DEBUG_OUTPUT else { // std::stringstream str; @@ -497,7 +522,6 @@ void productionGroup(const Opm::Schedule& sched, iGrp[nwgmax + 5] = -1; const int higher_lev_ctrl = higherLevelProdControlGroupSeqIndex(sched, sumState, group, simStep); const int higher_lev_ctrl_mode = higherLevelProdControlMode(sched, sumState, group, simStep); - const auto& deck_cmode = group.gconprod_cmode(); // Start branching for determining iGrp[nwgmax + 5] // use default value if group is not available for group control if (groupProductionControllable(sched, sumState, group, simStep)) { @@ -505,31 +529,31 @@ void productionGroup(const Opm::Schedule& sched, if (!group.productionGroupControlAvailable() && (higher_lev_ctrl <= 0)) { // group can respond to higher level control iGrp[nwgmax + 5] = 0; - } else if (((active_cmode != Opm::Group::ProductionCMode::NONE)) && (higher_lev_ctrl < 0)) { + } else if (((pctl_mode != Opm::Group::ProductionCMode::NONE)) && (higher_lev_ctrl < 0)) { // group is constrained by its own limits or controls - // if (active_cmode != Opm::Group::ProductionCMode::FLD) - need to use this test? - else remove + // if (pctl_mode != Opm::Group::ProductionCMode::FLD) - need to use this test? - else remove iGrp[nwgmax + 5] = -1; // only value that seems to work when no group at higher level has active control } else if (higher_lev_ctrl > 0) { - if (((deck_cmode == Opm::Group::ProductionCMode::FLD) || (deck_cmode == Opm::Group::ProductionCMode::NONE)) - && (prod_guide_rate_def != Opm::Group::GuideRateTarget::NO_GUIDE_RATE)) { + if (((prod_cmode == Opm::Group::ProductionCMode::FLD) || (prod_cmode == Opm::Group::ProductionCMode::NONE)) + && (group.productionControls(sumState).guide_rate_def != Opm::Group::GuideRateTarget::NO_GUIDE_RATE)) { iGrp[nwgmax + 5] = higher_lev_ctrl; } else { iGrp[nwgmax + 5] = 1; } } else if (higherLevelProdCMode_NotNoneFld(sched, group, simStep)) { - if (!((deck_cmode == Opm::Group::ProductionCMode::FLD) - || (deck_cmode == Opm::Group::ProductionCMode::NONE))) { + if (!((prod_cmode == Opm::Group::ProductionCMode::FLD) + || (prod_cmode == Opm::Group::ProductionCMode::NONE))) { iGrp[nwgmax + 5] = -1; } else { iGrp[nwgmax + 5] = 1; } - } else if ((deck_cmode == Opm::Group::ProductionCMode::FLD) - || (deck_cmode == Opm::Group::ProductionCMode::NONE)) { + } else if ((prod_cmode == Opm::Group::ProductionCMode::FLD) + || (prod_cmode == Opm::Group::ProductionCMode::NONE)) { iGrp[nwgmax + 5] = -1; } else { iGrp[nwgmax + 5] = -1; } - } else if (deck_cmode == Opm::Group::ProductionCMode::NONE) { + } else if (prod_cmode == Opm::Group::ProductionCMode::NONE) { iGrp[nwgmax + 5] = 1; } @@ -553,7 +577,7 @@ void productionGroup(const Opm::Schedule& sched, iGrp[nwgmax + IGroup::ProdActiveCMode] = (prod_guide_rate_def != Opm::Group::GuideRateTarget::NO_GUIDE_RATE) ? higher_lev_ctrl_mode : 0; } else { - switch (active_cmode) { + switch (pctl_mode) { case Opm::Group::ProductionCMode::NONE: iGrp[nwgmax + IGroup::ProdActiveCMode] = 0; break; @@ -582,35 +606,41 @@ void productionGroup(const Opm::Schedule& sched, iGrp[nwgmax + 9] = iGrp[nwgmax + IGroup::ProdActiveCMode]; iGrp[nwgmax + IGroup::GuideRateDef] = Value::GuideRateMode::None; - - const auto& p_exceed_act = production_controls.exceed_action; - switch (deck_cmode) { + switch (prod_cmode) { case Opm::Group::ProductionCMode::NONE: iGrp[nwgmax + 7] = (p_exceed_act == Opm::Group::ExceedAction::NONE) ? 0 : 4; + iGrp[nwgmax + IGroup::GConProdCMode] = 0; break; case Opm::Group::ProductionCMode::ORAT: iGrp[nwgmax + 7] = (p_exceed_act == Opm::Group::ExceedAction::NONE) ? -40000 : 4; + iGrp[nwgmax + IGroup::GConProdCMode] = 1; break; case Opm::Group::ProductionCMode::WRAT: iGrp[nwgmax + 7] = (p_exceed_act == Opm::Group::ExceedAction::NONE) ? -4000 : 4; + iGrp[nwgmax + IGroup::GConProdCMode] = 2; break; case Opm::Group::ProductionCMode::GRAT: iGrp[nwgmax + 7] = (p_exceed_act == Opm::Group::ExceedAction::NONE) ? -400 : 4; + iGrp[nwgmax + IGroup::GConProdCMode] = 3; break; case Opm::Group::ProductionCMode::LRAT: iGrp[nwgmax + 7] = (p_exceed_act == Opm::Group::ExceedAction::NONE) ? -40 : 4; + iGrp[nwgmax + IGroup::GConProdCMode] = 4; break; case Opm::Group::ProductionCMode::RESV: iGrp[nwgmax + 7] = (p_exceed_act == Opm::Group::ExceedAction::NONE) ? -4 : 4; // need to be checked + iGrp[nwgmax + IGroup::GConProdCMode] = 5; break; case Opm::Group::ProductionCMode::FLD: if ((higher_lev_ctrl > 0) && (prod_guide_rate_def != Opm::Group::GuideRateTarget::NO_GUIDE_RATE)) { iGrp[nwgmax + IGroup::GuideRateDef] = Value::GuideRateMode::Form; } iGrp[nwgmax + 7] = (p_exceed_act == Opm::Group::ExceedAction::NONE) ? 4 : 4; + iGrp[nwgmax + IGroup::GConProdCMode] = 0; // need to be checked!! break; default: iGrp[nwgmax + 7] = 0; + iGrp[nwgmax + IGroup::GConProdCMode] = 0; // need to be checked!! } } @@ -629,7 +659,6 @@ void injectionGroup(const Opm::Schedule& sched, auto group_parent_list = groupParentSeqIndex(sched, group, simStep); using IGroup = ::Opm::RestartIO::Helpers::VectorItems::IGroup::index; - // set "default value" in case a group is only injection group if (group.isInjectionGroup() && !group.isProductionGroup()) { iGrp[nwgmax + 5] = 1; @@ -798,67 +827,6 @@ void injectionGroup(const Opm::Schedule& sched, } } -template -void storeGroupTree(const Opm::Schedule& sched, - const Opm::Group& group, - const int nwgmax, - const int ngmaxz, - const std::size_t simStep, - IGrpArray& iGrp) { - - namespace Value = ::Opm::RestartIO::Helpers::VectorItems::IGroup::Value; - using IGroup = ::Opm::RestartIO::Helpers::VectorItems::IGroup::index; - const bool is_field = group.name() == "FIELD"; - - // Store index of all child wells or child groups. - if (group.wellgroup()) { - int igrpCount = 0; - for (const auto& well_name : group.wells()) { - const auto& well = sched.getWell(well_name, simStep); - iGrp[igrpCount] = well.seqIndex() + 1; - igrpCount += 1; - } - iGrp[nwgmax] = group.wells().size(); - iGrp[nwgmax + IGroup::GroupType] = Value::GroupType::WellGroup; - } else { - int igrpCount = 0; - for (const auto& group_name : group.groups()) { - const auto& child_group = sched.getGroup(group_name, simStep); - iGrp[igrpCount] = child_group.insert_index(); - igrpCount += 1; - } - iGrp[nwgmax] = group.groups().size(); - iGrp[nwgmax + IGroup::GroupType] = Value::GroupType::TreeGroup; - } - - - // Store index of parent group - if (is_field) - iGrp[nwgmax + IGroup::ParentGroup] = 0; - else { - const auto& parent_group = sched.getGroup(group.parent(), simStep); - if (parent_group.name() == "FIELD") - iGrp[nwgmax + IGroup::ParentGroup] = ngmaxz; - else - iGrp[nwgmax + IGroup::ParentGroup] = parent_group.insert_index(); - } - - iGrp[nwgmax + IGroup::GroupLevel] = currentGroupLevel(sched, group, simStep); -} - - -template -void storeFlowingWells(const Opm::Group& group, - const int nwgmax, - const Opm::SummaryState& sumState, - IGrpArray& iGrp) { - using IGroup = ::Opm::RestartIO::Helpers::VectorItems::IGroup::index; - const bool is_field = group.name() == "FIELD"; - const double g_act_pwells = is_field ? sumState.get("FMWPR", 0) : sumState.get_group_var(group.name(), "GMWPR", 0); - const double g_act_iwells = is_field ? sumState.get("FMWIN", 0) : sumState.get_group_var(group.name(), "GMWIN", 0); - iGrp[nwgmax + IGroup::FlowingWells] = static_cast(g_act_pwells) + static_cast(g_act_iwells); -} - template void staticContrib(const Opm::Schedule& sched, @@ -871,22 +839,54 @@ void staticContrib(const Opm::Schedule& sched, const std::map& cmodeToNum, IGrpArray& iGrp) { + using IGroup = ::Opm::RestartIO::Helpers::VectorItems::IGroup::index; const bool is_field = group.name() == "FIELD"; + if (group.wellgroup()) { + int igrpCount = 0; + //group has child wells + //store the well number (sequence index) in iGrp according to the sequence they are defined + for (const auto& well_name : group.wells()) { + const auto& well = sched.getWell(well_name, simStep); + iGrp[igrpCount] = well.seqIndex() + 1; + igrpCount += 1; + } + } else if (!group.groups().empty()) { + int igrpCount = 0; + for (const auto& group_name : group.groups()) { + const auto& child_group = sched.getGroup(group_name, simStep); + iGrp[igrpCount] = child_group.insert_index(); + igrpCount += 1; + } + } - storeGroupTree(sched, group, nwgmax, ngmaxz, simStep, iGrp); - storeFlowingWells(group, nwgmax, sumState, iGrp); + //assign the number of child wells or child groups to + // location nwgmax + iGrp[nwgmax] = groupSize(group); - iGrp[nwgmax + 17] = -1; - iGrp[nwgmax + 22] = -1; + // Find number of active production wells and injection wells for group + const double g_act_pwells = is_field ? sumState.get("FMWPR", 0) : sumState.get_group_var(group.name(), "GMWPR", 0); + const double g_act_iwells = is_field ? sumState.get("FMWIN", 0) : sumState.get_group_var(group.name(), "GMWIN", 0); + iGrp[nwgmax + IGroup::FlowingWells] = g_act_pwells + g_act_iwells; // Treat al groups which are *not* pure injection groups. if (group.getGroupType() != Opm::Group::GroupType::INJECTION) productionGroup(sched, group, nwgmax, simStep, sumState, pCtrlToPCmode, iGrp); + //default value - + iGrp[nwgmax + 17] = -1; + iGrp[nwgmax + 22] = -1; // Treat al groups which are *not* pure production groups. if (group.getGroupType() != Opm::Group::GroupType::PRODUCTION) injectionGroup(sched, group, nwgmax, simStep, sumState, cmodeToNum, iGrp); + iGrp[nwgmax + 26] = groupType(group); + + //find group level ("FIELD" is level 0) and store the level in + //location nwgmax + 27 + iGrp[nwgmax+27] = currentGroupLevel(sched, group, simStep); + + // set values for group probably connected to GCONPROD settings + // if (is_field) { //the maximum number of groups in the model @@ -907,6 +907,21 @@ void staticContrib(const Opm::Schedule& sched, iGrp[nwgmax+95] = group.insert_index(); iGrp[nwgmax+96] = group.insert_index(); } + + //find parent group and store index of parent group in + //location nwgmax + IGroup::ParentGroup + + using IGroup = ::Opm::RestartIO::Helpers::VectorItems::IGroup::index; + if (is_field) + iGrp[nwgmax + IGroup::ParentGroup] = 0; + else { + const auto& parent_group = sched.getGroup(group.parent(), simStep); + if (parent_group.name() == "FIELD") + iGrp[nwgmax + IGroup::ParentGroup] = ngmaxz; + else + iGrp[nwgmax + IGroup::ParentGroup] = parent_group.insert_index(); + } + } } // Igrp diff --git a/src/opm/parser/eclipse/EclipseState/Schedule/ScheduleTypes.cpp b/src/opm/parser/eclipse/EclipseState/Schedule/ScheduleTypes.cpp index 12f27631d..d1b0dc99b 100644 --- a/src/opm/parser/eclipse/EclipseState/Schedule/ScheduleTypes.cpp +++ b/src/opm/parser/eclipse/EclipseState/Schedule/ScheduleTypes.cpp @@ -87,17 +87,9 @@ bool WellType::gas_injector(int ecl_wtype) { return ecl_wtype == ecl::gas_injector; } -Phase WellType::injection_phase() const { - if (this->m_producer) - throw std::logic_error("Asked for injection phase in a producer"); - - return this->m_injection_phase; -} - - WellType::WellType(int ecl_wtype, int ecl_phase) : - m_injection_phase(ecl::from_ecl_phase(ecl_phase)), + injection_phase(ecl::from_ecl_phase(ecl_phase)), m_welspecs_phase(ecl::from_ecl_phase(ecl_phase)) { this->m_producer = false; @@ -106,13 +98,13 @@ WellType::WellType(int ecl_wtype, int ecl_phase) : this->m_producer = true; break; case ecl::oil_injector: - this->m_injection_phase = Phase::OIL; + this->injection_phase = Phase::OIL; break; case ecl::water_injector: - this->m_injection_phase = Phase::WATER; + this->injection_phase = Phase::WATER; break; case ecl::gas_injector: - this->m_injection_phase = Phase::GAS; + this->injection_phase = Phase::GAS; break; default: throw std::invalid_argument("Invalid integer well type ID"); @@ -122,7 +114,7 @@ WellType::WellType(int ecl_wtype, int ecl_phase) : WellType::WellType(bool producer, Phase phase) : m_producer(producer), - m_injection_phase(phase), + injection_phase(phase), m_welspecs_phase(phase) {} @@ -134,7 +126,7 @@ WellType WellType::serializeObject() { WellType result; result.m_producer = true; - result.m_injection_phase = Phase::OIL; + result.injection_phase = Phase::OIL; result.m_welspecs_phase = Phase::WATER; return result; @@ -156,8 +148,8 @@ bool WellType::update(InjectorType injector_type) { } auto inj_phase = from_injector_type(injector_type); - if (this->m_injection_phase != inj_phase) { - this->m_injection_phase = inj_phase; + if (this->injection_phase != inj_phase) { + this->injection_phase = inj_phase; ret_value = true; } @@ -176,7 +168,7 @@ int WellType::ecl_wtype() const { if (this->m_producer) return ecl::producer; - switch (this->m_injection_phase) { + switch (this->injection_phase) { case Phase::OIL: return ecl::oil_injector; case Phase::WATER: @@ -209,13 +201,13 @@ int WellType::ecl_phase() const { Phase WellType::preferred_phase() const { - return this->injector() ? this->m_injection_phase : this->m_welspecs_phase; + return this->injector() ? this->injection_phase : this->m_welspecs_phase; } bool WellType::operator==(const WellType& other) const { return this->m_welspecs_phase == other.m_welspecs_phase && - this->m_injection_phase == other.m_injection_phase && + this->injection_phase == other.injection_phase && this->m_producer == other.m_producer; } @@ -224,7 +216,7 @@ InjectorType WellType::injector_type() const { if (this->producer()) throw std::invalid_argument("Asked for injector type for a well which is a producer"); - switch (this->m_injection_phase) { + switch (this->injection_phase) { case Phase::OIL: return InjectorType::OIL; case Phase::WATER: