Merge pull request #2228 from totto82/fixGP3

Fix the accumulation of the group potentials.

opm/simulators/wells/BlackoilWellModel_impl.hpp

@@ -392,7 +392,10 @@ namespace Opm {
             guideRate_->compute(well->name(), reportStepIdx, simulationTime, oilpot, gaspot, waterpot);
         }
         const Group& fieldGroup = schedule().getGroup("FIELD", reportStepIdx);
-        wellGroupHelpers::updateGuideRateForGroups(fieldGroup, schedule(), phase_usage_, reportStepIdx, simulationTime, guideRate_.get(), well_state_);
+        std::vector<double> pot(numPhases(), 0.0);
+        wellGroupHelpers::updateGuideRateForGroups(fieldGroup, schedule(), phase_usage_, reportStepIdx, simulationTime, /*isInjector*/ false, well_state_, guideRate_.get(), pot);
+        std::vector<double> potInj(numPhases(), 0.0);
+        wellGroupHelpers::updateGuideRateForGroups(fieldGroup, schedule(), phase_usage_, reportStepIdx, simulationTime, /*isInjector*/ true, well_state_, guideRate_.get(), potInj);
 
         // compute wsolvent fraction for REIN wells
         updateWsolvent(fieldGroup, schedule(), reportStepIdx,  well_state_);
@@ -1204,6 +1207,12 @@ namespace Opm {
             std::vector<double> groupTargetReductionInj(numPhases(), 0.0);
             wellGroupHelpers::updateGroupTargetReduction(fieldGroup, schedule(), reportStepIdx, /*isInjector*/ true, well_state_, groupTargetReductionInj);
         }
+
+        const double simulationTime = ebosSimulator_.time();
+        std::vector<double> pot(numPhases(), 0.0);
+        wellGroupHelpers::updateGuideRateForGroups(fieldGroup, schedule(), phase_usage_, reportStepIdx, simulationTime, /*isInjector*/ false, well_state_, guideRate_.get(), pot);
+        std::vector<double> potInj(numPhases(), 0.0);
+        wellGroupHelpers::updateGuideRateForGroups(fieldGroup, schedule(), phase_usage_, reportStepIdx, simulationTime, /*isInjector*/ true, well_state_, guideRate_.get(), potInj);
     }
 
 

opm/simulators/wells/MultisegmentWell_impl.hpp

@@ -2149,7 +2149,6 @@ namespace Opm
 
         int phasePos;
         Well::GuideRateTarget wellTarget;
