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 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_LINEARALGEBRA_UTILITIES_LINEARSOLVERPARAMETERS_HPP_
#define GEOS_LINEARALGEBRA_UTILITIES_LINEARSOLVERPARAMETERS_HPP_
 
#include "common/format/EnumStrings.hpp"
#include "common/DataTypes.hpp"
 
namespace geos
{
 
struct LinearSolverParameters
{
  enum class SolverType : integer
  {
    direct,        
    cg,            
    gmres,         
    fgmres,        
    bicgstab,      
    richardson,    
    preconditioner 
  };
 
  enum class PreconditionerType : integer
  {
    none,      
    jacobi,    
    l1jacobi,  
    fgs,       
    sgs,       
    l1sgs,     
    chebyshev, 
    iluk,      
    ilut,      
    ick,        
    ict,       
    amg,       
    mgr,       
    block,     
    direct,    
    bgs,       
    multiscale 
  };
 
  integer logLevel = 0;     
  integer dofsPerNode = 1;  
  bool isSymmetric = false; 
  integer stopIfError = 1;  
 
  SolverType solverType = SolverType::direct;          
  PreconditionerType preconditionerType = PreconditionerType::iluk;  
  string hypredriveInputFile;                          
 
  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;             
    integer reuseFactorization = 0;   
  }
  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 Relaxation
  {
    real64 weight = 2.0 / 3.0;        
  }
  relaxation;                         
 
  struct Chebyshev
  {
    integer order = 2;                
    integer eigNumIter = 10;          
  }
  chebyshev;                          
 
  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,          
      iluk,               
      ilut,               
      ick,                
      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;                                         
    integer numCycles = 1;                                          
    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;                                
    integer maxCoarseSize = 9;                                      
    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,                     
      thermalSinglePhaseReservoirFVM,              
      singlePhaseHybridFVM,                        
      singlePhaseReservoirHybridFVM,               
      singlePhasePoromechanics,                    
      thermalSinglePhasePoromechanics,             
      hybridSinglePhasePoromechanics,              
      singlePhasePoromechanicsEmbeddedFractures,   
      singlePhasePoromechanicsConformingFractures, 
      singlePhasePoromechanicsReservoirFVM,        
      thermalSinglePhasePoromechanicsReservoirFVM, 
      compositionalMultiphaseFVM,                  
      compositionalMultiphaseHybridFVM,            
      compositionalMultiphaseReservoirFVM,         
      compositionalMultiphaseReservoirHybridFVM,   
      immiscibleMultiphaseFVM,                     
      reactiveCompositionalMultiphaseOBL,          
      thermalCompositionalMultiphaseFVM,           
      thermalCompositionalMultiphaseReservoirFVM,  
      multiphasePoromechanics,                     
      multiphasePoromechanicsReservoirFVM,         
      thermalMultiphasePoromechanics,              
      hydrofracture,                               
      lagrangianContactMechanics,                  
      augmentedLagrangianContactMechanics,         
      lagrangianContactMechanicsBubbleStab,        
      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;                      
 
  struct Block
  {
    enum class Shape
    {
      Diagonal,            
      UpperTriangular,     
      LowerTriangular,     
      LowerUpperTriangular 
    };
 
    enum class SchurType
    {
      None,                  
      FirstBlockDiagonal,    
      RowsumDiagonalProbing, 
      FirstBlockUserDefined  
    };
 
    enum class Scaling
    {
      None,          
      FrobeniusNorm, 
      UserProvided   
    };
 
    Shape shape = Shape::UpperTriangular;                   
    SchurType schurType = SchurType::RowsumDiagonalProbing; 
    Scaling scaling = Scaling::FrobeniusNorm;               
 
    array1d< LinearSolverParameters const * > subParams;    
    array1d< integer > order;                               
 
    void resize( integer const numBlocks )
    {
      subParams.resize( numBlocks );
      order.resize( numBlocks );
      for( integer i = 0; i < numBlocks; ++i )
      {
        order[i] = i;
      }
    }
  }
  block;             
 
  struct Multiscale
  {
    enum class BasisType
    {
      msrsb,   
    };
 
    // Core parameters
    BasisType basisType = BasisType::msrsb;                     
    string fieldName;                                           
    integer maxLevels = 5;                                      
    integer galerkin = 1;                                       
    real64 droptol = 0.0;                                       
    PreconditionerType coarseType = PreconditionerType::direct; 
    integer separateComponents = false;                         
    string_array boundarySets;                                  
 
    // Debugging/user-display settings
    string label;                                               
    integer debugLevel = 0;                                     
 
    struct Smoother
    {
      PreconditionerType type = PreconditionerType::sgs; 
      AMG::PreOrPost preOrPost = AMG::PreOrPost::both;   
      integer numSweeps = 1;                             
    }
    smoother;                                            
 
