ReservoirCouplingMasterReportStep.hpp

/*
  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 <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;

    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);

    data::ReservoirCouplingGroupRates collectGroupRatesForSummary() const;

    bool slaveIsActivated(int index) const { return this->master_.slaveIsActivated(index); }

    const std::string &slaveName(int index) const { return this->master_.getSlaveName(index); }

private:
    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};
};
} // namespace Opm
#endif // OPM_RESERVOIR_COUPLING_MASTER_REPORT_STEP_HPP