cs_param_types.h

Go to the documentation of this file.

#ifndef CS_PARAM_TYPES_H
#define CS_PARAM_TYPES_H
 
/*============================================================================
 * Set of definitions of structures and types used for setting a case
 *============================================================================*/
 
/*
  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 "base/cs_defs.h"
 
/*----------------------------------------------------------------------------*/
 
BEGIN_C_DECLS
 
/*============================================================================
 * Macro definitions
 *============================================================================*/
 
#define CS_DOF_VTX_SCAL    0 
#define CS_DOF_VTX_VECT    1 
#define CS_DOF_FACE_SCAL   2 
#define CS_DOF_FACE_VECT   3 
#define CS_DOF_FACE_SCAP1  3 
#define CS_DOF_FACE_SCAP2  4 
#define CS_DOF_FACE_VECP0  3 
#define CS_DOF_FACE_VECP1  5 
#define CS_DOF_FACE_VECP2  6 
#define CS_DOF_EDGE_SCAL   7 
#define CS_N_DOF_CASES     8
 
/*
 * Field property type
 */
 
#define CS_ISOTROPIC_DIFFUSION (1 << 0)
 
#define CS_ORTHOTROPIC_DIFFUSION (1 << 1)
 
#define CS_ANISOTROPIC_LEFT_DIFFUSION (1 << 2)
 
#define CS_ANISOTROPIC_RIGHT_DIFFUSION (1 << 3)
 
#define CS_ANISOTROPIC_DIFFUSION ((1 << 2) + (1 << 3))
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
typedef void
(cs_analytic_func_t) (cs_real_t            time,
                      cs_lnum_t            n_elts,
                      const cs_lnum_t     *elt_ids,
                      const cs_real_t     *coords,
                      bool                 dense_output,
                      void                *input,
                      cs_real_t           *retval);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
typedef void
(cs_dof_func_t) (cs_lnum_t            n_elts,
                 const cs_lnum_t     *elt_ids,
                 bool                 dense_output,
                 void                *input,
                 cs_real_t           *retval);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
typedef void
(cs_time_func_t) (double     time,
                  void      *input,
                  cs_real_t *retval);
 
typedef enum {
 
  CS_SPACE_SCHEME_LEGACY,
  CS_SPACE_SCHEME_CDOVB,
  CS_SPACE_SCHEME_CDOVCB,
  CS_SPACE_SCHEME_CDOEB,
  CS_SPACE_SCHEME_CDOFB,
  CS_SPACE_SCHEME_CDOCB,
  CS_SPACE_SCHEME_HHO_P0,
  CS_SPACE_SCHEME_HHO_P1,
  CS_SPACE_SCHEME_HHO_P2,
  CS_SPACE_SCHEME_MACFB,
 
  CS_SPACE_N_SCHEMES
 
} cs_param_space_scheme_t;
 
typedef enum {
 
  CS_PARAM_REDUCTION_DERHAM,
  CS_PARAM_REDUCTION_AVERAGE,
 
  CS_PARAM_N_REDUCTIONS
 
} cs_param_dof_reduction_t;
 
typedef enum {
 
  CS_TIME_SCHEME_STEADY,
  CS_TIME_SCHEME_EULER_IMPLICIT,
  CS_TIME_SCHEME_EULER_EXPLICIT,
  CS_TIME_SCHEME_CRANKNICO,
  CS_TIME_SCHEME_THETA,
  CS_TIME_SCHEME_BDF2,
 
  CS_TIME_N_SCHEMES
 
} cs_param_time_scheme_t;
 
typedef enum {
 
  CS_PARAM_ADVECTION_FORM_CONSERV,
  CS_PARAM_ADVECTION_FORM_NONCONS,
  CS_PARAM_ADVECTION_FORM_SKEWSYM,
 
  CS_PARAM_N_ADVECTION_FORMULATIONS
 
} cs_param_advection_form_t;
 
typedef enum {
 
  CS_PARAM_ADVECTION_SCHEME_CENTERED,
  CS_PARAM_ADVECTION_SCHEME_CIP,
  CS_PARAM_ADVECTION_SCHEME_CIP_CW,
  CS_PARAM_ADVECTION_SCHEME_HYBRID_CENTERED_UPWIND,
  CS_PARAM_ADVECTION_SCHEME_SAMARSKII,
  CS_PARAM_ADVECTION_SCHEME_SG,
  CS_PARAM_ADVECTION_SCHEME_UPWIND,
  CS_PARAM_ADVECTION_SCHEME_L0,
  CS_PARAM_ADVECTION_SCHEME_CENTERED_V8,
  CS_PARAM_ADVECTION_SCHEME_UPWIND_V8,
  CS_PARAM_ADVECTION_SCHEME_SOLU,
  CS_PARAM_ADVECTION_SCHEME_SOLU_SYM,
 
  CS_PARAM_N_ADVECTION_SCHEMES
 
} cs_param_advection_scheme_t;
 