    struct Coupled
    {
      integer useBlockSmoother = 1; 
    }
    coupled;                        
 
    struct Coarsening
    {
      enum class PartitionType
      {
        graph,          
        cartesian,      
        semistructured, 
      };
 
      PartitionType partitionType = PartitionType::graph; 
      array1d< real64 > ratio;                            
      globalIndex maxCoarseDof = 0;                       
 
      struct Structured
      {
        integer semicoarsening = 0; 
      }
      structured;                   
 
      struct Graph
      {
        enum class Method
        {
          metis,
          scotch,
        };
 
        Method method = Method::metis; 
        integer minCommonNodes = 3;    
        integer preserveRegions = 0;   
        integer matrixWeights = 0;     
        CRSMatrix< real64, localIndex > const * localMatrix{}; 
 
        struct Metis
        {
          enum class Method
          {
            kway,
            recursive
          };
 
          Method method = Method::kway;    
          integer ufactor = 30;            
          integer seed = 2020;             
        }
        metis;                             
 
        struct Scotch
        {
          // TODO
        } scotch;       
 
      } graph;          
 
    } coarsening;       
 
    struct MsRSB
    {
      enum class SupportType : integer
      {
        layers,
        matching
      };
 
      SupportType support = SupportType::matching; 
 
      integer numLayers       = 3;          
      integer maxIter         = 100;        
      real64 tolerance        = 1e-3;       
      real64 relaxation       = 2.0 / 3.0;  
      integer checkFrequency  = 10;         
      integer updateFrequency = 10;         
    }
    msrsb;                                  
  }
  multiscale;           
};
 
ENUM_STRINGS( LinearSolverParameters::SolverType,
              "direct",
              "cg",
              "gmres",
              "fgmres",
              "bicgstab",
              "richardson",
              "preconditioner" );
 
ENUM_STRINGS( LinearSolverParameters::PreconditionerType,
              "none",
              "jacobi",
              "l1jacobi",
              "fgs",
              "sgs",
              "l1sgs",
              "chebyshev",
              "iluk",
              "ilut",
              "ick",
              "ict",
              "amg",
              "mgr",
              "block",
              "direct",
              "bgs",
              "multiscale" );
 
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",
              "thermalSinglePhaseReservoirFVM",
              "singlePhaseHybridFVM",
              "singlePhaseReservoirHybridFVM",
              "singlePhasePoromechanics",
              "thermalSinglePhasePoromechanics",
              "hybridSinglePhasePoromechanics",
              "singlePhasePoromechanicsEmbeddedFractures",
              "singlePhasePoromechanicsConformingFractures",
              "singlePhasePoromechanicsReservoirFVM",
              "thermalSinglePhasePoromechanicsReservoirFVM",
              "compositionalMultiphaseFVM",
              "compositionalMultiphaseHybridFVM",
              "compositionalMultiphaseReservoirFVM",
              "compositionalMultiphaseReservoirHybridFVM",
              "immiscibleMultiphaseFVM",
              "reactiveCompositionalMultiphaseOBL",
              "thermalCompositionalMultiphaseFVM",
              "thermalCompositionalMultiphaseReservoirFVM",
              "multiphasePoromechanics",
              "multiphasePoromechanicsReservoirFVM",
              "thermalMultiphasePoromechanics",
              "hydrofracture",
              "lagrangianContactMechanics",
              "augmentedLagrangianContactMechanics",
              "lagrangianContactMechanicsBubbleStab",
              "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",
              "iluk",
              "ilut",
              "ick",
              "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" );
 
ENUM_STRINGS( LinearSolverParameters::Block::Shape,
              "D",
              "DU",
              "LD",
              "LDU" );
 
ENUM_STRINGS( LinearSolverParameters::Block::SchurType,
              "none",
              "diagonal",
              "probing",
              "user" );
 
ENUM_STRINGS( LinearSolverParameters::Block::Scaling,
              "none",
              "frobenius",
              "user" );
 
ENUM_STRINGS( LinearSolverParameters::Multiscale::BasisType,
              "msrsb" );
 
ENUM_STRINGS( LinearSolverParameters::Multiscale::Coarsening::PartitionType,
              "graph",
              "cartesian",
              "semistructured" );
 
ENUM_STRINGS( LinearSolverParameters::Multiscale::Coarsening::Graph::Method,
              "metis",
              "scotch" );
 
ENUM_STRINGS( LinearSolverParameters::Multiscale::Coarsening::Graph::Metis::Method,
              "kway",
              "recursive" );
 
ENUM_STRINGS( LinearSolverParameters::Multiscale::MsRSB::SupportType,
              "layers",
              "matching" );
 
} /* namespace geos */
 
#endif /*GEOS_LINEARALGEBRA_UTILITIES_LINEARSOLVERPARAMETERS_HPP_ */