LinearSolverParameters.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 Total, S.A
 * 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_LINEARALGEBRA_UTILITIES_LINEARSOLVERPARAMETERS_HPP_
#define GEOS_LINEARALGEBRA_UTILITIES_LINEARSOLVERPARAMETERS_HPP_
 
#include "common/format/EnumStrings.hpp"
 
namespace geos
{
 
struct LinearSolverParameters
{
  enum class SolverType : integer
  {
    direct,        
    cg,            
    gmres,         
    fgmres,        
    bicgstab,      
    preconditioner 
  };
 
  enum class PreconditionerType : integer
  {
    none,      
    jacobi,    
    l1jacobi,  
    fgs,       
    sgs,       
    l1sgs,     
    chebyshev, 
    iluk,      
    ilut,      
    ic,        
    ict,       
    amg,       
    mgr,       
    block,     
    direct,    
    bgs,       
  };
 
  integer logLevel = 0;     
  integer dofsPerNode = 1;  
  bool isSymmetric = false; 
  integer stopIfError = 1;  
 
  SolverType solverType = SolverType::direct;          
  PreconditionerType preconditionerType = PreconditionerType::iluk;  
 
  struct Direct
  {
    enum class ColPerm : integer
    {
      none,        
      MMD_AtplusA, 
      MMD_AtA,     
      colAMD,      
      metis,       
      parmetis     
    };
 
    enum class RowPerm : integer
    {
      none, 
      mc64  
    };
 
    integer checkResidual = 0;        
    integer equilibrate = 1;          
    ColPerm colPerm = ColPerm::metis; 
    RowPerm rowPerm = RowPerm::mc64;  
    integer replaceTinyPivot = 1;     
    integer iterativeRefine = 1;      
    integer parallel = 1;             
  }
  direct;                             
 
  struct Krylov
  {
    real64 relTolerance = 1e-6;       
    integer maxIterations = 200;      
#if GEOS_USE_HYPRE_DEVICE == GEOS_USE_HYPRE_CUDA || GEOS_USE_HYPRE_DEVICE == GEOS_USE_HYPRE_HIP
    integer maxRestart = 100;         
#else
    integer maxRestart = 200;         
#endif
    integer useAdaptiveTol = false;   
    real64 weakestTol = 1e-3;         
    real64 strongestTol = 1e-8;       
    real64 adaptiveGamma = 0.1;       
    real64 adaptiveExponent = 1.0;    
  }
  krylov;                             
 
  struct Scaling
  {
    integer useRowScaling = false;    
    integer useRowColScaling = false; 
  }
  scaling;                            
 
  struct AMG
  {
    enum class CycleType : integer
    {
      V,                  
      W                   
    };
 
    enum class PreOrPost : integer
    {
      pre,                
      post,               
      both                
    };
 
    enum class SmootherType : integer
    {
      default_,           
      jacobi,             
      l1jacobi,           
      fgs,                
      bgs,                
      sgs,                
      l1sgs,              
      chebyshev,          
      ilu0,               
      ilut,               
      ic0,                
      ict                 
    };
 
    enum class CoarseType : integer
    {
      default_,           
      jacobi,             
      l1jacobi,           
      fgs,                
      sgs,                
      l1sgs,              
      chebyshev,          
      direct,             
      bgs,                
      gsElimWPivoting,    
      gsElimWInverse      
    };
 
    enum class CoarseningType : integer
    {
      default_,           
      CLJP,               
      RugeStueben,        
      Falgout,            
      PMIS,               
      HMIS                
    };
 
    enum class InterpType : integer
    {
      default_,           
      modifiedClassical,  
      direct,             
      multipass,          
      extendedI,          
      standard,           
      extended,           
      directBAMG,         
      modifiedExtended,   
      modifiedExtendedI,  
      modifiedExtendedE   
    };
 
    enum class AggInterpType : integer
    {
      default_,           
      extendedIStage2,    
      standardStage2,     
      extendedStage2,     
      multipass,          
      modifiedExtended,   
      modifiedExtendedI,  
      modifiedExtendedE,  
      modifiedMultipass   
    };
 
    enum class NullSpaceType : integer
    {
      constantModes,      
      rigidBodyModes      
    };
 
#if GEOS_USE_HYPRE_DEVICE == GEOS_USE_HYPRE_CUDA || GEOS_USE_HYPRE_DEVICE == GEOS_USE_HYPRE_HIP
    CoarseningType coarseningType = CoarseningType::PMIS;           
    SmootherType smootherType = SmootherType::l1jacobi;             
#else
    CoarseningType coarseningType = CoarseningType::HMIS;           
    SmootherType smootherType = SmootherType::l1sgs;                
#endif
 
    integer maxLevels = 20;                                         
    CycleType cycleType = CycleType::V;                             
    CoarseType coarseType = CoarseType::direct;                     
    InterpType interpolationType = InterpType::extendedI;           
    integer interpolationMaxNonZeros = 4;                           
    real64 relaxWeight = 1.0;                                       
    integer numSweeps = 1;                                          
    integer numFunctions = 1;                                       
    integer aggressiveNumPaths = 1;                                 
    integer aggressiveNumLevels = 0;                                
    AggInterpType aggressiveInterpType = AggInterpType::multipass;  
    integer aggressiveInterpMaxNonZeros = 16;                       
    PreOrPost preOrPostSmoothing = PreOrPost::both;                 
    real64 threshold = 0.0;                                         
    integer separateComponents = false;                             
    NullSpaceType nullSpaceType = NullSpaceType::constantModes;     
  }
  amg;                                                              
 
