BlackoilWellModelRescoup_impl.hpp

Go to the documentation of this file.

/*
  Copyright 2025 Equinor ASA
 
  This file is part of the Open Porous Media project (OPM).
 
  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef OPM_BLACKOILWELLMODEL_RESCOUP_IMPL_HEADER_INCLUDED
#define OPM_BLACKOILWELLMODEL_RESCOUP_IMPL_HEADER_INCLUDED
 
// Improve IDE experience
#ifndef OPM_BLACKOILWELLMODEL_RESCOUP_HEADER_INCLUDED
#include <config.h>
#include <opm/simulators/wells/BlackoilWellModelRescoup.hpp>
#endif
 
#ifdef RESERVOIR_COUPLING_ENABLED
 
#include <opm/common/TimingMacros.hpp>
 
#include <opm/input/eclipse/EclipseState/Grid/RegionSetMatcher.hpp>
#include <opm/input/eclipse/Schedule/ResCoup/ReservoirCouplingInfo.hpp>
#include <opm/input/eclipse/Schedule/Schedule.hpp>
#include <opm/input/eclipse/Schedule/SummaryState.hpp>
#include <opm/input/eclipse/Schedule/UDQ/UDQConfig.hpp>
#include <opm/input/eclipse/Schedule/UDQ/UDQDefine.hpp>
#include <opm/input/eclipse/Schedule/UDQ/UDQEnums.hpp>
#include <opm/input/eclipse/Schedule/Well/WellMatcher.hpp>
#include <opm/input/eclipse/Units/UnitSystem.hpp>
 
#include <opm/simulators/utils/DeferredLoggingErrorHelpers.hpp>
#include <opm/simulators/wells/BlackoilWellModel.hpp>
#include <opm/simulators/wells/BlackoilWellModelNetworkPressureComputation.hpp>
#include <opm/simulators/wells/rescoup/RescoupConstraintsCalculator.hpp>
#include <opm/simulators/wells/rescoup/RescoupReceiveGroupConstraints.hpp>
#include <opm/simulators/wells/rescoup/RescoupReceiveSlaveGroupData.hpp>
#include <opm/simulators/wells/rescoup/RescoupSendSlaveGroupData.hpp>
 
#include <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <memory>
#include <optional>
#include <string>
#include <tuple>
 
namespace Opm {
 
// Constructor
// -----------
template<typename TypeTag>
BlackoilWellModelRescoup<TypeTag>::
BlackoilWellModelRescoup(BlackoilWellModel<TypeTag>& well_model)
    : well_model_{well_model}
    , network_{well_model.network()}
    , simulator_{well_model.simulator()}
    , param_{well_model.param()}
{}
 
// Public methods alphabetically
// ------------------------------
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
evalGroupAndFieldUDQs()
{
    const int reportStepIdx = this->groupStateHelper().reportStepIdx();
    auto& deferred_logger = this->groupStateHelper().deferredLogger();
    // UDQs are normally evaluated at the end of a time step.  A slave UDQ
    // that depends on a target imposed by the master would then lag one
    // step behind, so re-evaluate the group and field level UDQs now that
    // this step's targets have arrived.  Well and segment level UDQs are
    // left alone: their inputs are not available yet.  So is any
    // "UPDATE NEXT" DEFINE: it is a one-shot that the ordinary end-of-step
    // evaluation is meant to consume, and this extra evaluation must not
    // use it up early.
    const auto select = [](const UDQDefine& def) {
        const auto var_type = def.var_type();
        return ((var_type == UDQVarType::GROUP_VAR) || (var_type == UDQVarType::FIELD_VAR))
            && (def.status().first != UDQUpdate::NEXT);
    };
    const auto& schedule = this->schedule();
    OPM_BEGIN_PARALLEL_TRY_CATCH();
    {
        schedule[reportStepIdx].udq().eval(
            reportStepIdx,
            schedule.wellMatcher(reportStepIdx),
            schedule[reportStepIdx].group_order(),
            schedule.segmentMatcherFactory(reportStepIdx),
            [es = std::cref(this->simulator_.vanguard().eclState())]() {
                return std::make_unique<RegionSetMatcher>(es.get().fipRegionStatistics());
            },
            this->simulator_.vanguard().summaryState(),
            this->simulator_.vanguard().udqState(),
            select);
    }
    OPM_END_PARALLEL_TRY_CATCH_LOG(deferred_logger,
                                   "Failed to evaluate UDQs for reservoir coupling slave: ",
                                   this->well_model_.terminalOutput(),
                                   this->simulator_.vanguard().grid().comm())
}
 
template<typename TypeTag>
bool
BlackoilWellModelRescoup<TypeTag>::
masterIsInCoupledNetworkIteration() const
{
    return this->isReservoirCouplingMaster()
        && this->reservoirCouplingMaster().isFirstSubstepOfSyncTimestep()
        && this->masterNetworkHasMasterGroupLeaves()
        && !this->lastSentMasterGroupNodePressuresIsFinal();
}
 
 
template<typename TypeTag>
bool
BlackoilWellModelRescoup<TypeTag>::
masterNetworkHasMasterGroupLeaves() const
{
    // Query the parsed Schedule topology (`network.has_node(...)`) rather than the runtime
    // `node_pressures_` map.  The runtime map is empty on the very first beginTimeStep call
    // (network_.update has not yet run for this substep).
    if (!this->isReservoirCouplingMaster()) return false;
    const auto& rcm = this->reservoirCouplingMaster();
    const auto num_slaves = rcm.numSlaves();
    for (std::size_t s = 0; s < num_slaves; ++s) {
        if (!rcm.slaveIsCoupled(s)) continue;
        if (this->masterNetworkHasMasterGroupLeavesForSlave_(s)) {
            return true;
        }
    }
    return false;
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
maybeExchangeNetworkOuterIterationWithSlaves(bool more_network_update)
{
    if (!this->masterIsInCoupledNetworkIteration()) {
        return;
    }
    const bool is_final = !more_network_update;
    // In tight coupling the inner sub-loop (maybeExchangeNetworkSubIterationWithSlaves)
    // performs every non-final exchange, so here we only emit the single
    // terminating (is_final) message -- the non-final case would just resend the
    // same node pressures the last sub-iteration already shipped, and get the same
    // rates back.  The retained final send still covers the case where the network
    // is not balanced this iteration (the inner loop never runs).  In loose coupling
    // this per-outer send is the sole master<->slave coupling and runs every outer
    // iteration.
    if (is_final || !this->well_model_.useTightRcNetworkCoupling()) {
        // send the pressures freshly computed by network_.update() to all activated slaves
        this->sendMasterGroupNodePressuresToSlaves(is_final);
        if (!is_final) {
            // receive slaves' updated network_surface_rates for the next outer iteration.
            this->receiveSlaveGroupData();
            this->refreshAndSendGroupConstraints();
        }
    }
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
maybeExchangeNetworkSubIterationWithSlaves()
{
    // Called for rescoup master for the tight master-slave coupling (--rc-network-loose-coupling=false)
    // mode at the sub-iteration level: Send node pressures and receive slave rates per master inner
    // network sub-iteration.
    // In the loose mode (--rc-network-loose-coupling=true) the exchange happens only once
    // per master outer iteration (see updateWellControlsAndNetworkIteration), so
    // the inner loop converges the node pressures against a frozen slave rate.
    // This loose mode is faster but has been observed in some cases to overshoot to a value that
    // incorrectly shuts the slave wells in.
    // To avoid this, the tight coupling is therefore the default coupling.
    //
    // NOTE: This is always a non-final exchange.  The inner sub-iteration loop cannot
    // know whether the master's outer network loop will iterate again (the inner
    // loop ending on max_sub_iter, or on a THP update, still leaves
    // more_inner_network_update true), so it must not declare termination here.
    // The single is_final = true send is owned by the per-outer send in
    // updateWellControlsAndNetworkIteration() (when the outer loop converges)
    // and by sendSlaveNetworkLoopTerminationSignal_() (when the outer loop hits
    // max_iter).
    if (!this->well_model_.useTightRcNetworkCoupling()) {
        return;
    }
    if (!this->masterIsInCoupledNetworkIteration()) {
        return;
    }
    this->sendMasterGroupNodePressuresToSlaves(/*is_final=*/false);
    this->receiveSlaveGroupData();
    this->refreshAndSendGroupConstraints();
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
receiveCoupledNetworkActiveStatus()
{
    OPM_TIMEFUNCTION();
    assert(this->isReservoirCouplingSlave());
    this->reservoirCouplingSlave().receiveCoupledNetworkActiveStatusFromMaster();
    if (!this->reservoirCouplingSlave().connectedToMasterCoupledNetwork()) {
        // No master pressures this sync step: the node pressures are the slave's own again.
        this->network_.setNodePressureOverrides({});
        for (auto& well : this->wellContainer()) {
            well->setLogAllControlSwitches(false);
        }
    }
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
receiveGroupConstraintsFromMaster()
{
    OPM_TIMEFUNCTION();
    RescoupReceiveGroupConstraints<Scalar, IndexTraits> constraint_receiver{
        this->well_model_.guideRateHandler(),
        this->groupStateHelper()
    };
    constraint_receiver.receiveGroupConstraintsFromMaster();
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
receiveMasterGroupNodePressuresFromMaster()
{
    OPM_TIMEFUNCTION();
    assert(this->isReservoirCouplingSlave());
    auto& rescoup_slave = this->reservoirCouplingSlave();
    const auto [num_pressures, is_final] =
        rescoup_slave.receiveNumMasterGroupNodePressuresFromMaster();
    if (num_pressures > 0) {
        rescoup_slave.receiveMasterGroupNodePressuresFromMaster(num_pressures);
    }
    // Apply pressures as dynamic THP limits on every producer whose group
    // has a master-supplied pressure *and* whose group the slave's own deck
    // placed in its own surface network as a fixed-pressure node.  Wells in
    // master groups that are not network leaves are not touched either (no
    // entry in the map).  Mirrors the standard local-network apply pattern in
    // BlackoilWellModelNetworkGeneric::updatePressures(): when the well is
    // currently THP-controlled, also write the new THP into the WellState
    // directly, because setDynamicThpLimit() alone leaves the active
    // control's THP value stale and the subsequent well-solve would
    // converge against the old THP.
    //
    // The node-pressure exchange is a boundary condition between two
    // networks: the master's network ends at the master groups, and the
    // pressure it computes there is the fixed pressure of the corresponding
    // slave group's node in the *slave's* network.  A slave that declares no
    // network has no such node, and its wells keep the THP limits from their
    // own WCONPROD records -- so the messages are still received (the
    // protocol is unchanged) but nothing is imposed.
    //
    // The pressure is also the fixed pressure of the node in the slave's own network (see
    // BlackoilWellModelNetworkGeneric::setNodePressureOverrides()), so that the pressures of
    // the nodes below it, which are the THP limits of the wells in groups below the node, are
    // the master's pressure plus the pressure drops in the slave's branches.  Without it the
    // slave's own network update, which follows in every iteration, sets the THP limits of
    // the wells from the node's own fixed pressure, and the well control update (before it)
    // and the well solve (after it) would see different limits.  The direct write below only
    // reaches wells in a group that is the node itself.
    const auto& pressures = rescoup_slave.masterGroupNodePressures();
    std::map<std::string, Scalar> overrides;
    for (const auto& [group_name, pressure] : pressures) {
        if (this->slaveGroupIsFixedPressureNodeInOwnNetwork_(group_name)) {
            overrides[group_name] = pressure;
        }
    }
    this->network_.setNodePressureOverrides(overrides);
    // A well whose THP limit comes from the master's pressure, in the node itself or in a node
    // below it, can sit on the boundary between its group target and that limit: on THP
    // control its rate exceeds the target, on GRUP the THP it needs is below the limit, and
    // it switches between the two in every exchange while the master's pressure follows the
    // rates.  Flow's limit on the number of well
    // switches ends this, but only counts switches after NUPCOL iterations, which the
    // exchanges (made before the Newton iterations) never reach.  Count the switches
    // during the exchange so that such a well is kept on THP control.
    for (auto& well : this->wellContainer()) {
        well->setLogAllControlSwitches(false);
    }
    if (pressures.empty()) return;
    const auto& summary_state = this->well_model_.summaryState();
    auto& well_state = this->wellState();
    for (auto& well : this->wellContainer()) {
        if (!well->isProducer() || !well->wellEcl().predictionMode()) continue;
        const auto& group_name = well->wellEcl().groupName();
        if (this->wellIsBelowOverriddenNode_(group_name, overrides)) {
            well->setLogAllControlSwitches(!is_final);
        }
        const auto it = pressures.find(group_name);
        if (it == pressures.end()) continue;
        if (!this->slaveGroupIsFixedPressureNodeInOwnNetwork_(group_name)) continue;
        well->setDynamicThpLimit(it->second);
        auto& ws = well_state[well->indexOfWell()];
        // The exchange is made in the first substep of a sync step only.  The well objects are
        // rebuilt at the start of every substep, and a limit that is not in the well state is
        // lost then (see BlackoilWellModelNetworkGeneric::initializeWell()), so the later
        // substeps would solve the wells against the limit of their own deck.
        ws.network_thp_limit = it->second;
        if (ws.production_cmode == Well::ProducerCMode::THP) {
            ws.thp = well->getTHPConstraint(summary_state);
        }
    }
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
receiveRefreshedGroupConstraintsFromMaster()
{
    // The counterpart of refreshAndSendGroupConstraints() on the master.  The
    // constraints received replace the ones in force, so the slave group
    // control modes, the targets and limits in force and the UDQs built on
    // them follow suit.
    this->receiveGroupConstraintsFromMaster();
    this->groupStateHelper().updateSlaveGroupCmodesFromMaster();
    this->refreshSlaveGroupTargets();
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
receiveSlaveGroupData()
{
    OPM_TIMEFUNCTION();
    assert(this->isReservoirCouplingMaster());
    RescoupReceiveSlaveGroupData<Scalar, IndexTraits> slave_group_data_receiver{
        this->groupStateHelper(),
    };
    slave_group_data_receiver.receiveSlaveGroupData();
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
refreshAndSendGroupConstraints()
{
    // Called right after a receiveSlaveGroupData() within a sync step: after
    // the slaves' initial well solve at the start of the step, and inside the
    // network iteration.  Fold the rates just received into the master's group
    // state and ship constraints recomputed from them to the slaves, replacing
    // the ones they are currently holding.  The constraints sent first in the
    // sync step are computed from the slave rates before the slaves solved
    // their wells, which lag behind in two ways:
    //  - a group whose producers are not under group control has its current
    //    rate subtracted from the parent's target (see
    //    RescoupConstraintsCalculator::excludeAndRedistributeProductionTargets_()),
    //    and for wells that open this step that rate is not known before the
    //    solve, so the siblings would share the full parent target;
    //  - a target derived from slave production (GCONINJE REIN, SALE or VREP)
    //    would be built from the previous sync step's production.
    const int report_step_idx = this->well_model_.simulator().episodeIndex();
    this->well_model_.updateAndCommunicateGroupData(
        report_step_idx, /*update_wellgrouptarget=*/false);
    this->sendMasterGroupConstraintsToSlaves();
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
refreshSlaveGroupTargets()
{
    // The deck's own GCONINJE and GCONPROD limits may be UDAs, resolved from
    // the summary state, and the UDQ evaluation below may change them.  So
    // prime, evaluate the selected UDQs, and work the targets in force out
    // once more with the UDQs current, as the well control path will see
    // them.  The second pass repeats the loops over the slave groups, not
    // the UDQ evaluation.
    this->storeSlaveGroupInjectionTargets();
    this->storeSlaveGroupProductionTargets();
    this->evalGroupAndFieldUDQs();
    this->storeSlaveGroupInjectionTargets();
    this->storeSlaveGroupProductionTargets();
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
rescoupSyncSummaryData()
{
    // Reservoir coupling: exchange production data between slaves and master.
    //
    // Master side: after its first substep, the master blocks here until all
    // slaves have completed the sync step and sent their production data.
    // This ensures evalSummaryState() (called next in endTimeStep) and all
    // subsequent master substeps have correct slave production rates.
    //
    // Slave side: on the last substep of the sync step, the slave sends its
    // production data to the master.  The master is already waiting at this
    // point (blocked on MPI_Recv from its first substep's timeStepSucceeded).
    // The group rates are first recomputed from the converged well rates: the
    // group state holds the rates of the NUPCOL well state, which is frozen
    // after the first NUPCOL Newton iterations of the step.  The step has
    // converged, so there is nothing for NUPCOL to stabilise any more, and the
    // master uses these rates for its summary output and for its own substeps
    // until the next sync step.  (The data sent at the start of a sync step is
    // computed in the first Newton iteration, where the NUPCOL well state is the
    // current one.)
    if (this->isReservoirCouplingMaster()) {
        if (this->reservoirCouplingMaster().needsSlaveDataReceive()) {
            // The rates held before the receive are the slaves' start-of-step rates, which
            // GRUPMAST item 4 compares with the end-of-step rates. They come from the last
            // receive of the sync step, so they are the converged start state: after the
            // slaves' initial well solve and any network iterations. The first receive is
            // too early, wells that open at the start of the step still have zero rate then.
            this->reservoirCouplingMaster().saveGroupFlowsAtStartOfSyncStep();
            this->receiveSlaveGroupData();
            this->reservoirCouplingMaster().updateFlowChangeTimeStepLimit();
            this->reservoirCouplingMaster().setNeedsSlaveDataReceive(false);
        }
    }
    if (this->isReservoirCouplingSlave()) {
        if (this->reservoirCouplingSlave().isLastSubstepOfSyncTimestep()) {
            this->well_model_.updateGroupRatesFromWellState(
                this->well_model_.simulator().episodeIndex());
            this->sendSlaveGroupDataToMaster();
        }
    }
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
sendCoupledNetworkActiveStatus()
{
    OPM_TIMEFUNCTION();
    assert(this->isReservoirCouplingMaster());
    // Send to each activated slave a single bool: "are you connected to the
    // master's cross-rescoup network this sync timestep?", i.e. does this
    // slave have a master group that is a leaf in the master network.  This
    // is per-slave: a slave with no leaf in the master network does not
    // participate even if other slaves do.  Sent as a dedicated one-element
    // MPI message; the per-iteration node-pressure sends inside
    // updateWellControlsAndNetworkIteration() carry their own is_final flag
    // in the NumMasterGroupNodePressures header.
    auto& rescoup_master = this->reservoirCouplingMaster();
    const auto num_slaves = rescoup_master.numSlaves();
    bool any_connected = false;
    for (std::size_t slave_idx = 0; slave_idx < num_slaves; ++slave_idx) {
        if (rescoup_master.slaveIsCoupled(slave_idx)) {
            const bool connected =
                this->masterNetworkHasMasterGroupLeavesForSlave_(slave_idx);
            any_connected = any_connected || connected;
            rescoup_master.sendCoupledNetworkActiveStatusToSlave(slave_idx, connected);
        }
    }
    // Mirror the *global* active state into the master's own is_final flag:
    // the master iterates the exchange iff at least one slave is connected.
    // (This must stay global -- a per-slave value would break the master's
    // own updateWellControlsAndNetworkIteration() gate.)
    this->last_sent_master_group_node_pressures_is_final_ = !any_connected;
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
sendMasterGroupConstraintsToSlaves()
{
    OPM_TIMEFUNCTION();
    // This function is called by the master process to send the group
    // constraints to the slaves.  The "will the master iterate cross-rescoup?"
    // flag is shipped separately by sendCoupledNetworkActiveStatus().
    RescoupConstraintsCalculator<Scalar, IndexTraits> constraints_calculator{
        this->well_model_.guideRateHandler(),
        this->groupStateHelper()
    };
    constraints_calculator.calculateMasterGroupConstraintsAndSendToSlaves();
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
sendMasterGroupNodePressuresToSlaves(bool is_final)
{
    OPM_TIMEFUNCTION();
    assert(this->isReservoirCouplingMaster());
    auto& rescoup_master = this->reservoirCouplingMaster();
    const auto& node_pressures = this->network_.nodePressures();
    const auto num_slaves = rescoup_master.numSlaves();
    for (std::size_t slave_idx = 0; slave_idx < num_slaves; ++slave_idx) {
        if (!rescoup_master.slaveIsCoupled(slave_idx)) continue;
        std::vector<typename ReservoirCoupling::MasterGroupNodePressure<Scalar>> pressures;
        const auto& master_groups = rescoup_master.getMasterGroupNamesForSlave(slave_idx);
        for (std::size_t i = 0; i < master_groups.size(); ++i) {
            const auto it = node_pressures.find(master_groups[i]);
            if (it != node_pressures.end()) {
                pressures.push_back({i, it->second});
            }
        }
        rescoup_master.sendNumMasterGroupNodePressuresToSlave(
            slave_idx, pressures.size(), is_final);
        if (!pressures.empty()) {
            rescoup_master.sendMasterGroupNodePressuresToSlave(slave_idx, pressures);
        }
    }
    this->last_sent_master_group_node_pressures_is_final_ = is_final;
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
sendSlaveGroupDataToMaster()
{
    OPM_TIMEFUNCTION();
    assert(this->isReservoirCouplingSlave());
    RescoupSendSlaveGroupData<Scalar, IndexTraits> slave_group_data_sender{
        this->groupStateHelper(), this->well_model_.nupcolWellState()};
    slave_group_data_sender.sendSlaveGroupDataToMaster();
}
 
// Automatically manages the lifecycle of the DeferredLogger pointer
// in the reservoir coupling logger.  Ensures the logger is properly
// cleared when it goes out of scope, preventing dangling pointer issues:
//
// - The ScopedLoggerGuard constructor sets the logger pointer
// - When the guard goes out of scope, the destructor clears the pointer
// - Move semantics transfer ownership safely when returning from this function
//   - The moved-from guard is "nullified" and its destructor does nothing
//   - Only the final guard in the caller will clear the logger
template<typename TypeTag>
std::optional<ReservoirCoupling::ScopedLoggerGuard>
BlackoilWellModelRescoup<TypeTag>::
setupScopedLogger(DeferredLogger& local_logger)
{
    if (this->isReservoirCouplingMaster()) {
        return ReservoirCoupling::ScopedLoggerGuard{
            this->reservoirCouplingMaster().logger(),
            &local_logger
        };
    } else if (this->isReservoirCouplingSlave()) {
        return ReservoirCoupling::ScopedLoggerGuard{
            this->reservoirCouplingSlave().logger(),
            &local_logger
        };
    }
    return std::nullopt;
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
storeSlaveGroupInjectionTargets()
{
    const int reportStepIdx = this->groupStateHelper().reportStepIdx();
    // The injection target that applies to a slave group is not something
    // the slave's schedule can know on its own: it depends on the target
    // the master imposes at every synchronization step and on the group's
    // GRUPSLAV filter flag, which says whether the master's limit, the
    // deck's own GCONINJE limit, or the smaller of the two is in force.
    // Work out that effective target and keep it on the slave, where the
    // summary writer picks it up and reports it as GGIRT/GWIRT.  Only
    // surface rate targets map onto these keywords.
    //
    // A UDQ that refers to the target reads it from the summary state, so
    // the summary state is primed with the same value, in output units,
    // ahead of the UDQ evaluation that follows.  When nothing is in force
    // the slot is primed with the schedule's own target instead -- what the
    // end-of-step summary evaluation will report -- so that a target in
    // force on an earlier sync step cannot linger there.
    using M = UnitSystem::measure;
    auto& summary_state = this->simulator_.vanguard().summaryState();
    const auto& units = this->simulator_.vanguard().eclState().getUnits();
    auto& slave = this->reservoirCouplingSlave();
    const auto& rescoup = this->schedule()[reportStepIdx].rescoup();
    // The surface-rate group injection target vectors, which is all of them:
    // there is no oil equivalent, so a master oil injection target reaches the
    // control path but has nothing to be reported as; and GVIRT is a reservoir
    // volume target, which cannot be derived from what the master sends, since
    // it converts every injection mode to a surface rate before sending (see
    // RescoupConstraintsCalculator::calculateSlaveGroupInjectionTargets_()).
    // A slave UDQ naming GVIRT for a slave group therefore still reads the
    // schedule, as it did before reservoir coupling could report a target at
    // all.
    const auto targets = std::array {
        std::tuple { Phase::GAS,   std::string{"GGIRT"}, M::gas_surface_rate    },
        std::tuple { Phase::WATER, std::string{"GWIRT"}, M::liquid_surface_rate },
    };
    auto& in_force = slave.effectiveInjectionTargets();
    in_force.clear();
    for (std::size_t i = 0; i < slave.numSlaveGroups(); ++i) {
        const auto& gname = slave.slaveGroupIdxToGroupName(i);
        for (const auto& [phase, keyword, unit] : targets) {
            const auto effective = this->effectiveSlaveGroupInjectionTarget_(
                gname, phase, reportStepIdx, rescoup, summary_state);
            if (effective.has_value()) {
                in_force[gname][phase] = *effective;
                summary_state.update_group_var(gname, keyword, units.from_si(unit, *effective));
            }
            else {
                summary_state.update_group_var(
                    gname, keyword,
                    units.from_si(unit, this->scheduleInjectionTarget_(gname, phase, reportStepIdx, summary_state)));
            }
        }
    }
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
storeSlaveGroupProductionTargets()
{
    const int reportStepIdx = this->groupStateHelper().reportStepIdx();
    // As storeSlaveGroupInjectionTargets(), for the production rate limits.
    // The master sends a slave group a limit for every rate type: the target
    // of its active control mode, and its share of the other limits found up
    // the master's group tree.  The GRUPSLAV flag says how each combines with
    // the deck's own GCONPROD limit.  Work out the limit in force for each
    // rate type, keep it on the slave for the summary writer, and prime the
    // summary state for the UDQ evaluation that follows -- with the
    // schedule's own limit when nothing is in force.
    //
    // The values are primed in the measures the summary evaluators use.
    // RESV is left out: GVPRT does not report a group target, it adds up the
    // reservoir volume rate targets of the group's wells.
    using M = UnitSystem::measure;
    using CMode = Group::ProductionCMode;
    auto& summary_state = this->simulator_.vanguard().summaryState();
    const auto& units = this->simulator_.vanguard().eclState().getUnits();
    auto& slave = this->reservoirCouplingSlave();
    const auto& rescoup = this->schedule()[reportStepIdx].rescoup();
    const auto targets = std::array {
        std::tuple { CMode::ORAT, std::string{"GOPRT"}, M::rate             },
        std::tuple { CMode::WRAT, std::string{"GWPRT"}, M::rate             },
        std::tuple { CMode::GRAT, std::string{"GGPRT"}, M::gas_surface_rate },
        std::tuple { CMode::LRAT, std::string{"GLPRT"}, M::rate             },
    };
    auto& in_force = slave.effectiveProductionTargets();
    in_force.clear();
    for (std::size_t i = 0; i < slave.numSlaveGroups(); ++i) {
        const auto& gname = slave.slaveGroupIdxToGroupName(i);
        for (const auto& [cmode, keyword, unit] : targets) {
            const auto effective = this->effectiveSlaveGroupProductionTarget_(
                gname, cmode, reportStepIdx, rescoup, summary_state);
            if (effective.has_value()) {
                in_force[gname][cmode] = *effective;
                summary_state.update_group_var(gname, keyword, units.from_si(unit, *effective));
            }
            else {
                summary_state.update_group_var(
                    gname, keyword,
                    units.from_si(unit, this->scheduleProductionTarget_(gname, cmode, reportStepIdx, summary_state)));
            }
        }
    }
}
 
// Private methods alphabetically
// ------------------------------
 
template<typename TypeTag>
std::optional<typename BlackoilWellModelRescoup<TypeTag>::Scalar>
BlackoilWellModelRescoup<TypeTag>::
effectiveSlaveGroupInjectionTarget_(const std::string& gname,
                                    const Phase phase,
                                    const int reportStepIdx,
                                    const ReservoirCoupling::CouplingInfo& rescoup,
                                    const SummaryState& summary_state) const
{
    using FilterFlag = ReservoirCoupling::GrupSlav::FilterFlag;
    const auto& slave = this->reservoirCouplingSlave();
    if (! slave.hasMasterInjectionTarget(gname, phase)) {
        return std::nullopt;
    }
    const auto [master_target, cmode] = slave.masterInjectionTarget(gname, phase);
    if (cmode != Group::InjectionCMode::RATE) {
        return std::nullopt;
    }
 
    // Same fallback as GroupStateHelper::getInjectionFilterFlag_(): a slave
    // group without a GRUPSLAV record follows the master.
    auto filter = FilterFlag::MAST;
    if (rescoup.hasGrupSlav(gname)) {
        const auto& grup_slav = rescoup.grupSlav(gname);
        filter = (phase == Phase::GAS) ? grup_slav.gasInjFlag()
               : (phase == Phase::WATER) ? grup_slav.waterInjFlag()
               : grup_slav.oilInjFlag();
    }
    if (filter == FilterFlag::SLAV) {
        // The deck's own limit applies; the summary evaluator reads it from
        // the schedule as for any other group.
        return std::nullopt;
    }
    if (filter == FilterFlag::BOTH) {
        const auto& group = this->schedule().getGroup(gname, reportStepIdx);
        if (group.hasInjectionControl(phase)) {
            return std::min(master_target,
                            this->scheduleInjectionTarget_(gname, phase, reportStepIdx, summary_state));
        }
    }
    return master_target;
}
 
template<typename TypeTag>
std::optional<typename BlackoilWellModelRescoup<TypeTag>::Scalar>
BlackoilWellModelRescoup<TypeTag>::
effectiveSlaveGroupProductionTarget_(const std::string& gname,
                                     const Group::ProductionCMode cmode,
                                     const int reportStepIdx,
                                     const ReservoirCoupling::CouplingInfo& rescoup,
                                     const SummaryState& summary_state) const
{
    // The rule GroupStateHelper::getEffectiveProductionLimit_() applies in
    // the control path, with one difference.  That method is only reached
    // for a rate type the group has a GCONPROD limit of its own for, while
    // a limit is reported here for every rate type, so the deck's own limit
    // only takes part under BOTH when the group has one.
    using CMode = Group::ProductionCMode;
    using FilterFlag = ReservoirCoupling::GrupSlav::FilterFlag;
    const auto& slave = this->reservoirCouplingSlave();
    if (! slave.hasMasterProductionLimits(gname)) {
        return std::nullopt;
    }
    const auto& limits = slave.masterProductionLimits(gname);
    const Scalar master_limit = (cmode == CMode::ORAT) ? limits.oil_limit
                              : (cmode == CMode::WRAT) ? limits.water_limit
                              : (cmode == CMode::GRAT) ? limits.gas_limit
                              : limits.liquid_limit;
    if (master_limit < 0) {
        // No limit of this type up the master's group tree: the deck's own
        // limit applies, and the summary evaluator reads it from the schedule.
        return std::nullopt;
    }
 
    // Same mapping and fallback as GroupStateHelper::getProductionFilterFlag_():
    // the second production flag of GRUPSLAV covers both water and liquid, and
    // a slave group without a GRUPSLAV record follows the master.
    auto filter = FilterFlag::MAST;
    if (rescoup.hasGrupSlav(gname)) {
        const auto& grup_slav = rescoup.grupSlav(gname);
        filter = (cmode == CMode::ORAT) ? grup_slav.oilProdFlag()
               : (cmode == CMode::GRAT) ? grup_slav.gasProdFlag()
               : grup_slav.liquidProdFlag();
    }
    if (filter == FilterFlag::SLAV) {
        return std::nullopt;
    }
    if (filter == FilterFlag::BOTH) {
        const auto& group = this->schedule().getGroup(gname, reportStepIdx);
        if (group.has_control(cmode)) {
            return std::min(master_limit,
                            this->scheduleProductionTarget_(gname, cmode, reportStepIdx, summary_state));
        }
    }
    return master_limit;
}
 
template<typename TypeTag>
bool
BlackoilWellModelRescoup<TypeTag>::
masterNetworkHasMasterGroupLeavesForSlave_(std::size_t slave_idx) const
{
    // See masterNetworkHasMasterGroupLeaves() for why the parsed Schedule
    // topology is queried rather than the runtime node_pressures_ map.
    if (!this->isReservoirCouplingMaster()) return false;
    const int episodeIdx = this->simulator_.episodeIndex();
    const auto& network = this->schedule()[episodeIdx].network();
    if (!network.active()) return false;
    const auto& rcm = this->reservoirCouplingMaster();
    for (const auto& mg : rcm.getMasterGroupNamesForSlave(slave_idx)) {
        if (network.has_node(mg)) {
            return true;
        }
    }
    return false;
}
 
template<typename TypeTag>
typename BlackoilWellModelRescoup<TypeTag>::Scalar
BlackoilWellModelRescoup<TypeTag>::
scheduleInjectionTarget_(const std::string& gname,
                         const Phase phase,
                         const int reportStepIdx,
                         const SummaryState& summary_state) const
{
    const auto& group = this->schedule().getGroup(gname, reportStepIdx);
    if (! group.hasInjectionControl(phase)) {
        return Scalar{0};
    }
    return static_cast<Scalar>(group.injectionControls(phase, summary_state).surface_max_rate);
}
 
template<typename TypeTag>
typename BlackoilWellModelRescoup<TypeTag>::Scalar
BlackoilWellModelRescoup<TypeTag>::
scheduleProductionTarget_(const std::string& gname,
                          const Group::ProductionCMode cmode,
                          const int reportStepIdx,
                          const SummaryState& summary_state) const
{
    using CMode = Group::ProductionCMode;
    const auto controls = this->schedule().getGroup(gname, reportStepIdx)
        .productionControls(summary_state);
    switch (cmode) {
    case CMode::ORAT: return static_cast<Scalar>(controls.oil_target);
    case CMode::WRAT: return static_cast<Scalar>(controls.water_target);
    case CMode::GRAT: return static_cast<Scalar>(controls.gas_target);
    case CMode::LRAT: return static_cast<Scalar>(controls.liquid_target);
    default: return Scalar{0};
    }
}
 
template<typename TypeTag>
bool
BlackoilWellModelRescoup<TypeTag>::
slaveGroupIsFixedPressureNodeInOwnNetwork_(const std::string& group_name) const
{
    const int episodeIdx = this->simulator_.episodeIndex();
    const auto& network = this->schedule()[episodeIdx].network();
    if (!network.active()) return false;
    if (!network.has_node(group_name)) return false;
    return network.node(group_name).terminal_pressure().has_value();
}
 
template<typename TypeTag>
bool
BlackoilWellModelRescoup<TypeTag>::
wellIsBelowOverriddenNode_(const std::string& group_name,
                           const std::map<std::string, Scalar>& overrides) const
{
    if (overrides.empty()) return false;
    const int episodeIdx = this->simulator_.episodeIndex();
    const auto& network = this->schedule()[episodeIdx].network();
    if (!network.active() || !network.has_node(group_name)) return false;
    return nodeFollowsOverriddenNode(network, group_name, overrides);
}
 
 
} // namespace Opm
 
#endif // RESERVOIR_COUPLING_ENABLED
#endif // OPM_BLACKOILWELLMODEL_RESCOUP_IMPL_HEADER_INCLUDED