ReservoirCouplingMasterReportStep.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_RESERVOIR_COUPLING_MASTER_REPORT_STEP_HPP
#define OPM_RESERVOIR_COUPLING_MASTER_REPORT_STEP_HPP
 
#include <opm/simulators/flow/rescoup/ReservoirCoupling.hpp>
#include <opm/simulators/flow/rescoup/ReservoirCouplingMpiTraits.hpp>
#include <opm/output/data/Groups.hpp>
#include <opm/input/eclipse/Schedule/Schedule.hpp>
#include <opm/simulators/utils/ParallelCommunication.hpp>
#include <opm/common/OpmLog/OpmLog.hpp>
 
#include <mpi.h>
 
#include <array>
#include <limits>
#include <map>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
namespace Opm {
 
// Avoid including the complete definition of ReservoirCouplingMaster here to avoid circular dependency.
template <class Scalar> class ReservoirCouplingMaster;
 
template <class Scalar>
class ReservoirCouplingMasterReportStep {
public:
    using MessageTag = ReservoirCoupling::MessageTag;
    using Potentials = ReservoirCoupling::Potentials<Scalar>;
    using SlaveGroupProductionData = ReservoirCoupling::SlaveGroupProductionData<Scalar>;
    using SlaveGroupInjectionData = ReservoirCoupling::SlaveGroupInjectionData<Scalar>;
    using InjectionGroupTarget = ReservoirCoupling::InjectionGroupTarget<Scalar>;
    using MasterGroupNodePressure = ReservoirCoupling::MasterGroupNodePressure<Scalar>;
    using ProductionGroupConstraints = ReservoirCoupling::ProductionGroupConstraints<Scalar>;
 
    ReservoirCouplingMasterReportStep(
        ReservoirCouplingMaster<Scalar> &master
    );
 
    const Parallel::Communication &comm() const { return this->master_.getComm(); }
 
    const std::vector<std::string>& getMasterGroupNamesForSlave(std::size_t slave_idx) const {
         return this->master_.getMasterGroupNamesForSlave(slave_idx);
    }
 
    const std::map<std::string, std::string>& getMasterGroupToSlaveNameMap() const {
         return this->master_.getMasterGroupToSlaveNameMap();
    }
 
    std::size_t getMasterGroupCanonicalIdx(
        const std::string &slave_name, const std::string &master_group_name) const;
 
    MPI_Comm getSlaveComm(int index) const { return this->master_.getSlaveComm(index); }
 
    Scalar getMasterGroupInjectionSurfaceRate(const std::string &group_name, ReservoirCoupling::Phase phase) const;
 
    Scalar getMasterGroupInjectionReservoirRate(const std::string &group_name, ReservoirCoupling::Phase phase) const;
 
    Scalar getMasterGroupProductionSurfaceRate(const std::string &group_name, ReservoirCoupling::Phase phase) const;
 
    Scalar getMasterGroupNetworkProductionSurfaceRate(
        const std::string &group_name, ReservoirCoupling::Phase phase) const;
 
    Scalar getMasterGroupProductionReservoirRate(const std::string &group_name, ReservoirCoupling::Phase phase) const;
 
    int getSlaveGroupNumGroupControlledInjectors(const std::string &master_group_name,
                                                 ReservoirCoupling::Phase phase) const;
 
    int getSlaveGroupNumGroupControlledProducers(const std::string &master_group_name) const;
 
    const Potentials& getSlaveGroupPotentials(const std::string &master_group_name) const;
 
    bool isFirstSubstepOfSyncTimestep() const { return is_first_substep_of_sync_timestep_; }
 
    bool needsSlaveDataReceive() const { return needs_slave_data_receive_; }
 
    void setNeedsSlaveDataReceive(bool value) { needs_slave_data_receive_ = value; }
 
    std::size_t numSlaveGroups(unsigned int index) const { return this->master_.numSlaveGroups(index); }
 
    std::size_t numSlaves() const { return this->master_.numSlavesStarted(); }
 
