cs_param_amg.h

Go to the documentation of this file.

#ifndef __CS_PARAM_AMG_H__
#define __CS_PARAM_AMG_H__
 
/*============================================================================
 * Routines to handle the set of parameters for algebraic multigrids (AMG)
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2024 EDF S.A.
 
  This program is free software; you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
  Foundation; either version 2 of the License, or (at your option) any later
  version.
 
  This program is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  details.
 
  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
  Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
 
/*----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "cs_param_types.h"
 
/*----------------------------------------------------------------------------*/
 
BEGIN_C_DECLS
 
/*============================================================================
 * Macro definitions
 *============================================================================*/
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
typedef enum {
 
  CS_PARAM_AMG_NONE,            
  CS_PARAM_AMG_HYPRE_BOOMER_V,  
  CS_PARAM_AMG_HYPRE_BOOMER_W,  
  CS_PARAM_AMG_INHOUSE_K,       
  CS_PARAM_AMG_INHOUSE_V,       
  CS_PARAM_AMG_PETSC_GAMG_V,    
  CS_PARAM_AMG_PETSC_GAMG_W,    
  CS_PARAM_AMG_PETSC_HMG_V,     
  CS_PARAM_AMG_PETSC_HMG_W,     
  CS_PARAM_N_AMG_TYPES
 
} cs_param_amg_type_t;
 
typedef enum {
 
  CS_PARAM_AMG_BOOMER_COARSEN_FALGOUT = 6,
  CS_PARAM_AMG_BOOMER_COARSEN_PMIS = 8,
  CS_PARAM_AMG_BOOMER_COARSEN_HMIS = 10, /* (default) */
  CS_PARAM_AMG_BOOMER_COARSEN_CGC = 21,
  CS_PARAM_AMG_BOOMER_COARSEN_CGC_E = 22,
 
  CS_PARAM_AMG_BOOMER_N_COARSEN_ALGOS
 
} cs_param_amg_boomer_coarsen_algo_t;
 
typedef enum {
 
  CS_PARAM_AMG_BOOMER_INTERP_HYPERBOLIC = 2,
  CS_PARAM_AMG_BOOMER_INTERP_EXT_PLUS_I_CC = 6, /* (default) Also for GPU */
  CS_PARAM_AMG_BOOMER_INTERP_EXT_PLUS_I = 7,
  CS_PARAM_AMG_BOOMER_INTERP_FF1 = 13,
  CS_PARAM_AMG_BOOMER_INTERP_EXTENDED = 14,     /* Also for GPU */
  CS_PARAM_AMG_BOOMER_INTERP_EXT_PLUS_I_MATRIX = 17,
  CS_PARAM_AMG_BOOMER_INTERP_EXT_PLUS_E_MATRIX = 18,
 
  CS_PARAM_AMG_BOOMER_N_INTERP_ALGOS
 
} cs_param_amg_boomer_interp_algo_t;
 
typedef enum {
 
  CS_PARAM_AMG_BOOMER_JACOBI = 0,
  CS_PARAM_AMG_BOOMER_FORWARD_GS = 3,
  CS_PARAM_AMG_BOOMER_BACKWARD_GS = 4,
  CS_PARAM_AMG_BOOMER_HYBRID_SSOR = 6,
  CS_PARAM_AMG_BOOMER_L1_SGS = 8,
  CS_PARAM_AMG_BOOMER_GAUSS_ELIM = 9,      /* for the coarsest level only */
  CS_PARAM_AMG_BOOMER_BACKWARD_L1_GS = 13, /* (default) */
  CS_PARAM_AMG_BOOMER_FORWARD_L1_GS = 14,  /* (default) */
  CS_PARAM_AMG_BOOMER_CG = 15,
  CS_PARAM_AMG_BOOMER_CHEBYSHEV = 16,
  CS_PARAM_AMG_BOOMER_FCF_JACOBI = 17,
  CS_PARAM_AMG_BOOMER_L1_JACOBI = 18,
 
  CS_PARAM_AMG_BOOMER_N_SMOOTHERS
 
} cs_param_amg_boomer_smoother_t;
 
typedef struct {
 
  /* Read the function \ref _petsc_boomeramg_hook or \ref _hypre_boomeramg_hook
     for more details and read the HYPRE user guide */
 
  double                               strong_threshold;
  cs_param_amg_boomer_coarsen_algo_t   coarsen_algo;
  cs_param_amg_boomer_interp_algo_t    interp_algo;
  int                                  p_max;
  int                                  n_agg_levels;
  int                                  n_agg_paths;
 
  cs_param_amg_boomer_smoother_t       down_smoother;
  cs_param_amg_boomer_smoother_t       up_smoother;
  cs_param_amg_boomer_smoother_t       coarse_solver;
 
  int                                  n_down_iter;
  int                                  n_up_iter;
 
} cs_param_amg_boomer_t;
 
