NonlinearSolverParameters.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_PHYSICSSOLVERS_NONLINEARSOLVERPARAMETERS_HPP_
#define GEOS_PHYSICSSOLVERS_NONLINEARSOLVERPARAMETERS_HPP_
 
#include "common/format/EnumStrings.hpp"
#include "dataRepository/Group.hpp"
#include "physicsSolvers/PhysicsSolverBaseKernels.hpp"
 
namespace geos
{
 
class NonlinearSolverParameters : public dataRepository::Group
{
public:
 
  NonlinearSolverParameters() = delete;
 
  NonlinearSolverParameters( string const & name,
                             Group * const parent );
 
  virtual ~NonlinearSolverParameters() = default;
 
  NonlinearSolverParameters( NonlinearSolverParameters && ) = default;
 
  NonlinearSolverParameters & operator=( const NonlinearSolverParameters & params )
  {
    m_lineSearchAction = params.m_lineSearchAction;
    m_lineSearchInterpType = params.m_lineSearchInterpType;
    m_lineSearchMaxCuts = params.m_lineSearchMaxCuts;
    m_lineSearchCutFactor = params.m_lineSearchCutFactor;
    m_lineSearchStartingIteration = params.m_lineSearchStartingIteration;
    m_lineSearchResidualFactor = params.m_lineSearchResidualFactor;
 
    m_newtonTol = params.m_newtonTol;
    m_maxIterNewton = params.m_maxIterNewton;
    m_minIterNewton = params.m_minIterNewton;
    m_numNewtonIterations = params.m_numNewtonIterations;
 
    m_maxAllowedResidualNorm = params.m_maxAllowedResidualNorm;
    m_allowNonConverged = params.m_allowNonConverged;
 
    m_timeStepDecreaseIterLimit = params.m_timeStepDecreaseIterLimit;
    m_timeStepIncreaseIterLimit = params.m_timeStepIncreaseIterLimit;
    m_timeStepDecreaseFactor = params.m_timeStepDecreaseFactor;
    m_timeStepIncreaseFactor = params.m_timeStepIncreaseFactor;
    m_minTimeStepIncreaseInterval = params.m_minTimeStepIncreaseInterval;
    m_maxSubSteps = params.m_maxSubSteps;
    m_maxTimeStepCuts = params.m_maxTimeStepCuts;
    m_timeStepCutFactor = params.m_timeStepCutFactor;
    m_maxNumConfigurationAttempts = params.m_maxNumConfigurationAttempts;
    m_configurationTolerance = params.m_configurationTolerance;
 
    setLogLevel( params.getLogLevel());
 
    return *this;
  }
 
  static string catalogName() { return "NonlinearSolverParameters"; }
 
  virtual void postInputInitialization() override;
 
  void print() const;
 
  struct viewKeysStruct
  {
    static constexpr char const * lineSearchActionString()        { return "lineSearchAction"; }
    static constexpr char const * lineSearchMaxCutsString()       { return "lineSearchMaxCuts"; }
    static constexpr char const * lineSearchCutFactorString()     { return "lineSearchCutFactor"; }
    static constexpr char const * lineSearchInterpolationTypeString() { return "lineSearchInterpolationType"; }
    static constexpr char const * lineSearchStartingIterationString() { return "lineSearchStartingIteration"; }
    static constexpr char const * lineSearchResidualFactorString() { return "lineSearchResidualFactor"; }
 
    static constexpr char const * normTypeString()                { return "normType"; }
    static constexpr char const * minNormalizerString()           { return "minNormalizer"; }
    static constexpr char const * newtonTolString()               { return "newtonTol"; }
    static constexpr char const * newtonMaxIterString()           { return "newtonMaxIter"; }
    static constexpr char const * newtonMinIterString()           { return "newtonMinIter"; }
    static constexpr char const * newtonNumIterationsString()     { return "newtonNumberOfIterations"; }
    static constexpr char const * newtonSplitOperMaxIterString()  { return "newtonSplitOperMaxIter"; }
 
    static constexpr char const * allowNonConvergedString()       { return "allowNonConverged"; }
    static constexpr char const * timeStepDecreaseIterLimString() { return "timeStepDecreaseIterLimit"; }
    static constexpr char const * timeStepIncreaseIterLimString() { return "timeStepIncreaseIterLimit"; }
    static constexpr char const * timeStepDecreaseFactorString()  { return "timeStepDecreaseFactor"; }
    static constexpr char const * timeStepIncreaseFactorString()  { return "timeStepIncreaseFactor"; }
    static constexpr char const * minTimeStepIncreaseIntervalString()  { return "minTimeStepIncreaseInterval"; }
 
