HypreMGR.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_INTERFACES_HYPREMGRSTRATEGIES_HPP_
#define GEOS_LINEARALGEBRA_INTERFACES_HYPREMGRSTRATEGIES_HPP_
 
#include "linearAlgebra/common/common.hpp"
 
#include "linearAlgebra/DofManager.hpp"
#include "linearAlgebra/interfaces/hypre/HypreUtils.hpp"
#include "linearAlgebra/utilities/LinearSolverParameters.hpp"
 
#include <_hypre_utilities.h>
 
namespace geos
{
 
struct HypreMGRData
{
  array1d< HYPRE_Int > pointMarkers;  
  HyprePrecWrapper coarseSolver;      
  HyprePrecWrapper mechSolver;        
  HyprePrecWrapper iluSolver;         
  HyprePrecWrapper nestedSolver;      
};
 
namespace hypre
{
 
namespace mgr
{
 
struct MGRParameters
{
  HYPRE_Real tolerance{ 0.0 };
  HYPRE_Int maxIterations{ 1 };
  HYPRE_Int printLevel{ 0 };
  HYPRE_Int cycleType{ 1 };
  HYPRE_Int fRelaxCycle{ 1 };
  HYPRE_Int globalSmoothCycle{ 1 };
  HYPRE_Int nonCpointsToFpoints{ 1 };
  HYPRE_Int nonGalerkinMaxElmts{ 1 };
  HYPRE_Int pMaxElmts{ 0 };
};
 
inline MGRParameters defaultMGRParameters()
{
  return {};
}
 
HYPRE_Int constexpr hydrofractureMinCoarseSize = 1000;
 
inline void setMGRCycleSettings( HYPRE_Solver const solver,
                                 MGRParameters const & params = defaultMGRParameters() )
{
  GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetCycleType( solver, params.cycleType ) );
  GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetFRelaxCycle( solver, params.fRelaxCycle ) );
  GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetGlobalSmoothCycle( solver, params.globalSmoothCycle ) );
}
 
struct BoomerAMGParameters
{
  HYPRE_Real tolerance{ 0.0 };
  HYPRE_Int maxIterations{ 1 };
  HYPRE_Int printLevel{ 0 };
  HYPRE_Int minCoarseSize{ -1 };
  HYPRE_Int maxCoarseSize{ 9 };
  HYPRE_Int smoothType{ 6 };
  HYPRE_Int smoothNumLevels{ 0 };
  HYPRE_Int smoothNumSweeps{ 1 };
  HYPRE_Int smoothMaxRowNnz{ 20 };
  HYPRE_Int iluLocalReordering{ 0 };
 
  HYPRE_Real maxRowSum{ -1.0 };
  HYPRE_Real strongThreshold{ -1.0 };
  HYPRE_Int numFunctions{ -1 };
  HYPRE_Int filterFunctions{ -1 };
  HYPRE_Int pMaxElmts{ -1 };
 
  HYPRE_Int aggressiveNumLevels{ -1 };
  HYPRE_Int aggressiveInterpType{ -1 };
  HYPRE_Int aggressivePMaxElmts{ -1 };
  HYPRE_Int coarseningType{ -1 };
 
  HYPRE_Int relaxType{ -1 };
  HYPRE_Int downRelaxType{ -1 };
  HYPRE_Int upRelaxType{ -1 };
  HYPRE_Int coarseRelaxType{ -1 };
  HYPRE_Int numSweeps{ -1 };
  HYPRE_Int relaxOrder{ -1 };
};
 
inline BoomerAMGParameters displacementAMGParameters( integer const separateComponents,
                                                      bool const filterFunctions,
                                                      bool const useALMSmoother = false )
{
  BoomerAMGParameters result;
  result.maxRowSum = 1.0;
  result.strongThreshold = useALMSmoother ? 0.8 : 0.6;
  result.numFunctions = 3;
  result.filterFunctions = filterFunctions ? separateComponents : 0;
 
  if( useALMSmoother )
  {
    result.pMaxElmts = 20;
    result.aggressiveNumLevels = 1;
#if GEOS_USE_HYPRE_DEVICE != GEOS_USE_HYPRE_CUDA && GEOS_USE_HYPRE_DEVICE != GEOS_USE_HYPRE_HIP
    result.coarseningType = hypre::getAMGCoarseningType( LinearSolverParameters::AMG::CoarseningType::Falgout );
#endif
  }
 
#if GEOS_USE_HYPRE_DEVICE == GEOS_USE_HYPRE_CUDA || GEOS_USE_HYPRE_DEVICE == GEOS_USE_HYPRE_HIP
  result.coarseningType = hypre::getAMGCoarseningType( LinearSolverParameters::AMG::CoarseningType::PMIS );
  result.relaxType = hypre::getAMGRelaxationType( LinearSolverParameters::AMG::SmootherType::chebyshev );
  result.numSweeps = useALMSmoother ? 2 : 1;
#else
  if( useALMSmoother )
  {
    result.downRelaxType = 89;
    result.upRelaxType = 89;
    result.coarseRelaxType = 9;
    result.numSweeps = 2;
    result.relaxOrder = 0;
  }
  else
  {
    result.relaxOrder = 1;
  }
#endif
 
  return result;
}
 
