NonlinearSystem.hpp

Go to the documentation of this file.

#ifndef OPM_FLOW_NONLINEAR_SYSTEM_HEADER_INCLUDED
#define OPM_FLOW_NONLINEAR_SYSTEM_HEADER_INCLUDED
/*
  Copyright 2026, SINTEF Digital
 
  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/>.
*/
#include <cstddef>
 
#include <opm/input/eclipse/Schedule/Tuning.hpp>
 
#include <opm/models/utils/propertysystem.hh>
 
#include <opm/simulators/flow/BlackoilModelParameters.hpp>
#include <opm/simulators/flow/FlowBaseProblemProperties.hpp>
#include <opm/simulators/linalg/linalgproperties.hh>
#include <opm/simulators/timestepping/ConvergenceReport.hpp>
#include <opm/simulators/timestepping/SimulatorReport.hpp>
#include <opm/simulators/timestepping/SimulatorTimerInterface.hpp>
#include <opm/simulators/utils/ComponentName.hpp>
#include <opm/simulators/utils/ParallelCommunication.hpp>
#include <span>
#include <string_view>
#include <tuple>
#include <vector>
 
namespace Opm {
 
template <class TypeTag>
class NonlinearSystem
{
public:
    // --------- Types ---------
    using Simulator = GetPropType<TypeTag, Properties::Simulator>;
    using Grid = GetPropType<TypeTag, Properties::Grid>;
    using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
    using Indices = GetPropType<TypeTag, Properties::Indices>;
    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
    using GlobalEqVector = GetPropType<TypeTag, Properties::GlobalEqVector>;
    using ModelParameters = BlackoilModelParameters<Scalar>;
    using WellModel = GetPropType<TypeTag, Properties::WellModel>;
    using ComponentName = ::Opm::ComponentName<FluidSystem, Indices>;
 
    // --------- Public methods ---------
    virtual ~NonlinearSystem() = default;
 
    bool isParallel() const
    { return grid_.comm().size() > 1; }
 
    const Simulator& simulator() const
    { return simulator_; }
 
    Simulator& simulator()
    { return simulator_; }
 
    bool terminalOutputEnabled() const
    { return terminal_output_; }
 
    int numPhases() const
    { return Indices::numPhases; }
 
    const SimulatorReportSingle& failureReport() const
    { return failureReport_; }
 
    const std::vector<StepReport>& stepReports() const
    { return convergence_reports_; }
 
    const ComponentName& compNames() const
    { return compNames_; }
 
    const ModelParameters& param() const
    { return param_; }
 
    WellModel& wellModel()
    { return well_model_; }
 
    const WellModel& wellModel() const
    { return well_model_; }
 
    void beginReportStep()
    { simulator_.problem().beginEpisode(); }
 
    void endReportStep()
    { simulator_.problem().endEpisode(); }
 
    SimulatorReportSingle assembleReservoir(const SimulatorTimerInterface& timer);
 
    void updateTUNING(const Tuning& tuning);
 
    void updateTUNINGDP(const TuningDp& tuning_dp);
 
    void updateSolution(const GlobalEqVector& dx);
 
    template <class LogFailure>
    void addReservoirConvergenceMetrics(ConvergenceReport& report,
                                        const int componentIdx,
                                        const std::string_view componentName,
                                        const std::span<const Scalar> residuals,
                                        const std::span<const ConvergenceReport::ReservoirFailure::Type> types,
                                        const std::span<const Scalar> tolerances,
                                        const Scalar maxResidualAllowed,
                                        LogFailure&& logFailure) const;
 
protected:
    explicit NonlinearSystem(Simulator& simulator,
                             const ModelParameters& param,
                             WellModel& wellModel,
                             const bool terminal_output);
 
    virtual void initialLinearization(SimulatorReportSingle& report,
                                      int minIter,
                                      int maxIter,
                                      const SimulatorTimerInterface& timer);
 
    virtual bool shouldStoreSolutionUpdate() const
    { return false; }
 
    virtual void prepareSolutionUpdate()
    {}
 
    virtual void storeSolutionUpdate(const GlobalEqVector&)
    {}
 
    SimulatorReportSingle prepareStep(const SimulatorTimerInterface& timer);
 
    template <class WellModelType>
    SimulatorReportSingle assembleReservoir(WellModelType& wellModel);
 
    template <class ModelParametersType>
    void applyTUNING(ModelParametersType& param,
                     const Tuning& tuning);
 
    template <class ModelParametersType>
    void applyTUNINGDP(ModelParametersType& param,
                       const TuningDp& tuning_dp);
 
    template <class ValueType>
    std::tuple<ValueType, ValueType>
    convergenceReduction(Parallel::Communication comm,
                         const ValueType primaryVolumeLocal,
                         const ValueType secondaryVolumeLocal,
                         std::vector<ValueType>& sumValues,
                         std::vector<ValueType>& maxValues,
                         std::vector<ValueType>& averagedValues);
 
    void popLastStepReport()
    { convergence_reports_.back().report.pop_back(); }
 
    // --------- Data members ---------
    Simulator& simulator_;
    const Grid& grid_;
    bool terminal_output_;
    ModelParameters param_;
    WellModel& well_model_;
    SimulatorReportSingle failureReport_;
    std::vector<StepReport> convergence_reports_;
    ComponentName compNames_{};
    std::vector<std::vector<Scalar>> residual_norms_history_;
    Scalar current_relaxation_;
    GlobalEqVector dx_old_;
};
 
} // namespace Opm
 
#include <opm/simulators/flow/NonlinearSystem_impl.hpp>
 
#endif // OPM_FLOW_NONLINEAR_SYSTEM_HEADER_INCLUDED