    static constexpr char const * maxSubStepsString()             { return "maxSubSteps"; }
    static constexpr char const * maxTimeStepCutsString()         { return "maxTimeStepCuts"; }
    static constexpr char const * timeStepCutFactorString()       { return "timeStepCutFactor"; }
    static constexpr char const * maxAllowedResidualNormString()  { return "maxAllowedResidualNorm"; }
 
    static constexpr char const * maxNumConfigurationAttemptsString() { return "maxNumConfigurationAttempts"; }
    static constexpr char const * configurationToleranceString() { return "configurationTolerance"; }
 
    static constexpr char const * couplingTypeString()                   { return "couplingType"; }
    static constexpr char const * sequentialConvergenceCriterionString() { return "sequentialConvergenceCriterion"; }
    static constexpr char const * subcyclingOptionString()               { return "subcycling"; }
    static constexpr char const * nonlinearAccelerationTypeString() { return "nonlinearAccelerationType"; }
  } viewKeys;
 
  enum class LineSearchAction : integer
  {
    None,    
    Attempt, 
    Require, 
  };
 
  enum class LineSearchInterpolationType : integer
  {
    Linear,    
    Parabolic, 
  };
 
  enum class CouplingType : integer
  {
    FullyImplicit,      
    Sequential 
  };
 
  enum class SequentialConvergenceCriterion : integer
  {
    ResidualNorm, 
    NumberOfNonlinearIterations, 
    SolutionIncrements 
  };
 
  enum class NonlinearAccelerationType : integer
  {
    None, 
    Aitken 
  };
 
  integer timeStepDecreaseIterLimit() const
  {
    return std::ceil( m_timeStepDecreaseIterLimit * m_maxIterNewton );
  }
 
 
  integer timeStepIncreaseIterLimit() const
  {
    return std::ceil( m_timeStepIncreaseIterLimit * m_maxIterNewton );
  }
 
  real64 timeStepDecreaseFactor() const
  {
    return m_timeStepDecreaseFactor;
  }
 
  real64 timeStepIncreaseFactor() const
  {
    return m_timeStepIncreaseFactor;
  }
 
  integer minTimeStepIncreaseInterval() const
  {
    return m_minTimeStepIncreaseInterval;
  }
 
  physicsSolverBaseKernels::NormType normType() const
  {
    return m_normType;
  }
 
  CouplingType couplingType() const
  {
    return m_couplingType;
  }
 
  SequentialConvergenceCriterion sequentialConvergenceCriterion() const
  {
    return m_sequentialConvergenceCriterion;
  }
 
  LineSearchAction m_lineSearchAction;
 
  LineSearchInterpolationType m_lineSearchInterpType;
 
  integer m_lineSearchMaxCuts;
 
  real64 m_lineSearchCutFactor;
 
  integer m_lineSearchStartingIteration;
 
  real64 m_lineSearchResidualFactor;
 
  physicsSolverBaseKernels::NormType m_normType;
 
  real64 m_newtonTol;
 
  integer m_maxIterNewton;
 
  integer m_minIterNewton;
 
  integer m_numNewtonIterations;
 
  real64 m_maxAllowedResidualNorm;
 
  integer m_allowNonConverged;
 
  real64 m_timeStepDecreaseIterLimit;
 
  real64 m_timeStepIncreaseIterLimit;
 
  real64 m_timeStepDecreaseFactor;
 
  real64 m_timeStepIncreaseFactor;
 
  integer m_minTimeStepIncreaseInterval;
 
  integer m_maxSubSteps;
 
  integer m_maxTimeStepCuts;
 
  real64 m_timeStepCutFactor;
 
  integer m_numTimeStepAttempts;
 
  integer m_numConfigurationAttempts;
 
  integer m_maxNumConfigurationAttempts;
 
  double m_configurationTolerance;
 
  CouplingType m_couplingType;
 
  SequentialConvergenceCriterion m_sequentialConvergenceCriterion;
 
  integer m_subcyclingOption;
 
  NonlinearAccelerationType m_nonlinearAccelerationType;
 
  real64 m_minNormalizer = 1e-12;
};
 
ENUM_STRINGS( NonlinearSolverParameters::LineSearchAction,
              "None",
              "Attempt",
              "Require" );
 
ENUM_STRINGS( NonlinearSolverParameters::LineSearchInterpolationType,
              "Linear",
              "Parabolic" );
 
ENUM_STRINGS( NonlinearSolverParameters::CouplingType,
              "FullyImplicit",
              "Sequential" );
 
ENUM_STRINGS( NonlinearSolverParameters::SequentialConvergenceCriterion,
              "ResidualNorm",
              "NumberOfNonlinearIterations",
              "SolutionIncrements" );
 
ENUM_STRINGS( NonlinearSolverParameters::NonlinearAccelerationType,
              "None",
              "Aitken" );
 
} /* namespace geos */
 
#endif /* GEOS_PHYSICSSOLVERS_NONLINEARSOLVERPARAMETERS_HPP_ */