inline BoomerAMGParameters almBubbleAMGParameters()
{
  BoomerAMGParameters result = displacementAMGParameters( 0, false, true );
  result.strongThreshold = 0.75;
  result.filterFunctions = 0;
  result.pMaxElmts = 10;
  result.aggressiveNumLevels = -1;
#if GEOS_USE_HYPRE_DEVICE == GEOS_USE_HYPRE_CUDA || GEOS_USE_HYPRE_DEVICE == GEOS_USE_HYPRE_HIP
  result.coarseningType = hypre::getAMGCoarseningType( LinearSolverParameters::AMG::CoarseningType::PMIS );
#else
  result.coarseningType = -1;
#endif
  result.numSweeps = 1;
  return result;
}
 
inline BoomerAMGParameters almReservoirDisplacementAMGParameters( integer const separateComponents )
{
  BoomerAMGParameters result = displacementAMGParameters( separateComponents, true );
#if GEOS_USE_HYPRE_DEVICE != GEOS_USE_HYPRE_CUDA && GEOS_USE_HYPRE_DEVICE != GEOS_USE_HYPRE_HIP
  result.downRelaxType = 89;
  result.upRelaxType = 89;
  result.coarseRelaxType = 9;
  result.numSweeps = 1;
  result.relaxOrder = 0;
#endif
  return result;
}
 
inline BoomerAMGParameters pressureAMGParameters( HYPRE_Int const minCoarseSize = -1 )
{
  BoomerAMGParameters result;
  result.minCoarseSize = minCoarseSize;
  result.aggressiveNumLevels = 1;
  result.aggressivePMaxElmts = 20;
  result.aggressiveInterpType = hypre::getAMGAggressiveInterpolationType( LinearSolverParameters::AMG::AggInterpType::multipass );
 
#if GEOS_USE_HYPRE_DEVICE == GEOS_USE_HYPRE_CUDA || GEOS_USE_HYPRE_DEVICE == GEOS_USE_HYPRE_HIP
  result.aggressiveInterpType = hypre::getAMGAggressiveInterpolationType( LinearSolverParameters::AMG::AggInterpType::modifiedExtendedE );
  result.coarseningType = hypre::getAMGCoarseningType( LinearSolverParameters::AMG::CoarseningType::PMIS );
  result.maxRowSum = 1.0;
  result.relaxType = hypre::getAMGRelaxationType( LinearSolverParameters::AMG::SmootherType::l1jacobi );
  result.numSweeps = 2;
#else
  result.relaxOrder = 1;
#endif
 
  return result;
}
 
inline BoomerAMGParameters pressureTemperatureAMGParameters()
{
  BoomerAMGParameters result;
  result.aggressiveNumLevels = 1;
  result.aggressivePMaxElmts = 16;
  result.numFunctions = 2;
 
#if GEOS_USE_HYPRE_DEVICE == GEOS_USE_HYPRE_CUDA || GEOS_USE_HYPRE_DEVICE == GEOS_USE_HYPRE_HIP
  result.aggressiveNumLevels = 0;
  result.coarseningType = hypre::getAMGCoarseningType( LinearSolverParameters::AMG::CoarseningType::PMIS );
  result.maxRowSum = 1.0;
  result.relaxType = hypre::getAMGRelaxationType( LinearSolverParameters::AMG::SmootherType::l1jacobi );
  result.numSweeps = 2;
#else
  result.relaxOrder = 1;
#endif
 
  return result;
}
 
