solver_config.hpp

Go to the documentation of this file.

// Copyright (c) Lawrence Livermore National Security, LLC and
// other Serac Project Developers. See the top-level LICENSE file for
// details.
//
// SPDX-License-Identifier: (BSD-3-Clause)
 
#pragma once
 
#include <variant>
 
#include "mfem.hpp"
#include "axom/fmt.hpp"
 
namespace serac {
 
enum class TimestepMethod
{
  QuasiStatic, 
  // options for first order ODEs
  BackwardEuler,    
  SDIRK33,          
  ForwardEuler,     
  RK2,              
  RK3SSP,           
  RK4,              
  GeneralizedAlpha, 
  ImplicitMidpoint, 
  SDIRK23,          
  SDIRK34,          
  // options for second order ODEs
  //
  // note: we don't have a way to communicate
  //       parameters to the TimestepMethod,
  //       right now, so Newmark implies
  //       (beta = 0.25, gamma = 0.5)
  Newmark,             
  HHTAlpha,            
  WBZAlpha,            
  AverageAcceleration, 
  LinearAcceleration,  
  CentralDifference,   
  FoxGoodwin           
};
 
enum class DirichletEnforcementMethod
{
  DirectControl,
 
  RateControl,
 
  FullControl
};
 
struct TimesteppingOptions {
  TimestepMethod timestepper = TimestepMethod::QuasiStatic;
 
