cs_param_sles.h

Go to the documentation of this file.

#ifndef CS_PARAM_SLES_H
#define CS_PARAM_SLES_H
 
/*============================================================================
 * Routines to handle the SLES (Sparse Linear Equation Solver) settings
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2026 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 "alge/cs_param_amg.h"
#include "alge/cs_param_hpddm.h"
#include "alge/cs_param_mumps.h"
#include "base/cs_param_types.h"
 
/*----------------------------------------------------------------------------*/
 
/*============================================================================
 * Macro definitions
 *============================================================================*/
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
typedef struct {
 
  char   *name;        
  int     field_id;    
  int     verbosity;   
  cs_param_solver_class_t    solver_class;  
  cs_param_precond_type_t    precond;       
  cs_param_solver_type_t     solver;        
  bool                       need_flexible; 
  int                        restart;       
  cs_param_amg_type_t        amg_type;      
  cs_param_precond_block_t   precond_block_type;
 
  cs_param_resnorm_type_t    resnorm_type;
 
  bool                       allow_no_op;
 
  bool                       mat_is_sym;
 
  cs_param_convergence_t     cvg_param;
 
  void                      *context_param;
 
} cs_param_sles_t;
 
/*============================================================================
 * Global variables
 *============================================================================*/
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_sles_t *
cs_param_sles_create(int           field_id,
                     const char   *system_name);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_free(cs_param_sles_t  **p_slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_log(cs_param_sles_t   *slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_copy_from(const cs_param_sles_t  *src,
                        cs_param_sles_t        *dst);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_param_sles_set_solver(const char       *keyval,
                         cs_param_sles_t  *slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_param_sles_set_precond(const char       *keyval,
                          cs_param_sles_t  *slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_param_sles_set_solver_class(const char       *keyval,
                               cs_param_sles_t  *slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_param_sles_set_amg_type(const char       *keyval,
                           cs_param_sles_t  *slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_param_sles_set_precond_block_type(const char       *keyval,
                                     cs_param_sles_t  *slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_set_cvg_param(cs_param_sles_t  *slesp,
                            double            rtol,
                            double            atol,
                            double            dtol,
                            int               max_iter);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_amg_inhouse_reset(cs_param_sles_t  *slesp,
                                bool              used_as_solver,
                                bool              used_as_k_cycle);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_amg_inhouse(cs_param_sles_t                *slesp,
                          int                             n_down_iter,
                          cs_param_amg_inhouse_solver_t   down_smoother,
                          int                             down_poly_deg,
                          int                             n_up_iter,
                          cs_param_amg_inhouse_solver_t   up_smoother,
                          int                             up_poly_deg,
                          cs_param_amg_inhouse_solver_t   coarse_solver,
                          int                             coarse_poly_deg,
                          cs_param_amg_inhouse_coarsen_t  coarsen_algo,
                          int                             aggreg_limit);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_amg_inhouse_advanced(cs_param_sles_t  *slesp,
                                   int               max_levels,
                                   cs_gnum_t         min_n_g_rows,
                                   double            p0p1_relax,
                                   int               coarse_max_iter,
                                   double            coarse_rtol_mult);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_boomeramg_reset(cs_param_sles_t  *slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_boomeramg(cs_param_sles_t                    *slesp,
                        int                                 n_down_iter,
                        cs_param_amg_boomer_smoother_t      down_smoother,
                        int                                 n_up_iter,
                        cs_param_amg_boomer_smoother_t      up_smoother,
                        cs_param_amg_boomer_smoother_t      coarse_solver,
                        cs_param_amg_boomer_coarsen_algo_t  coarsen_algo);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_boomeramg_advanced(cs_param_sles_t                   *slesp,
                                 double                             strong_thr,
                                 cs_param_amg_boomer_interp_algo_t  interp_algo,
                                 int                                p_max,
                                 int                                n_agg_lv,
                                 int                                n_agg_paths);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_gamg_reset(cs_param_sles_t  *slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_gamg(cs_param_sles_t                  *slesp,
                   int                               n_down_iter,
                   cs_param_amg_gamg_smoother_t      down_smoother,
                   int                               n_up_iter,
                   cs_param_amg_gamg_smoother_t      up_smoother,
                   cs_param_amg_gamg_coarse_solver_t coarse_solver);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_gamg_advanced(cs_param_sles_t *slesp,
                            double           threshold,
                            int              n_agg_lv,
                            bool             use_sq_grph,
                            int              n_smooth_agg);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_hmg_reset(cs_param_sles_t  *slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_hmg(cs_param_sles_t                   *slesp,
                  int                                n_down_iter,
                  cs_param_amg_gamg_smoother_t       down_smoother,
                  int                                n_up_iter,
                  cs_param_amg_gamg_smoother_t       up_smoother,
                  cs_param_amg_gamg_coarse_solver_t  coarse_solver);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_hmg_advanced(cs_param_sles_t *slesp,
                           bool             use_boomer_coarsening,
                           bool             reuse_interpolation,
                           bool             subspace_coarsening);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_mumps_reset(cs_param_sles_t  *slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_mumps(cs_param_sles_t             *slesp,
                    bool                         is_single,
                    cs_param_mumps_facto_type_t  facto_type);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_mumps_advanced(cs_param_sles_t                *slesp,
                             cs_param_mumps_analysis_algo_t  analysis_algo,
                             int                             block_analysis,
                             bool                            keep_ordering,
                             double                          mem_coef,
                             double                          blr_threshold,
                             int                             ir_steps,
                             cs_param_mumps_memory_usage_t   mem_usage,
                             bool                            advanced_optim);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_hpddm_reset(cs_param_sles_t *slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_hpddm(cs_param_sles_t *slesp,
                    const bool       use_neumann,
                    const int        nb_eigenvector,
                    const int        harmonic_overlap,
                    const double     relative_threshold,
                    const int        p = -1);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_hpddm_advanced(cs_param_sles_t *slesp,
                             const int        min_iter,
                             const int        max_iter,
                             const int        min_harmonic_overlap,
                             const int        max_harmonic_overlap,
                             const int        min_nb_eigenvector,
                             const int        max_nb_eigenvector);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
bool
cs_param_sles_hypre_from_petsc(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_solver_class_t
cs_param_sles_check_class(cs_param_solver_class_t  wanted_class);
 
/*----------------------------------------------------------------------------*/
 
#endif /* CS_PARAM_SLES_H */