inline void configureBoomerAMG( HyprePrecWrapper & solver,
                                BoomerAMGParameters const & params )
{
  GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGCreate( &solver.ptr ) );
  GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetILULocalReordering( solver.ptr, params.iluLocalReordering ) );
  GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetILUMaxRowNnz( solver.ptr, params.smoothMaxRowNnz ) );
  GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetTol( solver.ptr, params.tolerance ) );
  GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetMaxIter( solver.ptr, params.maxIterations ) );
  GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetPrintLevel( solver.ptr, params.printLevel ) );
  if( params.minCoarseSize >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetMinCoarseSize( solver.ptr, params.minCoarseSize ) );
  }
  GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetMaxCoarseSize( solver.ptr, params.maxCoarseSize ) );
  GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetSmoothType( solver.ptr, params.smoothType ) );
  GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetSmoothNumLevels( solver.ptr, params.smoothNumLevels ) );
  GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetSmoothNumSweeps( solver.ptr, params.smoothNumSweeps ) );
 
  if( params.maxRowSum >= 0.0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetMaxRowSum( solver.ptr, params.maxRowSum ) );
  }
  if( params.strongThreshold >= 0.0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetStrongThreshold( solver.ptr, params.strongThreshold ) );
  }
  if( params.numFunctions >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetNumFunctions( solver.ptr, params.numFunctions ) );
  }
  if( params.filterFunctions >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetFilterFunctions( solver.ptr, params.filterFunctions ) );
  }
  if( params.pMaxElmts >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetPMaxElmts( solver.ptr, params.pMaxElmts ) );
  }
  if( params.aggressiveNumLevels >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetAggNumLevels( solver.ptr, params.aggressiveNumLevels ) );
  }
  if( params.aggressiveInterpType >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetAggInterpType( solver.ptr, params.aggressiveInterpType ) );
  }
  if( params.aggressivePMaxElmts >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetAggPMaxElmts( solver.ptr, params.aggressivePMaxElmts ) );
  }
  if( params.coarseningType >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetCoarsenType( solver.ptr, params.coarseningType ) );
  }
  if( params.relaxType >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetRelaxType( solver.ptr, params.relaxType ) );
  }
  if( params.numSweeps >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetNumSweeps( solver.ptr, params.numSweeps ) );
  }
  if( params.relaxOrder >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetRelaxOrder( solver.ptr, params.relaxOrder ) );
  }
  if( params.downRelaxType >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetCycleRelaxType( solver.ptr, params.downRelaxType, 1 ) );
  }
  if( params.upRelaxType >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetCycleRelaxType( solver.ptr, params.upRelaxType, 2 ) );
  }
  if( params.coarseRelaxType >= 0 )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_BoomerAMGSetCycleRelaxType( solver.ptr, params.coarseRelaxType, 3 ) );
  }
}
 
template< typename STRATEGY >
void setStrategy( LinearSolverParameters::MGR const & params,
                  arrayView1d< int const > const & numComponentsPerField,
                  HyprePrecWrapper & precond,
                  HypreMGRData & mgrData )
{
  STRATEGY strategy( numComponentsPerField );
  strategy.setup( params, precond, mgrData );
}
 
template< int NLEVEL >
class MGRStrategyBase
{
public:
 
  static constexpr HYPRE_Int numLevels = NLEVEL;              
 
protected:
 
  HYPRE_Int m_numBlocks{ 0 };                                 
 
  stdVector< HYPRE_Int > m_labels[numLevels]{};             
  HYPRE_Int m_numLabels[numLevels]{ -1 };                     
  HYPRE_Int * m_ptrLabels[numLevels]{ nullptr };              
 
  MGRFRelaxationType m_levelFRelaxType[numLevels];            
  HYPRE_Int m_levelFRelaxIters[numLevels]{ -1 };              
  MGRInterpolationType m_levelInterpType[numLevels];          
  MGRRestrictionType m_levelRestrictType[numLevels];          
  MGRCoarseGridMethod m_levelCoarseGridMethod[numLevels];     
  MGRGlobalSmootherType m_levelGlobalSmootherType[numLevels]; 
  HYPRE_Int m_levelGlobalSmootherIters[numLevels]{ -1 };      
  HYPRE_Real m_coarseGridThreshold{ 1.0e-20 };                
 
  // TODO: the following options are currently commented out in MGR's code.
  //       Let's consider their use when re-enable in hypre
  // HYPRE_Int m_numRestrictSweeps{ -1 }; ///< Number of restrict sweeps
  // HYPRE_Int m_numInterpSweeps{ -1 };   ///< Number of interpolation sweeps
 