/* GAMG AMG algorithms in PETSc */
/* ---------------------------- */
 
/* List of predefined common smoothers for PETSc (GAMG and HMG) */
 
typedef enum {
 
  CS_PARAM_AMG_GAMG_BACKWARD_GS,
  CS_PARAM_AMG_GAMG_BILU0,
  CS_PARAM_AMG_GAMG_CHEBYSHEV,
  CS_PARAM_AMG_GAMG_FORWARD_GS,
  CS_PARAM_AMG_GAMG_HYBRID_SSOR, // SGS on local rank / Jacobi at interfaces
  CS_PARAM_AMG_GAMG_JACOBI,
  CS_PARAM_AMG_GAMG_L1_JACOBI,
 
  CS_PARAM_AMG_GAMG_N_SMOOTHERS
 
} cs_param_amg_gamg_smoother_t;
 
/* List of predefined common coarse solver for PETSc (GAMG and HMG) */
 
typedef enum {
 
  CS_PARAM_AMG_GAMG_BJACOBI_LU,
  CS_PARAM_AMG_GAMG_CG,
  CS_PARAM_AMG_GAMG_GMRES,
  CS_PARAM_AMG_GAMG_LU,
  CS_PARAM_AMG_GAMG_TFS,
 
  CS_PARAM_AMG_GAMG_N_COARSE_SOLVERS
 
} cs_param_amg_gamg_coarse_solver_t;
 
typedef struct {
 
  // Parameters related to the way to build the different levels
 
  double                             threshold;
  bool                               use_square_graph;
  int                                n_agg_levels;
  int                                n_smooth_agg;
 
  // Parameters related to solvers associated to each level (level 0 is the
  // coarse grid)
 
  int                                n_down_iter;
  cs_param_amg_gamg_smoother_t       down_smoother;
 
  cs_param_amg_gamg_coarse_solver_t  coarse_solver;
 
  int                                n_up_iter;
  cs_param_amg_gamg_smoother_t       up_smoother;
 
} cs_param_amg_gamg_t;
 
typedef struct {
 
  // Parameters related to the way to build the different levels
 
  bool                               use_boomer_coarsening;
  bool                               reuse_interpolation;
  bool                               use_subspace_coarsening;
 
  // Parameters related to solvers associated to each level (level 0 is the
  // coarse grid). This relies on PETSc solvers.
 
  int                                n_down_iter;
  cs_param_amg_gamg_smoother_t       down_smoother;
 
  cs_param_amg_gamg_coarse_solver_t  coarse_solver;
 
  int                                n_up_iter;
  cs_param_amg_gamg_smoother_t       up_smoother;
 
} cs_param_amg_hmg_t;
 
/* In-house AMG algorithms */
/* ----------------------- */
 
 typedef enum {
 
   CS_PARAM_AMG_INHOUSE_FORWARD_GS = 1,   /* smoother only */
   CS_PARAM_AMG_INHOUSE_BACKWARD_GS = 2,  /* smoother only */
 
   CS_PARAM_AMG_INHOUSE_JACOBI = 3,
   CS_PARAM_AMG_INHOUSE_PROCESS_GS = 4,
   CS_PARAM_AMG_INHOUSE_PROCESS_SGS = 5,
 
   CS_PARAM_AMG_INHOUSE_CG = 6,
   CS_PARAM_AMG_INHOUSE_CR3 = 7,
   CS_PARAM_AMG_INHOUSE_GCR = 8,
   CS_PARAM_AMG_INHOUSE_GMRES = 9,
 
   CS_PARAM_AMG_INHOUSE_N_SOLVERS
 
 } cs_param_amg_inhouse_solver_t;
 
 typedef enum {
 
   /* For symmetric positive definite matrices (SPD) */
 
   CS_PARAM_AMG_INHOUSE_COARSEN_SPD_DX = 1 ,  
   CS_PARAM_AMG_INHOUSE_COARSEN_SPD_MX = 2,   
   CS_PARAM_AMG_INHOUSE_COARSEN_SPD_PW = 3 ,  
   CS_PARAM_AMG_INHOUSE_COARSEN_CONV_DIFF_DX = 4,  
   CS_PARAM_AMG_INHOUSE_N_COARSENINGS
 
 } cs_param_amg_inhouse_coarsen_t;
 
