BlackoilModelParameters.hpp

Go to the documentation of this file.

/*
  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; };
 
// Convert plain (single-segment) wells into multisegment wells at
// construction, so the wellbore hydrostatic head is handled implicitly.
// A string rather than a bool because more than one topology is useful:
// "per-connection" gives one segment per connection. "none" is the default.
struct ConvertToMultisegmentWell { static constexpr auto value = "none"; };
 
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