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 settings
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2023 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 struct {
 
  double               atol;
  double               rtol;
  double               dtol;
  int                  n_max_iter;
 
} cs_param_sles_cvg_t;
 
typedef enum {
 
  CS_PARAM_SLES_FACTO_LU,
  CS_PARAM_SLES_FACTO_LDLT_SYM,
  CS_PARAM_SLES_FACTO_LDLT_SPD,
 
  CS_PARAM_SLES_N_FACTO_TYPES
 
} cs_param_sles_facto_type_t;
 
typedef enum {
 
  CS_PARAM_SLES_ANALYSIS_AMD,
  CS_PARAM_SLES_ANALYSIS_QAMD,
  CS_PARAM_SLES_ANALYSIS_PORD,
  CS_PARAM_SLES_ANALYSIS_SCOTCH,
  CS_PARAM_SLES_ANALYSIS_PTSCOTCH,
  CS_PARAM_SLES_ANALYSIS_METIS,
  CS_PARAM_SLES_ANALYSIS_PARMETIS,
 
  CS_PARAM_SLES_ANALYSIS_AUTO,
 
  CS_PARAM_SLES_N_ANALYSIS_ALGOS
 
} cs_param_sles_analysis_algo_t;
 
 
typedef struct {
 
  /* \var analysis_algo
   * Choice of the algorithm used to perform the analysis step
   *
   * \var facto_type
   * Type of factorization to consider. This choice depends on the type of
   * matrix to handle
   */
 
  cs_param_sles_analysis_algo_t   analysis_algo;
  cs_param_sles_facto_type_t      facto_type;
 
  bool    is_single;        
  bool    advanced_optim;   
  double  blr_threshold;    
  double  mem_coef;         
  int     block_analysis;   
  int     ir_steps;         
} cs_param_sles_mumps_t;
 
 
typedef struct {
 
  char   *name;        
  int     field_id;    
  int     verbosity;   
  bool    setup_done;  
  cs_param_sles_class_t      solver_class; 
  cs_param_precond_type_t    precond;      
  cs_param_itsol_type_t      solver;       
  bool                       flexible;     
  int                        restart;      
  cs_param_amg_type_t        amg_type;     
  cs_param_precond_block_t    pcd_block_type;
 
  cs_param_resnorm_type_t     resnorm_type;
 
  cs_param_sles_cvg_t         cvg_param;
 
  void                       *context_param;
 
} cs_param_sles_t;
 
typedef struct {
 
  int                         verbosity;
 
  cs_param_saddle_solver_t    solver;
 
  cs_param_saddle_precond_t   precond;
 
  cs_param_sles_cvg_t         cvg_param;
 
  cs_param_schur_approx_t     schur_approximation;
 
  cs_param_sles_t            *schur_sles_param;
 
} cs_param_sles_saddle_t;
 
/*============================================================================
 * Global variables
 *============================================================================*/
 
/*============================================================================
 * Static inline public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_param_sles_is_mumps_set(cs_param_itsol_type_t  solver)
{
  if (solver == CS_PARAM_ITSOL_MUMPS)
    return true;
  else
    return false;
}
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_sles_saddle_t *
cs_param_sles_saddle_create(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_saddle_init_schur(const char                *basename,
                                cs_param_sles_saddle_t    *saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_saddle_copy(const cs_param_sles_saddle_t   *ref,
                          cs_param_sles_saddle_t         *dest);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_saddle_free(cs_param_sles_saddle_t    **p_saddlep);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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_mumps(cs_param_sles_t              *slesp,
                    bool                          is_single,
                    cs_param_sles_facto_type_t    facto_type);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_mumps_advanced(cs_param_sles_t               *slesp,
                             cs_param_sles_analysis_algo_t  analysis_algo,
                             int                            block_analysis,
                             double                         mem_coef,
                             double                         blr_threshold,
                             int                            ir_steps,
                             bool                           advanced_optim);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_copy_from(cs_param_sles_t   *src,
                        cs_param_sles_t   *dst);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_param_sles_set(bool                 use_field_id,
                  cs_param_sles_t     *slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_update_cvg_settings(bool                     use_field_id,
                                  const cs_param_sles_t   *slesp);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_sles_class_t
cs_param_sles_get_class_from_amg(cs_param_amg_type_t   amg_type);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_param_sles_class_t
cs_param_sles_check_class(cs_param_sles_class_t   wanted_class);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_check_amg(cs_param_sles_t   *slesp);
 
#if defined(HAVE_PETSC)
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_param_sles_petsc_cmd(bool          use_prefix,
                        const char   *prefix,
                        const char   *keyword,
                        const char   *keyval);
#endif
 
/*----------------------------------------------------------------------------*/
 
END_C_DECLS
 
#endif /* __CS_PARAM_SLES_H__ */