  static HYPRE_Int totalNumBlocks( arrayView1d< int const > const & numComponentsPerField )
  {
    HYPRE_Int result = 0;
    for( localIndex i = 0; i < numComponentsPerField.size(); ++i )
    {
      result += LvArray::integerConversion< HYPRE_Int >( numComponentsPerField[i] );
    }
    return result;
  }
 
  explicit MGRStrategyBase( HYPRE_Int const numBlocks )
    : m_numBlocks( numBlocks )
  {
    for( HYPRE_Int i = 0; i < numLevels; ++i )
    {
      m_levelFRelaxType[i]         = MGRFRelaxationType::jacobi;
      m_levelInterpType[i]         = MGRInterpolationType::jacobi;
      m_levelRestrictType[i]       = MGRRestrictionType::injection;
      m_levelCoarseGridMethod[i]   = MGRCoarseGridMethod::galerkin;
      m_levelGlobalSmootherType[i] = MGRGlobalSmootherType::none;
    }
  }
 
  void setupLabels()
  {
    for( HYPRE_Int i = 0; i < numLevels; ++i )
    {
      m_numLabels[i] = m_labels[i].size();
      m_ptrLabels[i] = m_labels[i].data();
    }
  }
 
  void setReduction( HyprePrecWrapper & precond,
                     HypreMGRData & mgrData )
 