typedef enum {
 
  CS_PARAM_ADVECTION_IMPLICIT_FULL,
  CS_PARAM_ADVECTION_IMPLICIT_LINEARIZED,
  CS_PARAM_ADVECTION_EXPLICIT,
 
  CS_PARAM_N_ADVECTION_STRATEGIES
 
} cs_param_advection_strategy_t;
 
typedef enum {
 
  CS_PARAM_ADVECTION_EXTRAPOL_NONE,
  CS_PARAM_ADVECTION_EXTRAPOL_TAYLOR_2,
  CS_PARAM_ADVECTION_EXTRAPOL_ADAMS_BASHFORTH_2,
 
  CS_PARAM_N_ADVECTION_EXTRAPOLATIONS
 
} cs_param_advection_extrapol_t;
 
typedef enum {
  // DO NOT CHANGE, back-compatibility with icodcl = 0
  CS_BC_UNDEF                 = 0,
  CS_BC_HMG_DIRICHLET         = 16,
  // DO NOT CHANGE, back-compatibility with icodcl = 1
  CS_BC_DIRICHLET             = 1,
  // DO NOT CHANGE, back-compatibility with icodcl = 2
  CS_BC_RADIATIVE_OUTLET      = 2,
  CS_BC_HMG_NEUMANN           = 7,
  // DO NOT CHANGE, back-compatibility with icodcl = 3
  CS_BC_NEUMANN               = 3,
  CS_BC_NEUMANN_FULL          = 8,
  // DO NOT CHANGE, back-compatibility with icodcl = 4
  CS_BC_SYMMETRY              = 4,
  // DO NOT CHANGE, back-compatibility with icodcl = 5
  CS_BC_WALL_MODELLED         = 5,
  // DO NOT CHANGE, back-compatibility with icodcl = 6
  // note: deprecated, to be removed
  CS_BC_ROUGH_WALL_MODELLED   = 6,
  CS_BC_ROBIN                 = 9,
  /* TODO add a code for:
   * - 10, used by
   * cs_boundary_conditions_set_affine_function_scalar
   * - 12, used by
   *   cs_boundary_conditions_set_affine_function_conv_neumann_diff_scalar
   *   and
   *   cs_boundary_conditions_set_total_flux
   * - 13 and cs_boundary_conditions_set_dirichlet_conv_neumann_diff_scalar
   * - 15 and cs_boundary_conditions_set_neumann_conv_h_neumann_diff_scalar
   */
  // DO NOT CHANGE, back-compatibility with icodcl = 11
  // in legacy, it correspond to Neumann on normal component and
  // Dirichlet on tangential ones for vectors
  CS_BC_CIRCULATION           = 11,
  // DO NOT CHANGE, back-compatibility with icodcl = 13
  CS_BC_IMPOSED_TOT_FLUX      = 13,
  // DO NOT CHANGE, back-compatibility with icodcl = 14
  CS_BC_GENERALIZED_SYM       = 14,
  // DO NOT CHANGE, back-compatibility with icodcl = 15
  CS_BC_IMPOSED_EXCHANGE_COEF = 15,
 
  CS_PARAM_N_BC_TYPES = 17
 
} cs_param_bc_type_t;
 
/* Compatibility macros */
 
#define  CS_PARAM_BC_HMG_DIRICHLET   CS_BC_HMG_DIRICHLET
#define  CS_PARAM_BC_DIRICHLET       CS_BC_DIRICHLET
#define  CS_PARAM_BC_HMG_NEUMANN     CS_BC_HMG_NEUMANN
#define  CS_PARAM_BC_NEUMANN         CS_BC_NEUMANN
#define  CS_PARAM_BC_NEUMANN_FULL    CS_BC_NEUMANN_FULL
#define  CS_PARAM_BC_ROBIN           CS_BC_ROBIN
#define  CS_PARAM_BC_SLIDING         CS_BC_SYMMETRY
#define  CS_PARAM_BC_CIRCULATION     CS_BC_CIRCULATION
#define  CS_PARAM_BC_WALL_PRECRIBED  CS_BC_WALL_MODELLED
 
typedef enum {
 
  CS_PARAM_BC_ENFORCE_ALGEBRAIC,
  CS_PARAM_BC_ENFORCE_PENALIZED,
  CS_PARAM_BC_ENFORCE_WEAK_NITSCHE,
  CS_PARAM_BC_ENFORCE_WEAK_SYM,
 
  CS_PARAM_N_BC_ENFORCEMENTS
 
} cs_param_bc_enforce_t;
 
typedef struct {
 
  double               atol;
  double               rtol;
  double               dtol;
  int                  n_max_iter;
 
} cs_param_convergence_t;
 
typedef struct {
  double atol;
  double rtol;
 
  int n_cvg_iter;
 
  int n_time_step_solve;
 
} cs_param_psteady_t;
 
typedef struct {
  int n_cvg_iter_curr{ 0 };
 
  double norm2_mass_flux_stat{ 0.0 };
  double norm2_turb_k_stat{ 0.0 };
 
  bool cvg_iter_mass_flux{ false };
  bool cvg_iter_turb_k{ false };
 
  bool cvg_steady{ false };
 
} cs_cdo_navsto_psteady_cvg_t;
 
