Refactor TargetCalculator

Refactor TargetCalculator::groupTarget() to
WellGroupHelper::getProductionGroupTarget(), and
don't pass Group::ProductionControls as a parameter. Since
TargetCalculator only works for a given group, passing control as a
parameter is confusing and can be error prone if being passed a control
for a different group than the TargetCalculator was constructed for.

Author: hakonhagland

opm/simulators/wells/BlackoilWellModelNldd_impl.hpp

@@ -118,6 +118,7 @@ recoverWellSolutionAndUpdateWellState(const BVector& x,
             }
             well->recoverWellSolutionAndUpdateWellState(wellModel_.simulator(),
                                                         x_local_,
+                                                        wellModel_.groupStateHelper(),
                                                         wellModel_.wellState(),
                                                         local_deferredLogger);
         }
@@ -143,8 +144,7 @@ getWellConvergence(const Domain& domain,
     for (const auto& well : wellModel_.localNonshutWells()) {
         if ((this->well_domain().at(well->name()) == domain.index)) {
             if (well->isOperableAndSolvable() || well->wellIsStopped()) {
-                report += well->getWellConvergence(wellModel_.simulator(),
-                                                   wellModel_.wellState(),
+                report += well->getWellConvergence(wellModel_.groupStateHelper(),
                                                    B_avg,
                                                    local_deferredLogger,
                                                    relax_tolerance);

opm/simulators/wells/BlackoilWellModel_impl.hpp

@@ -513,9 +513,9 @@ namespace Opm {
                 if (event || dyn_status_change) {
                     try {
                         well->scaleSegmentRatesAndPressure(this->wellState());
-                        well->calculateExplicitQuantities(simulator_, this->wellState(), local_deferredLogger);
+                        well->calculateExplicitQuantities(simulator_, this->groupStateHelper(), local_deferredLogger);
                         well->updateWellStateWithTarget(simulator_, this->groupStateHelper(), this->wellState(), local_deferredLogger);
-                        well->updatePrimaryVariables(simulator_, this->wellState(), local_deferredLogger);
+                        well->updatePrimaryVariables(this->groupStateHelper(), local_deferredLogger);
                         well->solveWellEquation(
                             simulator_, this->groupStateHelper(), this->wellState(), local_deferredLogger
                         );
@@ -1168,7 +1168,7 @@ namespace Opm {
 
         OPM_BEGIN_PARALLEL_TRY_CATCH();
         for (auto& well : this->well_container_) {
-            well->solveEqAndUpdateWellState(simulator_, well_state, deferred_logger);
+            well->solveEqAndUpdateWellState(simulator_, this->groupStateHelper(), well_state, deferred_logger);
         }
         OPM_END_PARALLEL_TRY_CATCH("BlackoilWellModel::doPreStepNetworkRebalance() failed: ",
                                     this->simulator_.vanguard().grid().comm());
@@ -1402,9 +1402,6 @@ namespace Opm {
 
                 //TODO: Auto choke combined with RESV control is not supported
                 std::vector<Scalar> resv_coeff(Indices::numPhases, 1.0);
-                Scalar gratTargetFromSales = 0.0;
-                if (group_state.has_grat_sales_target(group.name()))
-                    gratTargetFromSales = group_state.grat_sales_target(group.name());
 
                 const auto ctrl = group.productionControls(summary_state);
                 auto cmode_tmp = ctrl.cmode;
@@ -1417,7 +1414,7 @@ namespace Opm {
                     const Scalar efficiencyFactor = 1.0;
                     const Group& parentGroup = this->schedule().getGroup(group.parent(), reportStepIdx);
                     auto target = WellGroupControls<Scalar, IndexTraits>::getAutoChokeGroupProductionTargetRate(
-                                                            group.name(),
+                                                            group,
                                                             parentGroup,
                                                             this->groupStateHelper(),
                                                             this->schedule(),
@@ -1430,16 +1427,12 @@ namespace Opm {
                     target_tmp = target.first;
                     cmode_tmp = target.second;
                 }
-                const auto cmode = cmode_tmp;
-                using TargetCalculatorType =  GroupStateHelpers
-::TargetCalculator<Scalar, IndexTraits>;
-                TargetCalculatorType tcalc(cmode, FluidSystem::phaseUsage(), resv_coeff,
-                                           gratTargetFromSales, nodeName, group_state,
-                                           group.has_gpmaint_control(cmode));
+                using TargetCalculatorType =  GroupStateHelpers::TargetCalculator<Scalar, IndexTraits>;
+                TargetCalculatorType tcalc{this->groupStateHelper(), resv_coeff, group};
                 if (!fld_none)
                 {
                     // Target is set for the autochoke group itself
-                    target_tmp = tcalc.groupTarget(ctrl, local_deferredLogger);
+                    target_tmp = tcalc.groupTarget(local_deferredLogger);
                 }
 
                 const Scalar orig_target = target_tmp;
@@ -1777,7 +1770,7 @@ ::TargetCalculator<Scalar, IndexTraits>;
                     x_local_[i] = x[cells[i]];
                 }
                 well->recoverWellSolutionAndUpdateWellState(simulator_, x_local_,
-                                                            this->wellState(), local_deferredLogger);
+                                                            this->groupStateHelper(), this->wellState(), local_deferredLogger);
             }
         }
         OPM_END_PARALLEL_TRY_CATCH_LOG(local_deferredLogger,
@@ -1812,7 +1805,7 @@ ::TargetCalculator<Scalar, IndexTraits>;
         for (const auto& well : well_container_) {
             if (well->isOperableAndSolvable() || well->wellIsStopped()) {
                 local_report += well->getWellConvergence(
-                        simulator_, this->wellState(), B_avg, local_deferredLogger,
+                        this->groupStateHelper(), B_avg, local_deferredLogger,
                         iterationIdx > param_.strict_outer_iter_wells_);
             } else {
                 ConvergenceReport report;
@@ -1858,7 +1851,7 @@ ::TargetCalculator<Scalar, IndexTraits>;
     {
         // TODO: checking isOperableAndSolvable() ?
         for (auto& well : well_container_) {
-            well->calculateExplicitQuantities(simulator_, this->wellState(), deferred_logger);
+            well->calculateExplicitQuantities(simulator_, this->groupStateHelper(), deferred_logger);
         }
     }
 
@@ -2101,9 +2094,7 @@ ::TargetCalculator<Scalar, IndexTraits>;
                                        this->groupStateHelper(),
                                        local_deferredLogger);
             const bool under_zero_target =
-                well->wellUnderZeroGroupRateTarget(this->simulator_,
-                                                   this->wellState(),
-                                                   local_deferredLogger);
+                well->wellUnderZeroGroupRateTarget(this->groupStateHelper(), local_deferredLogger);
             well->updateWellTestState(this->wellState().well(wname),
                                       simulationTime,
                                       /*writeMessageToOPMLog=*/ true,
@@ -2280,7 +2271,7 @@ ::TargetCalculator<Scalar, IndexTraits>;
                 well->updateWellStateWithTarget(
                     simulator_, this->groupStateHelper(), this->wellState(), deferred_logger
                 );
-                well->updatePrimaryVariables(simulator_, this->wellState(), deferred_logger);
+                well->updatePrimaryVariables(this->groupStateHelper(), deferred_logger);
                 // There is no new well control change input within a report step,
                 // so next time step, the well does not consider to have effective events anymore.
                 events.clearEvent(WellState<Scalar, IndexTraits>::event_mask);
@@ -2364,7 +2355,7 @@ ::TargetCalculator<Scalar, IndexTraits>;
     updatePrimaryVariables(DeferredLogger& deferred_logger)
     {
         for (const auto& well : well_container_) {
-            well->updatePrimaryVariables(simulator_, this->wellState(), deferred_logger);
+            well->updatePrimaryVariables(this->groupStateHelper(), deferred_logger);
         }
     }