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/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->refreshAndSendInjectionTargets_();
        }
    }
}
 
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->refreshAndSendInjectionTargets_();
}
 
template<typename TypeTag>
void
BlackoilWellModelRescoup<TypeTag>::
receiveCoupledNetworkActiveStatus()
{
    OPM_TIMEFUNCTION();
    assert(this->isReservoirCouplingSlave());
    this->reservoirCouplingSlave().receiveCoupledNetworkActiveStatusFromMaster();
}
 
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.
    //
    // TODO (follow-up PR): when the slave group is a fixed-pressure node with
    // branches below it, the pressure belongs at the top of the slave's own
    // network solve rather than directly on the wells; the slave's branches
    // and their pressure losses then decide the wells' THP limits.  The
    // plumbing exists -- the solver already reads
    // Network::Node::terminal_pressure() when walking up branches -- but
    // surfacing the master-sent value into the solver needs a runtime
    // override path (e.g. a fixed-pressure override map on
    // BlackoilWellModelNetwork) so we do not mutate the parsed Schedule
    // network at runtime.  Until then the direct write below is exact only
    // for a slave group that is itself a well group, where there is no
    // branch between the node and the wells.
    const auto& pressures = rescoup_slave.masterGroupNodePressures();
    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();
        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()];
        if (ws.production_cmode == Well::ProducerCMode::THP) {
            ws.thp = well->getTHPConstraint(summary_state);
        }
    }
}
 
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>::
refreshSlaveGroupInjectionTargets()
{
    // The deck's own GCONINJE limit may be a UDA, resolved from the summary
    // state, and the UDQ evaluation below may change it.  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 loop over the slave groups, not the UDQ evaluation.
    this->storeSlaveGroupInjectionTargets();
    this->evalGroupAndFieldUDQs();
    this->storeSlaveGroupInjectionTargets();
}
 
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).
    if (this->isReservoirCouplingMaster()) {
        if (this->reservoirCouplingMaster().needsSlaveDataReceive()) {
            this->receiveSlaveGroupData();
            this->reservoirCouplingMaster().setNeedsSlaveDataReceive(false);
        }
    }
    if (this->isReservoirCouplingSlave()) {
        if (this->reservoirCouplingSlave().isLastSubstepOfSyncTimestep()) {
            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()};
    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)));
            }
        }
    }
}
 
// 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>
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>
void
BlackoilWellModelRescoup<TypeTag>::
refreshAndSendInjectionTargets_()
{
    // Called right after a receiveSlaveGroupData() inside the network iteration.
    // Fold the rates just received into the master's group state -- that is what
    // recomputes the reinjection and voidage rates that a GCONINJE REIN, SALE
    // or VREP target is built from -- and ship the resulting targets to the
    // slaves, replacing the ones they are currently holding.  Without this the
    // targets stay at the values computed in beginTimeStep(), from slave
    // production of the previous sync step.
    const int report_step_idx = this->well_model_.simulator().episodeIndex();
    this->well_model_.updateAndCommunicateGroupData(
        report_step_idx, /*update_wellgrouptarget=*/false);
    this->sendMasterGroupInjectionTargetsToSlaves_();
}
 
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>
void
BlackoilWellModelRescoup<TypeTag>::
sendMasterGroupInjectionTargetsToSlaves_()
{
    OPM_TIMEFUNCTION();
    RescoupConstraintsCalculator<Scalar, IndexTraits> constraints_calculator{
        this->well_model_.guideRateHandler(),
        this->groupStateHelper()
    };
    constraints_calculator.recalculateInjectionTargetsAndSendToSlaves();
}
 
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();
}
 
 
} // namespace Opm
 
#endif // RESERVOIR_COUPLING_ENABLED
#endif // OPM_BLACKOILWELLMODEL_RESCOUP_IMPL_HEADER_INCLUDED