-        Group::GuideRateTarget groupTarget;
         double scaling = 1.0;
 
         switch (injectorType) {
@@ -2157,7 +2156,6 @@ namespace Opm
         {
             phasePos = pu.phase_pos[BlackoilPhases::Aqua];
             wellTarget = Well::GuideRateTarget::WAT;
-            groupTarget = Group::GuideRateTarget::WAT;
             scaling = scalingFactor(pu.phase_pos[BlackoilPhases::Aqua]);
             break;
         }
@@ -2165,7 +2163,6 @@ namespace Opm
         {
             phasePos = pu.phase_pos[BlackoilPhases::Liquid];
             wellTarget = Well::GuideRateTarget::OIL;
-            groupTarget = Group::GuideRateTarget::OIL;
             scaling = scalingFactor(pu.phase_pos[BlackoilPhases::Liquid]);
             break;
         }
@@ -2173,7 +2170,6 @@ namespace Opm
         {
             phasePos = pu.phase_pos[BlackoilPhases::Vapour];
             wellTarget = Well::GuideRateTarget::GAS;
-            groupTarget = Group::GuideRateTarget::GAS;
             scaling = scalingFactor(pu.phase_pos[BlackoilPhases::Vapour]);
             break;
         }
@@ -2184,7 +2180,7 @@ namespace Opm
         const std::vector<double>& groupInjectionReductions = well_state.currentInjectionGroupReductionRates(group.name());
         double groupTargetReduction = groupInjectionReductions[phasePos];
         double fraction = wellGroupHelpers::wellFractionFromGuideRates(well, schedule, well_state, current_step_, Base::guide_rate_, wellTarget, /*isInjector*/true);
-        wellGroupHelpers::accumulateGroupFractions(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, groupTarget, /*isInjector*/true, fraction);
+        wellGroupHelpers::accumulateGroupInjectionPotentialFractions(well.groupName(), group.name(), schedule, well_state, current_step_, phasePos, fraction);
 
         switch(currentGroupControl) {
         case Group::InjectionCMode::NONE:
@@ -2322,7 +2318,7 @@ namespace Opm
         {
             double groupTargetReduction = groupTargetReductions[pu.phase_pos[Oil]];
             double fraction = wellGroupHelpers::wellFractionFromGuideRates(well, schedule, well_state, current_step_, Base::guide_rate_, Well::GuideRateTarget::OIL, /*isInjector*/false);
-            wellGroupHelpers::accumulateGroupFractions(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::OIL, /*isInjector*/false, fraction);
+            wellGroupHelpers::accumulateGroupFractionsFromGuideRates(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::OIL, fraction);
 
             const double rate_target = std::max(0.0, groupcontrols.oil_target / efficiencyFactor - groupTargetReduction);
             assert(FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx));
@@ -2334,7 +2330,7 @@ namespace Opm
         {
             double groupTargetReduction = groupTargetReductions[pu.phase_pos[Water]];
             double fraction = wellGroupHelpers::wellFractionFromGuideRates(well, schedule, well_state, current_step_, Base::guide_rate_, Well::GuideRateTarget::WAT, /*isInjector*/false);
-            wellGroupHelpers::accumulateGroupFractions(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::WAT, /*isInjector*/false, fraction);
+            wellGroupHelpers::accumulateGroupFractionsFromGuideRates(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::WAT, fraction);
 
             const double rate_target = std::max(0.0, groupcontrols.water_target / efficiencyFactor - groupTargetReduction);
             assert(FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx));
@@ -2346,7 +2342,7 @@ namespace Opm
         {
             double groupTargetReduction = groupTargetReductions[pu.phase_pos[Gas]];
             double fraction = wellGroupHelpers::wellFractionFromGuideRates(well, schedule, well_state, current_step_, Base::guide_rate_, Well::GuideRateTarget::GAS, /*isInjector*/false);
-            wellGroupHelpers::accumulateGroupFractions(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::GAS, /*isInjector*/false, fraction);
+            wellGroupHelpers::accumulateGroupFractionsFromGuideRates(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::GAS, fraction);
             const double rate_target = std::max(0.0, groupcontrols.gas_target / efficiencyFactor - groupTargetReduction);
             assert(FluidSystem::phaseIsActive(FluidSystem::gasCompIdx));
             const EvalWell& rate = -getSegmentRate(0, Indices::canonicalToActiveComponentIndex(FluidSystem::gasCompIdx));
@@ -2357,7 +2353,7 @@ namespace Opm
         {
             double groupTargetReduction = groupTargetReductions[pu.phase_pos[Oil]] + groupTargetReductions[pu.phase_pos[Water]];
             double fraction = wellGroupHelpers::wellFractionFromGuideRates(well, schedule, well_state, current_step_, Base::guide_rate_, Well::GuideRateTarget::LIQ, /*isInjector*/false);
-            wellGroupHelpers::accumulateGroupFractions(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::LIQ, /*isInjector*/false, fraction);
+            wellGroupHelpers::accumulateGroupFractionsFromGuideRates(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::LIQ, fraction);
 
             const double rate_target = std::max(0.0, groupcontrols.liquid_target / efficiencyFactor - groupTargetReduction);
             assert(FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx));

opm/simulators/wells/StandardWell_impl.hpp

@@ -994,28 +994,24 @@ namespace Opm
 
         int phasePos;
         Well::GuideRateTarget wellTarget;
-        Group::GuideRateTarget groupTarget;
 
         switch (injectorType) {
         case Well::InjectorType::WATER:
         {
             phasePos = pu.phase_pos[BlackoilPhases::Aqua];
             wellTarget = Well::GuideRateTarget::WAT;
-            groupTarget = Group::GuideRateTarget::WAT;
             break;
         }
         case Well::InjectorType::OIL:
         {
             phasePos = pu.phase_pos[BlackoilPhases::Liquid];
             wellTarget = Well::GuideRateTarget::OIL;
-            groupTarget = Group::GuideRateTarget::OIL;
             break;
         }
         case Well::InjectorType::GAS:
         {
             phasePos = pu.phase_pos[BlackoilPhases::Vapour];
             wellTarget = Well::GuideRateTarget::GAS;
-            groupTarget = Group::GuideRateTarget::GAS;
             break;
         }
         default:
@@ -1025,8 +1021,7 @@ namespace Opm
         const std::vector<double>& groupInjectionReductions = well_state.currentInjectionGroupReductionRates(group.name());
         double groupTargetReduction = groupInjectionReductions[phasePos];
         double fraction = wellGroupHelpers::wellFractionFromGuideRates(well, schedule, well_state, current_step_, Base::guide_rate_, wellTarget, /*isInjector*/true);
-        wellGroupHelpers::accumulateGroupFractions(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, groupTarget, /*isInjector*/true, fraction);
+        wellGroupHelpers::accumulateGroupInjectionPotentialFractions(well.groupName(), group.name(), schedule, well_state, current_step_, phasePos, fraction);
-
         switch(currentGroupControl) {
         case Group::InjectionCMode::NONE:
         {
@@ -1162,7 +1157,7 @@ namespace Opm
         {
             double groupTargetReduction = groupTargetReductions[pu.phase_pos[Oil]];
             double fraction = wellGroupHelpers::wellFractionFromGuideRates(well, schedule, well_state, current_step_, Base::guide_rate_, Well::GuideRateTarget::OIL, /*isInjector*/false);
-            wellGroupHelpers::accumulateGroupFractions(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::OIL, /*isInjector*/false, fraction);
+            wellGroupHelpers::accumulateGroupFractionsFromGuideRates(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::OIL, fraction);
 
             const double rate_target = std::max(0.0, groupcontrols.oil_target / efficiencyFactor - groupTargetReduction);
             assert(FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx));
@@ -1174,7 +1169,7 @@ namespace Opm
         {
             double groupTargetReduction = groupTargetReductions[pu.phase_pos[Water]];
             double fraction = wellGroupHelpers::wellFractionFromGuideRates(well, schedule, well_state, current_step_, Base::guide_rate_, Well::GuideRateTarget::WAT, /*isInjector*/false);
-            wellGroupHelpers::accumulateGroupFractions(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::WAT, /*isInjector*/false, fraction);
+            wellGroupHelpers::accumulateGroupFractionsFromGuideRates(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::WAT, fraction);
 
             const double rate_target = std::max(0.0, groupcontrols.water_target / efficiencyFactor - groupTargetReduction);
             assert(FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx));
@@ -1186,7 +1181,7 @@ namespace Opm
         {
             double groupTargetReduction = groupTargetReductions[pu.phase_pos[Gas]];
             double fraction = wellGroupHelpers::wellFractionFromGuideRates(well, schedule, well_state, current_step_, Base::guide_rate_, Well::GuideRateTarget::GAS, /*isInjector*/false);
-            wellGroupHelpers::accumulateGroupFractions(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::GAS, /*isInjector*/false, fraction);
+            wellGroupHelpers::accumulateGroupFractionsFromGuideRates(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::GAS, fraction);
 
             const double rate_target = std::max(0.0, groupcontrols.gas_target / efficiencyFactor - groupTargetReduction);
             assert(FluidSystem::phaseIsActive(FluidSystem::gasCompIdx));
@@ -1198,7 +1193,7 @@ namespace Opm
         {
             double groupTargetReduction = groupTargetReductions[pu.phase_pos[Oil]] + groupTargetReductions[pu.phase_pos[Water]];
             double fraction = wellGroupHelpers::wellFractionFromGuideRates(well, schedule, well_state, current_step_, Base::guide_rate_, Well::GuideRateTarget::LIQ, /*isInjector*/false);
-            wellGroupHelpers::accumulateGroupFractions(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::LIQ, /*isInjector*/false, fraction);
+            wellGroupHelpers::accumulateGroupFractionsFromGuideRates(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::LIQ, fraction);
 
             const double rate_target = std::max(0.0, groupcontrols.liquid_target / efficiencyFactor - groupTargetReduction);
             assert(FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx));
@@ -1220,7 +1215,7 @@ namespace Opm
                     + groupTargetReductions[pu.phase_pos[Water]];
 
             double fraction = wellGroupHelpers::wellFractionFromGuideRates(well, schedule, well_state, current_step_, Base::guide_rate_, Well::GuideRateTarget::RES, /*isInjector*/false);
-            wellGroupHelpers::accumulateGroupFractions(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::RES, /*isInjector*/false, fraction);
+            wellGroupHelpers::accumulateGroupFractionsFromGuideRates(well.groupName(), group.name(), schedule, well_state, current_step_, Base::guide_rate_, Group::GuideRateTarget::RES, fraction);
 
             EvalWell total_rate(numWellEq_ + numEq, 0.); // reservoir rate
             std::vector<double> convert_coeff(number_of_phases_, 1.0);

opm/simulators/wells/WellGroupHelpers.hpp

@@ -296,33 +296,82 @@ namespace Opm {
     }
 
 
-
+    inline void updateGuideRateForGroups(const Group& group, const Schedule& schedule, const PhaseUsage& pu, const int reportStepIdx, const double& simTime, const bool isInjector, WellStateFullyImplicitBlackoil& wellState, GuideRate* guideRate, std::vector<double>& pot)
-    inline void updateGuideRateForGroups(const Group& group, const Schedule& schedule, const PhaseUsage& pu, const int reportStepIdx, const double& simTime, GuideRate* guideRate, WellStateFullyImplicitBlackoil& wellState) {
+    {
+        const int np = pu.num_phases;
         for (const std::string& groupName : group.groups()) {
+            std::vector<double> thisPot(np, 0.0);
             const Group& groupTmp = schedule.getGroup(groupName, reportStepIdx);
-            updateGuideRateForGroups(groupTmp, schedule, pu, reportStepIdx, simTime, guideRate, wellState);
+            updateGuideRateForGroups(groupTmp, schedule, pu, reportStepIdx, simTime, isInjector, wellState, guideRate, thisPot);
-        }
-        bool isInjector = group.isInjectionGroup();
-        bool isProducer = group.isProductionGroup();
 
-        if (!isInjector && !isProducer)
+            // accumulate group contribution from sub group if FLD
-            return;
+            if (isInjector) {
+                const Group::InjectionCMode& currentGroupControl = wellState.currentInjectionGroupControl(groupName);
+                if (currentGroupControl != Group::InjectionCMode::FLD) {
+                    continue;
+                }
+            } else {
+                const Group::ProductionCMode& currentGroupControl = wellState.currentProductionGroupControl(groupName);
+                if (currentGroupControl != Group::ProductionCMode::FLD) {
+                    continue;
+                }
+            }
+            for (int phase = 0; phase < np; phase++) {
+                pot[phase] += thisPot[phase];
+            }
+        }
+        for (const std::string& wellName : group.wells()) {
+            const auto& wellTmp = schedule.getWell(wellName, reportStepIdx);
+
+            if (wellTmp.isProducer() && isInjector)
+                continue;
+
+            if (wellTmp.isInjector() && !isInjector)
+                continue;
+
+            if (wellTmp.getStatus() == Well::Status::SHUT)
+                continue;
+            const auto& end = wellState.wellMap().end();
+            const auto& it = wellState.wellMap().find( wellName );
+            if (it == end)  // the well is not found
+                continue;
+
+            int well_index = it->second[0];
+            const auto wellrate_index = well_index * wellState.numPhases();
+            // add contribution from wells not under group control
+            if (isInjector) {
+                if (wellState.currentInjectionControls()[well_index] == Well::InjectorCMode::GRUP)
+                    for (int phase = 0; phase < np; phase++) {
+                        pot[phase] += wellState.wellPotentials()[wellrate_index + phase];
+                    }
+            } else {
+                if (wellState.currentProductionControls()[well_index] ==  Well::ProducerCMode::GRUP)
+                    for (int phase = 0; phase < np; phase++) {
+                        pot[phase] -= wellState.wellPotentials()[wellrate_index + phase];
+                    }
+            }
+        }
 
         double oilPot = 0.0;
         if (pu.phase_used[BlackoilPhases::Liquid])
-            oilPot = sumWellPhaseRates(wellState.wellPotentials(), group, schedule, wellState, reportStepIdx, pu.phase_pos[BlackoilPhases::Liquid], isInjector);
 
+            oilPot = pot [ pu.phase_pos[BlackoilPhases::Liquid]];
         double gasPot = 0.0;
         if (pu.phase_used[BlackoilPhases::Vapour])
-            gasPot = sumWellPhaseRates(wellState.wellPotentials(), group, schedule, wellState, reportStepIdx, pu.phase_pos[BlackoilPhases::Vapour], isInjector);
+            gasPot = pot [ pu.phase_pos[BlackoilPhases::Vapour]];
 
         double waterPot = 0.0;
         if (pu.phase_used[BlackoilPhases::Aqua])
-            waterPot = sumWellPhaseRates(wellState.wellPotentials(), group, schedule, wellState, reportStepIdx, pu.phase_pos[BlackoilPhases::Aqua], isInjector);
+            waterPot = pot [pu.phase_pos[BlackoilPhases::Aqua]];
 
-        guideRate->compute(group.name(), reportStepIdx, simTime, oilPot, gasPot, waterPot);
+        if (isInjector) {
+            wellState.setCurrentGroupInjectionPotentials(group.name(), pot);
+        } else {
+            guideRate->compute(group.name(), reportStepIdx, simTime, oilPot, gasPot, waterPot);
+        }
     }
 
+
     inline void updateVREPForGroups(const Group& group, const Schedule& schedule, const int reportStepIdx, WellStateFullyImplicitBlackoil& wellState, double& resv) {
         for (const std::string& groupName : group.groups()) {
             const Group& groupTmp = schedule.getGroup(groupName, reportStepIdx);
@@ -405,28 +454,16 @@ namespace Opm {
         return wellGuideRate / groupTotalGuideRate;
     }
 
-    inline double groupFractionFromGuideRates(const Group& group, const Schedule& schedule, const WellStateFullyImplicitBlackoil& wellState, const int reportStepIdx, const GuideRate* guideRate, const Group::GuideRateTarget& groupTarget, const bool isInjector) {
+    inline double groupFractionFromGuideRates(const Group& group, const Schedule& schedule, const WellStateFullyImplicitBlackoil& wellState, const int reportStepIdx, const GuideRate* guideRate, const Group::GuideRateTarget& groupTarget) {
         double groupTotalGuideRate = 0.0;
         const Group& groupParent = schedule.getGroup(group.parent(), reportStepIdx);
         for (const std::string& groupName : groupParent.groups()) {
-            const Group& groupTmp = schedule.getGroup(groupName, reportStepIdx);
-
             // only count group under group control from its parent
-            if (isInjector) {
+            const Group::ProductionCMode& currentGroupControl = wellState.currentProductionGroupControl(groupName);
-                const Group::InjectionCMode& currentGroupControl = wellState.currentInjectionGroupControl(groupName);
+            if (currentGroupControl != Group::ProductionCMode::FLD)
-                if (currentGroupControl != Group::InjectionCMode::FLD)
+                continue;
-                    continue;
-            } else {
-                const Group::ProductionCMode& currentGroupControl = wellState.currentProductionGroupControl(groupName);
-                if (currentGroupControl != Group::ProductionCMode::FLD)
-                    continue;
-            }
 
-            if ( (groupTmp.isProductionGroup() && !isInjector) ||
+            groupTotalGuideRate += guideRate->get(groupName, groupTarget);
-                 (groupTmp.isInjectionGroup() && isInjector) )
-            {
-                groupTotalGuideRate += guideRate->get(groupName, groupTarget);
-            }
         }
         if (groupTotalGuideRate == 0.0)
             return 1.0;
@@ -435,14 +472,39 @@ namespace Opm {
         return groupGuideRate / groupTotalGuideRate;
     }
 
-    inline void accumulateGroupFractions(const std::string& groupName, const std::string& controlGroupName, const Schedule& schedule, const WellStateFullyImplicitBlackoil& wellState,const int reportStepIdx, const GuideRate* guideRate, const Group::GuideRateTarget& groupTarget, const bool isInjector, double& fraction) {
+    inline void accumulateGroupFractionsFromGuideRates(const std::string& groupName, const std::string& controlGroupName, const Schedule& schedule, const WellStateFullyImplicitBlackoil& wellState,const int reportStepIdx, const GuideRate* guideRate, const Group::GuideRateTarget& groupTarget, double& fraction) {
-
         const Group& group = schedule.getGroup(groupName, reportStepIdx);
         if (groupName != controlGroupName) {
-            fraction *= groupFractionFromGuideRates(group, schedule, wellState, reportStepIdx, guideRate, groupTarget, isInjector);
+            fraction *= groupFractionFromGuideRates(group, schedule, wellState, reportStepIdx, guideRate, groupTarget);
-            accumulateGroupFractions(group.parent(), controlGroupName, schedule, wellState, reportStepIdx, guideRate, groupTarget, isInjector, fraction);
+            accumulateGroupFractionsFromGuideRates(group.parent(), controlGroupName, schedule, wellState, reportStepIdx, guideRate, groupTarget, fraction);
         }
+        return;
+    }
 
+    inline double groupFractionFromInjectionPotentials(const Group& group, const Schedule& schedule, const WellStateFullyImplicitBlackoil& wellState, const int reportStepIdx, const int phasePos) {
+        double groupTotalGuideRate = 0.0;
+        const Group& groupParent = schedule.getGroup(group.parent(), reportStepIdx);
+        for (const std::string& groupName : groupParent.groups()) {
+            // only count group under group control from its parent
+            const Group::InjectionCMode& currentGroupControl = wellState.currentInjectionGroupControl(groupName);
+            if (currentGroupControl != Group::InjectionCMode::FLD)
+                continue;
+
+            groupTotalGuideRate += wellState.currentGroupInjectionPotentials(groupName)[phasePos];
+        }
+        if (groupTotalGuideRate == 0.0)
+            return 1.0;
+
+        double groupGuideRate = wellState.currentGroupInjectionPotentials(group.name())[phasePos];
+        return groupGuideRate / groupTotalGuideRate;
+    }
+
+    inline void accumulateGroupInjectionPotentialFractions(const std::string& groupName, const std::string& controlGroupName, const Schedule& schedule, const WellStateFullyImplicitBlackoil& wellState,const int reportStepIdx, const int phasePos, double& fraction) {
+        const Group& group = schedule.getGroup(groupName, reportStepIdx);
+        if (groupName != controlGroupName) {
+            fraction *= groupFractionFromInjectionPotentials(group, schedule, wellState, reportStepIdx, phasePos);
+            accumulateGroupInjectionPotentialFractions(group.parent(), controlGroupName, schedule, wellState, reportStepIdx, phasePos, fraction);
+        }
         return;
     }
 

opm/simulators/wells/WellStateFullyImplicitBlackoil.hpp

@@ -392,6 +392,19 @@ namespace Opm
             return it->second;
         }
 
+        void setCurrentGroupInjectionPotentials(const std::string& groupName, const std::vector<double>& pot ) {
+            injection_group_potentials[groupName] = pot;
+        }
+        const std::vector<double>& currentGroupInjectionPotentials(const std::string& groupName) const {
+            auto it = injection_group_potentials.find(groupName);
+
+            if (it == injection_group_potentials.end())
+                OPM_THROW(std::logic_error, "Could not find any potentials for group " << groupName);
+
+            return it->second;
+        }
+
+
 
         data::Wells report(const PhaseUsage &pu, const int* globalCellIdxMap) const override
         {
@@ -826,6 +839,7 @@ namespace Opm
 
         std::map<std::string, std::vector<double>> production_group_reduction_rates;
         std::map<std::string, std::vector<double>> injection_group_reduction_rates;
+        std::map<std::string, std::vector<double>> injection_group_potentials;
         std::map<std::string, double> injection_group_vrep_rates;
         std::map<std::string, std::vector<double>> injection_group_rein_rates;