typedef struct {
 
  /* Coarsening algorithm */
 
  int                             max_levels;     /* advanced settings */
  cs_gnum_t                       min_n_g_rows;   /* advanced settings */
  double                          p0p1_relax;     /* advanced settings */
 
  int                             aggreg_limit;
  cs_param_amg_inhouse_coarsen_t  coarsen_algo;
 
  /* Down smoother */
 
  int                             n_down_iter;
  cs_param_amg_inhouse_solver_t   down_smoother;
  int                             down_poly_degree;
 
  /* Up smoother */
 
  int                             n_up_iter;
  cs_param_amg_inhouse_solver_t   up_smoother;
  int                             up_poly_degree;
 
  /* Coarse solver */
 
  double                          coarse_rtol_mult; /* advanced settings */
  int                             coarse_max_iter;  /* advanced settings */
  cs_param_amg_inhouse_solver_t   coarse_solver;
  int                             coarse_poly_degree;
 
} cs_param_amg_inhouse_t;
 
/*============================================================================
 * Global variables
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_param_amg_boomer_is_needed(cs_param_solver_type_t   solver,
                              cs_param_precond_type_t  precond,
                              cs_param_amg_type_t      amg)
{
  if (precond == CS_PARAM_PRECOND_AMG || solver == CS_PARAM_SOLVER_AMG)
    if (amg == CS_PARAM_AMG_HYPRE_BOOMER_V ||
        amg == CS_PARAM_AMG_HYPRE_BOOMER_W)
      return true;
 
  return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_param_amg_gamg_is_needed(cs_param_solver_type_t   solver,
                            cs_param_precond_type_t  precond,
                            cs_param_amg_type_t      amg)
{
  if (precond == CS_PARAM_PRECOND_AMG || solver == CS_PARAM_SOLVER_AMG)
    if (amg == CS_PARAM_AMG_PETSC_GAMG_V ||
        amg == CS_PARAM_AMG_PETSC_GAMG_W)
      return true;
 
  return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_param_amg_hmg_is_needed(cs_param_solver_type_t   solver,
                           cs_param_precond_type_t  precond,
                           cs_param_amg_type_t      amg)
{
  if (precond == CS_PARAM_PRECOND_AMG || solver == CS_PARAM_SOLVER_AMG)
    if (amg == CS_PARAM_AMG_PETSC_HMG_V ||
        amg == CS_PARAM_AMG_PETSC_HMG_W)
      return true;
 
  return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_param_amg_inhouse_is_needed(cs_param_solver_type_t   solver,
                               cs_param_precond_type_t  precond,
                               cs_param_amg_type_t      amg)
{
  if (precond == CS_PARAM_PRECOND_AMG || solver == CS_PARAM_SOLVER_AMG)
    if (amg == CS_PARAM_AMG_INHOUSE_K || amg == CS_PARAM_AMG_INHOUSE_V)
      return true;
 
  return false;
}
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_amg_get_type_name(cs_param_amg_type_t  type);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_solver_class_t
cs_param_amg_get_class(cs_param_amg_type_t  amg_type);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_amg_boomer_t *
cs_param_amg_boomer_create(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_amg_boomer_t *
cs_param_amg_boomer_copy(const cs_param_amg_boomer_t  *bamgp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_amg_get_boomer_smoother_name(cs_param_amg_boomer_smoother_t  smoother);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_amg_boomer_log(const char                  *name,
                       const cs_param_amg_boomer_t  *bamgp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_amg_gamg_t *
cs_param_amg_gamg_create(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_amg_gamg_t *
cs_param_amg_gamg_copy(const cs_param_amg_gamg_t  *gamgp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_amg_get_gamg_smoother_name(cs_param_amg_gamg_smoother_t smoother);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_amg_get_gamg_coarse_solver_name
(
 cs_param_amg_gamg_coarse_solver_t  coarse
 );
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_amg_gamg_log(const char                 *name,
                      const cs_param_amg_gamg_t  *gamgp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_amg_hmg_t *
cs_param_amg_hmg_create(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_amg_hmg_t *
cs_param_amg_hmg_copy(const cs_param_amg_hmg_t  *hmgp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_amg_hmg_log(const char                *name,
                     const cs_param_amg_hmg_t  *hmgp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_amg_inhouse_t *
cs_param_amg_inhouse_create(bool  used_as_solver,
                            bool  used_as_k_cycle);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_amg_inhouse_t *
cs_param_amg_inhouse_copy(const cs_param_amg_inhouse_t  *amgp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_amg_get_inhouse_solver_name(cs_param_amg_inhouse_solver_t  solver);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_amg_inhouse_log(const char                    *name,
                         const cs_param_amg_inhouse_t  *amgp);
 
/*----------------------------------------------------------------------------*/
 
END_C_DECLS
 
#endif /* __CS_PARAM_AMG_H__ */