  DirichletEnforcementMethod enforcement_method = DirichletEnforcementMethod::RateControl;
};
 
// _linear_solvers_start
enum class LinearSolver
{
  CG,        
  GMRES,     
  SuperLU,   
  Strumpack, 
  PetscCG,   
  PetscGMRES 
};
// _linear_solvers_end
 
inline std::string linearName(const LinearSolver& s)
{
  switch (s) {
    case LinearSolver::CG:
      return "CG";
    case LinearSolver::GMRES:
      return "GMRES";
    case LinearSolver::SuperLU:
      return "SuperLU";
    case LinearSolver::Strumpack:
      return "Strumpack";
    case LinearSolver::PetscCG:
      return "PetscCG";
    case LinearSolver::PetscGMRES:
      return "PetscGMRES";
  }
  // This cannot happen, but GCC doesn't know that
  return "UNKNOWN";
}
 
inline std::ostream& operator<<(std::ostream& os, LinearSolver s) { return os << linearName(s); }
 
inline std::map<std::string, LinearSolver> linearSolverMap = {
    {"CG", LinearSolver::CG},           {"GMRES", LinearSolver::GMRES},
    {"SuperLU", LinearSolver::SuperLU}, {"Strumpack", LinearSolver::Strumpack},
    {"PetscCG", LinearSolver::PetscCG}, {"PetscGMRES", LinearSolver::PetscGMRES},
};
 
// Add a custom list of strings? conduit node?
// Arbitrary string (e.g. json) to define parameters?
 
// _nonlinear_solvers_start
enum class NonlinearSolver
{
  Newton,                    
  LBFGS,                     
  NewtonLineSearch,          
  TrustRegion,               
  KINFullStep,               
  KINBacktrackingLineSearch, 
  KINPicard,                 
  PetscNewton,               
  PetscNewtonBacktracking,   
  PetscNewtonCriticalPoint,  
  PetscTrustRegion           
};
// _nonlinear_solvers_end
 
inline std::string nonlinearName(const NonlinearSolver& s)
{
  switch (s) {
    case NonlinearSolver::Newton:
      return "Newton";
    case NonlinearSolver::LBFGS:
      return "LBFGS";
    case NonlinearSolver::NewtonLineSearch:
      return "NewtonLineSearch";
    case NonlinearSolver::TrustRegion:
      return "TrustRegion";
    case NonlinearSolver::KINFullStep:
      return "KINFullStep";
    case NonlinearSolver::KINBacktrackingLineSearch:
      return "KINBacktrackingLineSearch";
    case NonlinearSolver::KINPicard:
      return "KINPicard";
    case NonlinearSolver::PetscNewton:
      return "PetscNewton";
    case NonlinearSolver::PetscNewtonBacktracking:
      return "PetscNewtonBacktracking";
    case NonlinearSolver::PetscNewtonCriticalPoint:
      return "PetscNewtonCriticalPoint";
    case NonlinearSolver::PetscTrustRegion:
      return "PetscTrustRegion";
  }
  // This cannot happen, but GCC doesn't know that
  return "UNKNOWN";
}
 
inline std::ostream& operator<<(std::ostream& os, NonlinearSolver s) { return os << nonlinearName(s); }
 
inline std::map<std::string, NonlinearSolver> nonlinearSolverMap = {
    {"Newton", NonlinearSolver::Newton},
    {"LBFGS", NonlinearSolver::LBFGS},
    {"NewtonLineSearch", NonlinearSolver::NewtonLineSearch},
    {"TrustRegion", NonlinearSolver::TrustRegion},
    {"KINFullStep", NonlinearSolver::KINFullStep},
    {"KINBacktrackingLineSearch", NonlinearSolver::KINBacktrackingLineSearch},
    {"KINPicard", NonlinearSolver::KINPicard},
    {"PetscNewton", NonlinearSolver::PetscNewton},
    {"PetscNewtonBacktracking", NonlinearSolver::PetscNewtonBacktracking},
    {"PetscNewtonCriticalPoint", NonlinearSolver::PetscNewtonCriticalPoint},
    {"PetscTrustRegion", NonlinearSolver::PetscTrustRegion},
};
 
enum class AMGXSolver
{
  AMG,            
  PCGF,           
  CG,             
  PCG,            
  PBICGSTAB,      
  BICGSTAB,       
  FGMRES,         
  JACOBI_L1,      
  GS,             
  POLYNOMIAL,     
  KPZ_POLYNOMIAL, 
  BLOCK_JACOBI,   
  MULTICOLOR_GS,  
  MULTICOLOR_DILU 
};
 
struct AMGXOptions {
  AMGXSolver solver = AMGXSolver::AMG;
  AMGXSolver smoother = AMGXSolver::JACOBI_L1;
  bool verbose = false;
};
 
enum class PetscPCType
{
  JACOBI,        
  JACOBI_L1,     
  JACOBI_ROWSUM, 
  JACOBI_ROWMAX, 
  PBJACOBI,      
  BJACOBI,       
  LU,            
  ILU,           
  CHOLESKY,      
  SVD,           
  ASM,  
  GASM, 
  GAMG, 
  HMG,  
  NONE, 
};
 
inline std::string petscPCName(const PetscPCType& s)
{
  switch (s) {
    case PetscPCType::JACOBI:
      return "JACOBI";
    case PetscPCType::JACOBI_L1:
      return "JACOBI_L1";
    case PetscPCType::JACOBI_ROWSUM:
      return "JACOBI_ROWSUM";
    case PetscPCType::JACOBI_ROWMAX:
      return "JACOBI_ROWMAX";
    case PetscPCType::PBJACOBI:
      return "PBJACOBI";
    case PetscPCType::BJACOBI:
      return "BJACOBI";
    case PetscPCType::LU:
      return "LU";
    case PetscPCType::ILU:
      return "ILU";
    case PetscPCType::CHOLESKY:
      return "CHOLESKY";
    case PetscPCType::SVD:
      return "SVD";
    case PetscPCType::ASM:
      return "ASM";
    case PetscPCType::GASM:
      return "GASM";
    case PetscPCType::GAMG:
      return "GAMG";
    case PetscPCType::HMG:
      return "HMG";
    case PetscPCType::NONE:
      return "NONE";
  }
  // This cannot happen, but GCC doesn't know that
  return "UNKNOWN";
}
 
inline std::ostream& operator<<(std::ostream& os, PetscPCType s) { return os << petscPCName(s); }
 
// _preconditioners_start
enum class Preconditioner
{
  HypreJacobi,      
  HypreL1Jacobi,    
  HypreGaussSeidel, 
  HypreAMG,         
  HypreILU,         
  AMGX,             
  Petsc,            
  None              
};
// _preconditioners_end
 
inline std::string preconditionerName(Preconditioner p)
{
  switch (p) {
    case Preconditioner::HypreJacobi:
      return "HypreJacobi";
    case Preconditioner::HypreL1Jacobi:
      return "HypreL1Jacobi";
    case Preconditioner::HypreGaussSeidel:
      return "HypreGaussSeidel";
    case Preconditioner::HypreAMG:
      return "HypreAMG";
    case Preconditioner::HypreILU:
      return "HypreILU";
    case Preconditioner::AMGX:
      return "AMGX";
    case Preconditioner::Petsc:
      return "Petsc";
    case Preconditioner::None:
      return "None";
  }
  // This cannot happen, but GCC doesn't know that
  return "UNKNOWN";
}
 
inline std::ostream& operator<<(std::ostream& os, Preconditioner p) { return os << preconditionerName(p); }
 
inline std::map<std::string, Preconditioner> preconditionerMap = {
    {"HypreJacobi", Preconditioner::HypreJacobi},
    {"HypreL1Jacobi", Preconditioner::HypreL1Jacobi},
    {"HypreGaussSeidel", Preconditioner::HypreGaussSeidel},
    {"HypreAMG", Preconditioner::HypreAMG},
    {"HypreILU", Preconditioner::HypreILU},
    {"AMGX", Preconditioner::AMGX},
    {"Petsc", Preconditioner::Petsc},
    {"None", Preconditioner::None},
};
 
// _linear_options_start
struct LinearSolverOptions {
  LinearSolver linear_solver = LinearSolver::GMRES;
 