  {
    normalizeReductionParameters();
    MGRParameters const mgrParameters = defaultMGRParameters();
 
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetCpointsByPointMarkerArray( precond.ptr,
                                                                 m_numBlocks, numLevels,
                                                                 m_numLabels, m_ptrLabels,
                                                                 mgrData.pointMarkers.data() ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetLevelFRelaxType( precond.ptr, toUnderlyingPtr( m_levelFRelaxType ) ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetLevelNumRelaxSweeps( precond.ptr, m_levelFRelaxIters ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetLevelInterpType( precond.ptr, toUnderlyingPtr( m_levelInterpType ) ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetLevelRestrictType( precond.ptr, toUnderlyingPtr( m_levelRestrictType ) ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetCoarseGridMethod( precond.ptr, toUnderlyingPtr( m_levelCoarseGridMethod ) ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetLevelSmoothType( precond.ptr, toUnderlyingPtr( m_levelGlobalSmootherType ) ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetLevelSmoothIters( precond.ptr, m_levelGlobalSmootherIters ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetTruncateCoarseGridThreshold( precond.ptr, m_coarseGridThreshold ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetNonCpointsToFpoints( precond.ptr, mgrParameters.nonCpointsToFpoints ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetNonGalerkinMaxElmts( precond.ptr, mgrParameters.nonGalerkinMaxElmts ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetPMaxElmts( precond.ptr, mgrParameters.pMaxElmts ) );
  }
 
public:
  void configure( LinearSolverParameters::MGR const & )
  {}
 
  void normalizeReductionParameters()
  {
    // Ensure that if no F-relaxation or global smoothing is chosen the corresponding number
    // of iteration is set to 0
    for( HYPRE_Int i = 0; i < numLevels; ++i )
    {
      if( m_levelFRelaxType[i] == MGRFRelaxationType::none )
      {
        m_levelFRelaxIters[i] = 0;
      }
      if( m_levelGlobalSmootherType[i] == MGRGlobalSmootherType::none )
      {
        m_levelGlobalSmootherIters[i] = 0;
      }
    }
  }
 
protected:
 
  void setDisplacementAMG( HyprePrecWrapper & solver,
                           integer const & separateComponents )
  {
    configureBoomerAMG( solver, displacementAMGParameters( separateComponents, true ) );
 
    solver.setup = HYPRE_BoomerAMGSetup;
    solver.solve = HYPRE_BoomerAMGSolve;
    solver.destroy = HYPRE_BoomerAMGDestroy;
  }
 
  void setALMDisplacementAMG( HyprePrecWrapper & solver,
                              integer const separateComponents,
                              bool const bubbleCoarse )
  {
    configureBoomerAMG( solver, bubbleCoarse
                        ? almBubbleAMGParameters()
                        : displacementAMGParameters( separateComponents, true, true ) );
 
    solver.setup = HYPRE_BoomerAMGSetup;
    solver.solve = HYPRE_BoomerAMGSolve;
    solver.destroy = HYPRE_BoomerAMGDestroy;
  }
 
  void setALMReservoirDisplacementAMG( HyprePrecWrapper & solver,
                                       integer const separateComponents )
  {
    configureBoomerAMG( solver, almReservoirDisplacementAMGParameters( separateComponents ) );
 
    solver.setup = HYPRE_BoomerAMGSetup;
    solver.solve = HYPRE_BoomerAMGSolve;
    solver.destroy = HYPRE_BoomerAMGDestroy;
  }
 
  void setPressureAMG( HyprePrecWrapper & solver,
                       HYPRE_Int const minCoarseSize = -1 )
  {
    configureBoomerAMG( solver, pressureAMGParameters( minCoarseSize ) );
 
    solver.setup = HYPRE_BoomerAMGSetup;
    solver.solve = HYPRE_BoomerAMGSolve;
    solver.destroy = HYPRE_BoomerAMGDestroy;
  }
 
  void setPressureTemperatureAMG( HyprePrecWrapper & solver )
  {
    configureBoomerAMG( solver, pressureTemperatureAMGParameters() );
 
    solver.setup = HYPRE_BoomerAMGSetup;
    solver.solve = HYPRE_BoomerAMGSolve;
    solver.destroy = HYPRE_BoomerAMGDestroy;
  }
 
  void setMechanicsFSolver( HyprePrecWrapper & precond,
                            HypreMGRData & mgrData,
                            integer const & separateComponents )
  {
    setDisplacementAMG( mgrData.mechSolver, separateComponents );
    HYPRE_MGRSetFSolver( precond.ptr, mgrData.mechSolver.solve, mgrData.mechSolver.setup, mgrData.mechSolver.ptr );
  }
 
  void setMechanicsFSolverAtLevel( HyprePrecWrapper & precond,
                                   HypreMGRData & mgrData,
                                   integer const & separateComponents,
                                   HYPRE_Int const level )
  {
    setDisplacementAMG( mgrData.mechSolver, separateComponents );
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetFSolverAtLevel( precond.ptr, mgrData.mechSolver.ptr, level ) );
  }
  void setILUFSolverAtLevel( HYPRE_Int const level,
                             HyprePrecWrapper & precond,
                             HypreMGRData & mgrData )
  {
    GEOS_LAI_CHECK_ERROR( HYPRE_ILUCreate( &mgrData.iluSolver.ptr ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_ILUSetType( mgrData.iluSolver.ptr, 0 ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_ILUSetLevelOfFill( mgrData.iluSolver.ptr, 0 ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_ILUSetMaxIter( mgrData.iluSolver.ptr, 1 ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_ILUSetTol( mgrData.iluSolver.ptr, 0.0 ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_ILUSetLocalReordering( mgrData.iluSolver.ptr, 0 ) );
    GEOS_LAI_CHECK_ERROR( HYPRE_ILUSetPrintLevel( mgrData.iluSolver.ptr, 0 ) );
 
    mgrData.iluSolver.setup = HYPRE_ILUSetup;
    mgrData.iluSolver.solve = HYPRE_ILUSolve;
    mgrData.iluSolver.destroy = HYPRE_ILUDestroy;
 
    GEOS_LAI_CHECK_ERROR( HYPRE_MGRSetFSolverAtLevel( precond.ptr, mgrData.iluSolver.ptr, level ) );
  }
 
  void setILUCoarseSolver( HyprePrecWrapper & solver )
  {
    /* (Required) Create ILU solver */
    HYPRE_ILUCreate( &solver.ptr );
 
    /* (Recommended) General solver options */
    int const ilu_type = 0; /* 0, 1, 10, 11, 20, 21, 30, 31, 40, 41, 50 */
    int const max_iter = 1;
    double const tol = 0.0;
    int const reordering = 0; /* 0: none, 1: RCM */
    int const print_level = 0;
    HYPRE_ILUSetType( solver.ptr, ilu_type );
    HYPRE_ILUSetMaxIter( solver.ptr, max_iter );
    HYPRE_ILUSetTol( solver.ptr, tol );
    HYPRE_ILUSetLocalReordering( solver.ptr, reordering );
    HYPRE_ILUSetPrintLevel( solver.ptr, print_level );
 
    solver.setup = HYPRE_ILUSetup;
    solver.solve = HYPRE_ILUSolve;
    solver.destroy = HYPRE_ILUDestroy;
  }
 
};
 
void createMGR( LinearSolverParameters const & params,
                DofManager const * const dofManager,
                HyprePrecWrapper & precond,
                HypreMGRData & mgrData );
 
} // namespace mgr
 
} // namespace hypre
 
} // namespace geos
 
#endif /*GEOS_LINEARALGEBRA_INTERFACES_HYPREMGRSTRATEGIES_HPP_*/