  struct MGR
  {
    enum class StrategyType : integer
    {
      invalid,                                   
      singlePhaseReservoirFVM,                   
      singlePhaseHybridFVM,                      
      singlePhaseReservoirHybridFVM,             
      singlePhasePoromechanics,                  
      thermalSinglePhasePoromechanics,           
      hybridSinglePhasePoromechanics,            
      singlePhasePoromechanicsEmbeddedFractures, 
      singlePhasePoromechanicsConformingFractures, 
      singlePhasePoromechanicsReservoirFVM,      
      compositionalMultiphaseFVM,                
      compositionalMultiphaseHybridFVM,          
      compositionalMultiphaseReservoirFVM,       
      compositionalMultiphaseReservoirHybridFVM, 
      reactiveCompositionalMultiphaseOBL,        
      thermalCompositionalMultiphaseFVM,         
      thermalCompositionalMultiphaseReservoirFVM,
      multiphasePoromechanics,                   
      multiphasePoromechanicsReservoirFVM,       
      thermalMultiphasePoromechanics,            
      hydrofracture,                             
      lagrangianContactMechanics,                
      solidMechanicsEmbeddedFractures            
    };
 
    StrategyType strategy = StrategyType::invalid; 
    integer separateComponents = false;            
    integer areWellsShut = false;                  
  }
  mgr;                                             
 
  struct IFact
  {
    integer fill = 0;        
    real64 threshold = 0.0;  
  }
  ifact;                       
 
  struct DD
  {
    integer overlap = 0;   
  }
  dd;                      
};
 
ENUM_STRINGS( LinearSolverParameters::SolverType,
              "direct",
              "cg",
              "gmres",
              "fgmres",
              "bicgstab",
              "preconditioner" );
 
ENUM_STRINGS( LinearSolverParameters::PreconditionerType,
              "none",
              "jacobi",
              "l1jacobi",
              "fgs",
              "sgs",
              "l1sgs",
              "chebyshev",
              "iluk",
              "ilut",
              "icc",
              "ict",
              "amg",
              "mgr",
              "block",
              "direct",
              "bgs" );
 
ENUM_STRINGS( LinearSolverParameters::Direct::ColPerm,
              "none",
              "MMD_AtplusA",
              "MMD_AtA",
              "colAMD",
              "metis",
              "parmetis" );
 
ENUM_STRINGS( LinearSolverParameters::Direct::RowPerm,
              "none",
              "mc64" );
 
ENUM_STRINGS( LinearSolverParameters::MGR::StrategyType,
              "invalid",
              "singlePhaseReservoirFVM",
              "singlePhaseHybridFVM",
              "singlePhaseReservoirHybridFVM",
              "singlePhasePoromechanics",
              "thermalSinglePhasePoromechanics",
              "hybridSinglePhasePoromechanics",
              "singlePhasePoromechanicsEmbeddedFractures",
              "singlePhasePoromechanicsConformingFractures",
              "singlePhasePoromechanicsReservoirFVM",
              "compositionalMultiphaseFVM",
              "compositionalMultiphaseHybridFVM",
              "compositionalMultiphaseReservoirFVM",
              "compositionalMultiphaseReservoirHybridFVM",
              "reactiveCompositionalMultiphaseOBL",
              "thermalCompositionalMultiphaseFVM",
              "thermalCompositionalMultiphaseReservoirFVM",
              "multiphasePoromechanics",
              "multiphasePoromechanicsReservoirFVM",
              "thermalMultiphasePoromechanics",
              "hydrofracture",
              "lagrangianContactMechanics",
              "solidMechanicsEmbeddedFractures" );
 
ENUM_STRINGS( LinearSolverParameters::AMG::CycleType,
              "V",
              "W" );
 
ENUM_STRINGS( LinearSolverParameters::AMG::PreOrPost,
              "pre",
              "post",
              "both" );
 
ENUM_STRINGS( LinearSolverParameters::AMG::SmootherType,
              "default",
              "jacobi",
              "l1jacobi",
              "fgs",
              "bgs",
              "sgs",
              "l1sgs",
              "chebyshev",
              "ilu0",
              "ilut",
              "ic0",
              "ict" );
 
ENUM_STRINGS( LinearSolverParameters::AMG::CoarseType,
              "default",
              "jacobi",
              "l1jacobi",
              "fgs",
              "sgs",
              "l1sgs",
              "chebyshev",
              "direct",
              "bgs",
              "gsElimWPivoting",
              "gsElimWInverse" );
 
ENUM_STRINGS( LinearSolverParameters::AMG::CoarseningType,
              "default",
              "CLJP",
              "RugeStueben",
              "Falgout",
              "PMIS",
              "HMIS" );
 
ENUM_STRINGS( LinearSolverParameters::AMG::InterpType,
              "default",
              "modifiedClassical",
              "direct",
              "multipass",
              "extendedI",
              "standard",
              "extended",
              "directBAMG",
              "modifiedExtended",
              "modifiedExtendedI",
              "modifiedExtendedE" );
 
ENUM_STRINGS( LinearSolverParameters::AMG::AggInterpType,
              "default",
              "extendedIStage2",
              "standardStage2",
              "extendedStage2",
              "multipass",
              "modifiedExtended",
              "modifiedExtendedI",
              "modifiedExtendedE",
              "modifiedMultipass" );
 
ENUM_STRINGS( LinearSolverParameters::AMG::NullSpaceType,
              "constantModes",
              "rigidBodyModes" );
 
} /* namespace geos */
 
#endif /*GEOS_LINEARALGEBRA_UTILITIES_LINEARSOLVERPARAMETERS_HPP_ */