  Preconditioner preconditioner = Preconditioner::HypreJacobi;
 
  AMGXOptions amgx_options = AMGXOptions{};
 
  PetscPCType petsc_preconditioner = PetscPCType::JACOBI;
 
  double relative_tol = 1.0e-8;
 
  double absolute_tol = 1.0e-12;
 
  int max_iterations = 300;
 
  int print_level = 0;
 
  int preconditioner_print_level = 0;
};
// _linear_options_end
 
enum SubSpaceOptions
{
  NEVER,
  WHEN_INDEFINITE,
  WHEN_INDEFINITE_OR_BOUNDARY,
  ALWAYS
};
 
// _nonlinear_options_start
struct NonlinearSolverOptions {
  NonlinearSolver nonlin_solver = NonlinearSolver::NewtonLineSearch;
 
  double relative_tol = 1.0e-8;
 
  double absolute_tol = 1.0e-12;
 
  int min_iterations = 0;
 
  int max_iterations = 20;
 
  int max_line_search_iterations = 0;
 
  int print_level = 0;
 
  double trust_region_scaling = 0.1;
 
  SubSpaceOptions subspace_option = SubSpaceOptions::NEVER;
 
  int num_leftmost = 1;
 
  bool force_monolithic = false;
};
// _nonlinear_options_end
 
}  // namespace serac
 
// fmt support for serac::NonlinearSolver
namespace axom::fmt {
template <>
struct formatter<serac::NonlinearSolver> : ostream_formatter {
};
 
// fmt support for serac::LinearSolver
template <>
struct formatter<serac::LinearSolver> : ostream_formatter {
};
 
// fmt support for serac::Preconditioner
template <>
struct formatter<serac::Preconditioner> : ostream_formatter {
};
 
// fmt support for serac::PetscPCType
template <>
struct formatter<serac::PetscPCType> : ostream_formatter {
};
}  // namespace axom::fmt