typedef enum {
 
  CS_PARAM_NL_ALGO_NONE,
  CS_PARAM_NL_ALGO_PICARD,
  CS_PARAM_NL_ALGO_MODIFIED_PICARD,
  CS_PARAM_NL_ALGO_ANDERSON,
  CS_PARAM_N_NL_ALGOS
 
} cs_param_nl_algo_t;
 
typedef enum {
 
  CS_PARAM_SOLVER_CLASS_CS,
  CS_PARAM_SOLVER_CLASS_HYPRE,
  CS_PARAM_SOLVER_CLASS_MUMPS,
  CS_PARAM_SOLVER_CLASS_PETSC,
 
  CS_PARAM_N_SOLVER_CLASSES
 
} cs_param_solver_class_t;
 
typedef enum {
 
  CS_PARAM_PRECOND_BLOCK_NONE,
  CS_PARAM_PRECOND_BLOCK_DIAG,
  CS_PARAM_PRECOND_BLOCK_LOWER_TRIANGULAR,
  CS_PARAM_PRECOND_BLOCK_SYM_GAUSS_SEIDEL,
  CS_PARAM_PRECOND_BLOCK_UPPER_TRIANGULAR,
 
  CS_PARAM_N_PCD_BLOCK_TYPES
 
} cs_param_precond_block_t;
 
typedef enum {
 
  CS_PARAM_PRECOND_NONE,
 
  CS_PARAM_PRECOND_AMG,
  CS_PARAM_PRECOND_BJACOB_ILU0, 
  CS_PARAM_PRECOND_BJACOB_SGS,  
  CS_PARAM_PRECOND_DIAG,
  CS_PARAM_PRECOND_GKB_CG,    
  CS_PARAM_PRECOND_GKB_GMRES, 
  CS_PARAM_PRECOND_LU,        
  CS_PARAM_PRECOND_ILU0,      
  CS_PARAM_PRECOND_ICC0,      
  CS_PARAM_PRECOND_MUMPS,     
  CS_PARAM_PRECOND_HPDDM,     
  CS_PARAM_PRECOND_POLY1,
  CS_PARAM_PRECOND_POLY2,
  CS_PARAM_PRECOND_SSOR,
 
  CS_PARAM_N_PRECOND_TYPES
 
} cs_param_precond_type_t;
 
typedef enum {
 
  CS_PARAM_SOLVER_NONE,
 
  CS_PARAM_SOLVER_AMG,
  CS_PARAM_SOLVER_BICGS,
  CS_PARAM_SOLVER_BICGS2,
  CS_PARAM_SOLVER_CG,
  CS_PARAM_SOLVER_CR3,
  CS_PARAM_SOLVER_FCG,
  CS_PARAM_SOLVER_FGMRES,           
  CS_PARAM_SOLVER_GAUSS_SEIDEL,
  CS_PARAM_SOLVER_GCR,
  CS_PARAM_SOLVER_GMRES,            
  CS_PARAM_SOLVER_JACOBI,
  CS_PARAM_SOLVER_MUMPS,            
  CS_PARAM_SOLVER_SYM_GAUSS_SEIDEL,
  CS_PARAM_SOLVER_USER_DEFINED,
 
  CS_PARAM_N_SOLVER_TYPES
 
} cs_param_solver_type_t;
 
typedef enum {
 
  CS_PARAM_RESNORM_NONE,           
  CS_PARAM_RESNORM_NORM2_RHS,      
  CS_PARAM_RESNORM_WEIGHTED_RHS,   
  CS_PARAM_RESNORM_FILTERED_RHS,   
  CS_PARAM_N_RESNORM_TYPES
 
} cs_param_resnorm_type_t;
 
/*============================================================================
 * Global variables
 *============================================================================*/
 
/* Separation lines: header1, header2 (compatible with markdown), other */
 
extern const char cs_sep_h1[80];
extern const char cs_sep_h2[80];
extern const char cs_sepline[80];
extern const char cs_med_sepline[50];
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
bool
cs_param_space_scheme_is_face_based(cs_param_space_scheme_t    scheme);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_get_space_scheme_name(cs_param_space_scheme_t    scheme);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_get_time_scheme_name(cs_param_time_scheme_t    scheme);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_get_advection_form_name(cs_param_advection_form_t    adv_form);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_get_advection_scheme_name(cs_param_advection_scheme_t    scheme);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_get_advection_strategy_name(cs_param_advection_strategy_t  adv_stra);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_get_advection_extrapol_name(cs_param_advection_extrapol_t   extrapol);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_get_bc_name(cs_param_bc_type_t  bc);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_get_bc_enforcement_name(cs_param_bc_enforce_t  type);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_get_nl_algo_name(cs_param_nl_algo_t   algo);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_get_nl_algo_label(cs_param_nl_algo_t   algo);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_get_solver_name(cs_param_solver_type_t  solver);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_get_precond_name(cs_param_precond_type_t  precond);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_param_get_precond_block_name(cs_param_precond_block_t   type);
 
/*----------------------------------------------------------------------------*/
 
END_C_DECLS
 
#endif /* CS_PARAM_TYPES_H */