BlackoilModelParameters.hpp

/*
  Copyright 2015 SINTEF ICT, Applied Mathematics.

  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_BLACKOILMODELPARAMETERS_HEADER_INCLUDED
#define OPM_BLACKOILMODELPARAMETERS_HEADER_INCLUDED

#include <opm/simulators/flow/SubDomain.hpp>

#include <string>

namespace Opm::Parameters {

template<class Scalar>
struct DbhpMaxRel { static constexpr Scalar value = 1.0; };

template<class Scalar>
struct DwellFractionMax { static constexpr Scalar value = 0.2; };

struct EclDeckFileName { static constexpr auto value = ""; };

template<class Scalar>
struct InjMultOscThreshold { static constexpr Scalar value = 0.1; };

template<class Scalar>
struct InjMultDampMult { static constexpr Scalar value = 0.9; };

template<class Scalar>
struct InjMultMinDampFactor { static constexpr Scalar value = 0.05; };

template<class Scalar>
struct MaxResidualAllowed { static constexpr Scalar value = 1e7; };

template<class Scalar>
struct RelaxedMaxPvFraction { static constexpr Scalar value = 0.03; };

template<class Scalar>
struct ToleranceMb { static constexpr Scalar value = 1e-7; };

template<class Scalar>
struct ToleranceMbRelaxed { static constexpr Scalar value = 1e-6; };

//TODO change to a simpler number with fewer digits
//converting J -> RM3 (entalpy / (cp * deltaK * rho) assuming change of 1e-5K of water
template<class Scalar>
struct ToleranceEnergyBalance { static constexpr Scalar value = 1e-7*41.82; };

template<class Scalar>
struct ToleranceEnergyBalanceRelaxed { static constexpr Scalar value = 1e-6*41.82; };

template<class Scalar>
struct ToleranceCnv { static constexpr Scalar value = 1e-2; };

template<class Scalar>
struct ToleranceCnvRelaxed { static constexpr Scalar value = 1.0; };

template<class Scalar>
struct ToleranceCnvEnergy { static constexpr Scalar value = 1e-2*41.82; };

template<class Scalar>
struct ToleranceCnvEnergyRelaxed { static constexpr Scalar value = 1.0*41.82; };

template<class Scalar>
struct ToleranceMaxDp { static constexpr Scalar value = 0.0; };

template<class Scalar>
struct ToleranceMaxDs { static constexpr Scalar value = 0.0; };

template<class Scalar>
struct ToleranceMaxDrs { static constexpr Scalar value = 0.0; };

template<class Scalar>
struct ToleranceMaxDrv { static constexpr Scalar value = 0.0; };

template<class Scalar>
struct ToleranceWells { static constexpr Scalar value = 1e-4; };

template<class Scalar>
struct ToleranceWellControl { static constexpr Scalar value = 1e-7; };

struct MaxWelleqIter { static constexpr int value = 30; };

template<class Scalar>
struct MaxSinglePrecisionDays { static constexpr Scalar value = 20.0; };

struct MinStrictCnvIter { static constexpr int value = -1; };
struct MinStrictMbIter { static constexpr int value = -1; };
struct SolveWelleqInitially { static constexpr bool value = true; };
struct PreSolveNetwork { static constexpr bool value = true; };
struct UpdateEquationsScaling { static constexpr bool value = false; };
struct UseUpdateStabilization { static constexpr bool value = true; };
struct MatrixAddWellContributions { static constexpr bool value = false; };

struct UseMultisegmentWell { static constexpr bool value = true; };

template<class Scalar>
struct TolerancePressureMsWells { static constexpr Scalar value = 0.01*1e5; };

template<class Scalar>
struct MaxPressureChangeMsWells { static constexpr Scalar value = 10*1e5; };

struct MaxNewtonIterationsWithInnerWellIterations { static constexpr int value = 99; };
struct MaxInnerIterMsWells { static constexpr int value = 100; };
struct MaxInnerIterWells { static constexpr int value = 50; };
struct MaxWellStatusSwitchInInnerIterWells { static constexpr int value = 99; };
struct MaxWellStatusSwitchForWells { static constexpr int value = 99; };
struct ShutUnsolvableWells { static constexpr bool value = true; };
struct AlternativeWellRateInit { static constexpr bool value = true; };
struct StrictOuterIterWells { static constexpr int value = 6; };
struct StrictInnerIterWells { static constexpr int value = 40; };

template<class Scalar>
struct RegularizationFactorWells { static constexpr Scalar value = 100.0; };

struct EnableWellOperabilityCheck { static constexpr bool value = true; };
struct EnableWellOperabilityCheckIter { static constexpr bool value = false; };
struct DebugEmitCellPartition { static constexpr bool value = false; };

template<class Scalar>
struct RelaxedWellFlowTol { static constexpr Scalar value = 1e-3; };

template<class Scalar>
struct RelaxedPressureTolMsw { static constexpr Scalar value = 1e4; };

struct MaximumNumberOfWellSwitches { static constexpr int value = 3; };
struct MaximumNumberOfGroupSwitches { static constexpr int value = 3; };
struct UseAverageDensityMsWells { static constexpr bool value = false; };
struct LocalWellSolveControlSwitching { static constexpr bool value = true; };
struct UseImplicitIpr { static constexpr bool value = true; };
struct CheckGroupConstraintsInnerWellIterations { static constexpr bool value = true; };

// Network solver parameters
struct NetworkMaxStrictOuterIterations { static constexpr int value = 10; };
struct NetworkMaxOuterIterations { static constexpr int value = 3; };
struct NetworkMaxSubIterations { static constexpr int value = 100; };
template<class Scalar>
struct NetworkPressureUpdateDampingFactor { static constexpr Scalar value = 0.1; };
template<class Scalar>
struct NetworkMaxPressureUpdateInBars { static constexpr Scalar value = 5.0; };
// Reservoir coupling: when false (default) the master exchanges node pressures
// and slave rates with the slaves once per master inner network sub-iteration
// (tight coupling).  When true, the exchange happens only once per master outer network
// iteration (loose coupling).
struct RcNetworkLooseCoupling { static constexpr bool value = false; };
struct NonlinearSolver { static constexpr auto value = "newton"; };
struct LocalSolveApproach { static constexpr auto value = "gauss-seidel"; };
struct MaxLocalSolveIterations { static constexpr int value = 20; };
struct NewtonMinIterations { static constexpr int value = 2; };

struct WellGroupConstraintsMaxIterations { static constexpr int value = 1; };
template<class Scalar>
struct GroupControlFractionTolerance { static constexpr Scalar value = 1e-4; };
template<class Scalar>
struct LocalToleranceScalingMb { static constexpr Scalar value = 1.0; };

template<class Scalar>
struct LocalToleranceScalingCnv { static constexpr Scalar value = 0.1; };
struct NlddNumInitialNewtonIter { static constexpr int value = 1; };
template<class Scalar>
struct NlddRelativeMobilityChangeTol { static constexpr Scalar value = 0.1; };
struct NumLocalDomains { static constexpr int value = 0; };

template<class Scalar>
struct LocalDomainsPartitioningImbalance { static constexpr Scalar value = 1.03; };

struct LocalDomainsPartitioningMethod { static constexpr auto value = "zoltan"; };
struct LocalDomainsPartitionWellNeighborLevels { static constexpr int value = 1; };
struct LocalDomainsOrderingMeasure { static constexpr auto value = "maxpressure"; };

struct ConvergenceMonitoring { static constexpr bool value = false; };
struct ConvergenceMonitoringCutOff { static constexpr int value = 6; };
template<class Scalar>
struct ConvergenceMonitoringDecayFactor { static constexpr Scalar value = 0.75; };


template<class Scalar>
struct NupcolGroupRateTolerance { static constexpr Scalar value = 0.001; };

} // namespace Opm::Parameters

namespace Opm {

template <class Scalar>
struct BlackoilModelParameters
{
public:
    Scalar dbhp_max_rel_;
    Scalar dwell_fraction_max_;
    Scalar inj_mult_osc_threshold_;
    Scalar inj_mult_damp_mult_;
    Scalar inj_mult_min_damp_factor_;
    Scalar max_residual_allowed_;
    Scalar relaxed_max_pv_fraction_;
    Scalar tolerance_mb_;
    Scalar tolerance_mb_relaxed_;
    Scalar tolerance_energy_balance_;
    Scalar tolerance_energy_balance_relaxed_;
    Scalar tolerance_cnv_;
    Scalar tolerance_cnv_relaxed_;
    Scalar tolerance_cnv_energy_;
    Scalar tolerance_cnv_energy_relaxed_;
    Scalar tolerance_max_dp_;
    Scalar tolerance_max_ds_;
    Scalar tolerance_max_drs_;
    Scalar tolerance_max_drv_;
    Scalar tolerance_wells_;
    //  TODO: it might need to distinguish between rate control and pressure control later
    Scalar tolerance_well_control_;
    Scalar tolerance_pressure_ms_wells_;
    Scalar relaxed_tolerance_flow_well_;

    Scalar relaxed_tolerance_pressure_ms_well_;

    Scalar max_pressure_change_ms_wells_;

    int max_inner_iter_ms_wells_;

    int strict_inner_iter_wells_;

    int strict_outer_iter_wells_;

    Scalar regularization_factor_wells_;

    int max_niter_inner_well_iter_;

    bool shut_unsolvable_wells_;

    int max_inner_iter_wells_;

    int max_welleq_iter_;

    Scalar maxSinglePrecisionTimeStep_;

    int min_strict_cnv_iter_;

    int min_strict_mb_iter_;

    bool solve_welleq_initially_;

    bool pre_solve_network_;

    bool update_equations_scaling_;

    bool use_update_stabilization_;

    bool use_multisegment_well_;

    std::string deck_file_name_;

    bool matrix_add_well_contributions_;

    bool check_well_operability_;
    bool check_well_operability_iter_;

    int max_number_of_well_switches_;

    int max_number_of_group_switches_;

    bool use_average_density_ms_wells_;

    bool local_well_solver_control_switching_;

    bool use_implicit_ipr_;

    bool check_group_constraints_inner_well_iterations_;

    int network_max_strict_outer_iterations_;

    int network_max_outer_iterations_;

    int network_max_sub_iterations_;

    Scalar network_pressure_update_damping_factor_;

    Scalar network_max_pressure_update_in_bars_;

    bool rc_network_loose_coupling_;

    int well_group_constraints_max_iterations_;

    int max_well_status_switch_inner_iter_;

    int max_well_status_switch_;

    Scalar group_control_fraction_tolerance_;

    std::string nonlinear_solver_;

    DomainSolveApproach local_solve_approach_{DomainSolveApproach::Jacobi};

    int newton_max_iter_;

    int newton_min_iter_;

    int max_local_solve_iterations_;

    Scalar local_tolerance_scaling_mb_;
    Scalar local_tolerance_scaling_cnv_;

    int nldd_num_initial_newton_iter_{1};
    Scalar nldd_relative_mobility_change_tol_;
    int num_local_domains_{0};
    Scalar local_domains_partition_imbalance_{1.03};
    std::string local_domains_partition_method_;
    int local_domains_partition_well_neighbor_levels_{1};
    DomainOrderingMeasure local_domains_ordering_{DomainOrderingMeasure::MaxPressure};

    bool write_partitions_{false};

    struct ConvergenceMonitorParams
    {
        bool enabled_;
        int cutoff_;
        Scalar decay_factor_;
    };

    ConvergenceMonitorParams monitor_params_; 

    // Relative tolerance of group rates (VREP, REIN)
    // If violated the nupcol wellstate is updated
    Scalar nupcol_group_rate_tolerance_;

    BlackoilModelParameters();

    static void registerParameters();
};

} // namespace Opm

#endif // OPM_BLACKOILMODELPARAMETERS_HEADER_INCLUDED