    ReservoirCoupling::Logger& logger() const { return this->master_.logger(); }
 
    void receiveInjectionDataFromSlaves();
 
    void receiveProductionDataFromSlaves();
 
    const Schedule &schedule() const { return this->master_.schedule(); }
 
    void sendCoupledNetworkActiveStatusToSlave(
        std::size_t slave_idx, bool active
    ) const;
 
    void sendInjectionTargetsToSlave(
        std::size_t slave_idx, const std::vector<InjectionGroupTarget>& injection_targets
    ) const;
 
    void sendMasterGroupNodePressuresToSlave(
        std::size_t slave_idx, const std::vector<MasterGroupNodePressure>& pressures
    ) const;
 
    void sendNumGroupConstraintsToSlave(
        std::size_t slave_idx, std::size_t num_injection_targets, std::size_t num_production_constraints
    ) const;
 
    void sendNumMasterGroupNodePressuresToSlave(
        std::size_t slave_idx, std::size_t num_pressures, bool is_final
    ) const;
 
    void sendProductionConstraintsToSlave(
        std::size_t slave_idx, const std::vector<ProductionGroupConstraints>& production_constraints
    ) const;
 
    void setFirstSubstepOfSyncTimestep(bool value) { is_first_substep_of_sync_timestep_ = value; }
 
    void setReportStepIdx(int report_step_idx);
 
    void setSlaveGroupInjectionData(const std::string& slave_name,
                                    std::vector<SlaveGroupInjectionData> injection_data)
    {
        this->slave_group_injection_data_[slave_name] = std::move(injection_data);
    }
 
    void setSlaveGroupProductionData(const std::string& slave_name,
                                     std::vector<SlaveGroupProductionData> production_data)
    {
        this->slave_group_production_data_[slave_name] = std::move(production_data);
    }
 
    void saveGroupFlowsAtStartOfSyncStep();
 
    void setSyncStepLength(Scalar length) { sync_step_length_ = length; }
 
    void updateFlowChangeTimeStepLimit();
 
    Scalar flowChangeTimeStepLimit() const { return flow_change_time_step_limit_; }
 
    std::tuple<std::string, Scalar, Scalar> flowChangeLimitingGroup() const {
        return {flow_change_limiting_group_, flow_change_limiting_change_, flow_change_limiting_fraction_};
    }
 
    data::ReservoirCouplingGroupRates collectGroupRatesForSummary() const;
 
    bool slaveIsCoupled(int index) const { return this->master_.slaveIsCoupled(index); }
 
    const std::string &slaveName(int index) const { return this->master_.getSlaveName(index); }
 
private:
    struct GroupFlows {
        Scalar production_reservoir{};
        std::array<Scalar, 3> injection_surface{};
    };
 
    GroupFlows getMasterGroupFlows_(const std::string& group_name) const;
 
    Scalar getMasterGroupRate_(const std::string &group_name, ReservoirCoupling::Phase phase,
                               ReservoirCoupling::RateKind kind) const;
 
    ReservoirCouplingMaster<Scalar> &master_;
 
    int report_step_idx_;
 
    std::map<std::string, std::vector<SlaveGroupProductionData>> slave_group_production_data_;
 
    std::map<std::string, std::vector<SlaveGroupInjectionData>> slave_group_injection_data_;
 
    bool is_first_substep_of_sync_timestep_{true};
 
    bool needs_slave_data_receive_{false};
 
    std::map<std::string, GroupFlows> group_flows_at_start_of_sync_step_;
 
    Scalar sync_step_length_{0};
 
    Scalar flow_change_time_step_limit_{std::numeric_limits<Scalar>::infinity()};
 
    std::string flow_change_limiting_group_;
    Scalar flow_change_limiting_change_{0};
    Scalar flow_change_limiting_fraction_{0};
};
} // namespace Opm
#endif // OPM_RESERVOIR_COUPLING_MASTER_REPORT_STEP_HPP