programmer's documentation
cs_param.h
Go to the documentation of this file.
1 #ifndef __CS_PARAM_H__
2 #define __CS_PARAM_H__
3 
4 /*============================================================================
5  * Manage the definition/setting of a computation
6  *============================================================================*/
7 
8 /*
9  This file is part of Code_Saturne, a general-purpose CFD tool.
10 
11  Copyright (C) 1998-2015 EDF S.A.
12 
13  This program is free software; you can redistribute it and/or modify it under
14  the terms of the GNU General Public License as published by the Free Software
15  Foundation; either version 2 of the License, or (at your option) any later
16  version.
17 
18  This program is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20  FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
21  details.
22 
23  You should have received a copy of the GNU General Public License along with
24  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
25  Street, Fifth Floor, Boston, MA 02110-1301, USA.
26 */
27 
28 /*----------------------------------------------------------------------------*/
29 
30 /*----------------------------------------------------------------------------
31  * Local headers
32  *----------------------------------------------------------------------------*/
33 
34 #include "cs_mesh.h"
35 #include "cs_cdo.h"
36 #include "cs_quadrature.h"
37 
38 /*----------------------------------------------------------------------------*/
39 
41 
42 /*============================================================================
43  * Macro definitions
44  *============================================================================*/
45 
46 /* Tag to build parameter flag */
47 #define CS_PARAM_FLAG_UNIFORM (1 << 0) // 1: uniform (in space)
48 #define CS_PARAM_FLAG_CELLWISE (1 << 1) // 2: cellwise uniform
49 #define CS_PARAM_FLAG_UNSTEADY (1 << 2) // 4: unsteady
50 #define CS_PARAM_FLAG_VERTEX (1 << 3) // 8: on vertices
51 #define CS_PARAM_FLAG_EDGE (1 << 4) // 16: on edges
52 #define CS_PARAM_FLAG_FACE (1 << 5) // 32: on faces
53 #define CS_PARAM_FLAG_CELL (1 << 6) // 64: on cells
54 #define CS_PARAM_FLAG_PRIMAL (1 << 7) // 128: on primal mesh
55 #define CS_PARAM_FLAG_DUAL (1 << 8) // 256: on dual mesh
56 #define CS_PARAM_FLAG_BORDER (1 << 9) // 512: scalar-valued
57 #define CS_PARAM_FLAG_SCAL (1 << 10) // 1024: scalar-valued
58 #define CS_PARAM_FLAG_VECT (1 << 11) // 2048: vector-valued
59 #define CS_PARAM_FLAG_TENS (1 << 12) // 4096: tensor-valued
60 #define CS_PARAM_FLAG_BY_CELL (1 << 13) // 8192: by cell (c2e, c2f, c2v)
61 
62 /*============================================================================
63  * Type definitions
64  *============================================================================*/
65 
66 /* User-defined function */
67 typedef void (cs_user_func_t) (const void *input1,
68  const void *input2,
69  cs_real_t tcur,
70  const cs_real_3_t xyz,
71  cs_get_t *output);
72 
73 typedef union {
74 
75  cs_get_t get; // definition by value
76  cs_analytic_func_t *analytic; // definition by an analytic function
77  cs_timestep_func_t *time_func; // definition of the time step by a function
78  cs_user_func_t *user_func; // definition by an user-defined function
79  cs_onevar_law_func_t *law1_func; // definition by law depending one variable
80 
81 } cs_def_t;
82 
83 typedef enum {
84 
93 
95 
96 /* Dimension of the variable to deal with */
97 typedef enum {
98 
99  CS_PARAM_VAR_SCAL, // scalar variable (dim = 1)
100  CS_PARAM_VAR_VECT, // vector variable (dim = 3)
101  CS_PARAM_VAR_SYMTENS, // symmetric tensor variable (dim = 6)
102  CS_PARAM_VAR_TENS, // tensor variable (dim = 9)
104 
106 
107 /* DISCRETE HODGE OPERATORS */
108 /* ======================== */
109 
110 typedef enum {
111 
112  CS_PARAM_HODGE_TYPE_VPCD, // from primal vertices to dual cells
113  CS_PARAM_HODGE_TYPE_EPFD, // from primal edges to dual faces
114  CS_PARAM_HODGE_TYPE_FPED, // from primal faces to dual edges
115  CS_PARAM_HODGE_TYPE_EDFP, // from dual edges to primal faces
116  CS_PARAM_HODGE_TYPE_CPVD, // from primal cells to dual vertices
118 
120 
121 typedef enum {
122 
123  CS_PARAM_HODGE_ALGO_VORONOI, // Under othogonality condition gives a diag. op.
124  CS_PARAM_HODGE_ALGO_WBS, // WBS: Whitney Barycentric Subdivision
125  CS_PARAM_HODGE_ALGO_COST, // COST: COnsistency & STabilization splitting
127 
129 
130 typedef struct {
131 
132  bool inv_pty; /* Definition based on the property
133  or its inverse */
134 
135  cs_param_hodge_type_t type; /* type of discrete Hodge operator */
136  cs_param_hodge_algo_t algo; /* type of algorithm used to build this op. */
137  double coef; /* Value of the stabilization parameter
138  if the COST algo. is used, otherwise 0. */
139 
141 
142 /* TIME SCHEME */
143 /* =========== */
144 
145 /* Type of numerical scheme for the discretization in time */
146 typedef enum {
147 
148  CS_TIME_SCHEME_IMPLICIT, // fully implicit (forward Euler/theta-scheme = 1)
149  CS_TIME_SCHEME_EXPLICIT, // fully explicit (backward Euler/theta-scheme = 0)
150  CS_TIME_SCHEME_CRANKNICO, // Crank-Nicolson (theta-scheme = 0.5)
151  CS_TIME_SCHEME_THETA, // theta-scheme
153 
155 
156 /* Parameters related to time discretization */
157 typedef struct {
158 
159  cs_time_scheme_t scheme; // numerical scheme
160  cs_real_t theta; // used in theta-scheme
161  bool do_lumping; // perform mass lumping ?
162 
163  /* Initial conditions */
164  cs_param_def_type_t ic_def_type; // type of definition
165  cs_def_t ic_def; // definition
166 
168 
169 /* ADVECTION OPERATOR PARAMETRIZATION */
170 /* ================================== */
171 
172 typedef enum {
173 
177 
179 
180 /* Type of weight functions considered */
181 typedef enum {
182 
189 
191 
192 /* Choice on the type of algo. used to set the argument used in
193  the weight function */
194 typedef enum {
195 
199 
201 
202 /* Set of options for building a contraction operator (also called interior
203  product) which is closely related to the advection operator */
204 typedef struct {
205 
206  cs_param_advection_form_t formulation; // conservative or not
209  cs_quadra_type_t quad_type; // barycentric, higher, highest
210 
212 
213 /* REACTION TERM PARAMETRIZATION */
214 /* ============================= */
215 
216 typedef enum {
217 
220 
222 
223 typedef struct {
224 
225  char *name;
227 
230 
232 
233 /* BOUNDARY CONDITIONS */
234 /* =================== */
235 
236 /* Physic-driven boundary */
237 typedef enum {
238 
244 
246 
247 /* Mathematical boundary conditions */
248 typedef enum {
249 
256 
258 
259 /* Choice between different method to enforce the BCs */
260 typedef enum {
261 
262  CS_PARAM_BC_ENFORCE_STRONG, /* Strong enforcement of the BCs */
263  CS_PARAM_BC_ENFORCE_WEAK_PENA, /* Weak enforcement with a strong
264  penalization coefficient */
265  CS_PARAM_BC_ENFORCE_WEAK_NITSCHE, /* Weak enforcement using Nitsche method */
266  CS_PARAM_BC_ENFORCE_WEAK_SYM, /* Weak enforcement using symmetric Nitsche
267  method */
269 
271 
272 /* Definition of the value of a boundary condition (BC)
273  One or two values may be needed according to the type of BC.
274  That's why two coefficients are used in the definition.
275  For Dirichlet or Neumann BC for instance, only one coefficient is used.
276 */
277 
278 typedef struct {
279 
280  int loc_id; // Id related to the list of border faces
281 
282  cs_param_bc_type_t bc_type; // type of mathematical BC
283  cs_param_var_type_t var_type; // type of variable
284  cs_param_def_type_t def_type; // Type of definition for a and b
285 
286 
287  /* Access to the value related to the first coefficient and possibly
288  the second one */
291 
293 
294 typedef struct {
295 
296  cs_param_bc_type_t default_bc; // BC used by default
297  cs_param_bc_enforce_t enforcement; // type of boundary enforcement
298  cs_quadra_type_t quad_type; // barycentric, higher, highest...
299  bool use_subdiv; /* subdivide or not into tetrahedra for
300  evaluating BC values */
301 
302  int n_defs;
304 
305 } cs_param_bc_t;
306 
307 /* SOURCE TERMS */
308 /* ============ */
309 
310 /* Types of source terms */
311 typedef enum {
312 
313  CS_PARAM_SOURCE_TERM_USER, // user-defined
314  CS_PARAM_SOURCE_TERM_MASS, // specific treatment
315  CS_PARAM_SOURCE_TERM_HEADLOSS, // specific treatment
317 
319 
320 typedef struct {
321 
322  char *restrict name; /* short description of the source term */
323 
324  int ml_id; /* id of the related mesh location structure */
325  int post; /* -1: no post, 0: at the beginning,
326  n: at each 'n' iterations */
327 
328  /* Specification related to the way of computing the source term */
329  cs_param_source_term_type_t type; // mass, head loss...
330  cs_param_var_type_t var_type; // scalar, vector...
331  cs_param_def_type_t def_type; // by value, by function...
332  cs_quadra_type_t quad_type; // barycentric, higher, highest
333  bool use_subdiv; // use a subdivision into tetrahedra
334 
335  /* Values if one needs an implicit and explicit part
336  implicit part comes first */
338 
340 
341 /* ITERATIVE SOLVERS */
342 /* ================= */
343 
344 typedef enum {
345 
346  CS_PARAM_PRECOND_DIAG, // Diagonal preconditioning (also called Jacobi)
347  CS_PARAM_PRECOND_POLY1, // Neumann polynomial preconditioning (Order 1)
348  CS_PARAM_PRECOND_SSOR, // Symmetric Successive OverRelaxations
349  CS_PARAM_PRECOND_ILU0, // Incomplete LU factorization
350  CS_PARAM_PRECOND_ICC0, // Incomplete Cholesky factorization
351  CS_PARAM_PRECOND_AMG, // Algebraic MultiGrid
352  CS_PARAM_PRECOND_AS, // Additive Schwarz method
354 
356 
357 /* Type of iterative solver to use to inverse the linear system */
358 typedef enum {
359 
360  CS_PARAM_ITSOL_CG, // Conjuguate Gradient
361  CS_PARAM_ITSOL_BICG, // Bi-Conjuguate gradient
362  CS_PARAM_ITSOL_GMRES, // Generalized Minimal RESidual
363  CS_PARAM_ITSOL_AMG, // Algebraic MultiGrid
365 
367 
368 /* Description of the algorithm used to solve an equation */
369 typedef struct {
370 
371  cs_param_precond_type_t precond; // type of preconditioner
372  cs_param_itsol_type_t solver; // type of solver
373 
374  int n_max_iter; // max. number of iterations
375  double eps; // stopping criterion on accuracy
376 
377  int output_freq; // frequencdy of output into listing
378  bool resid_normalized; /* normalized or not the norm of the
379  residual used for the stopping criterion
380  */
382 
383 /*============================================================================
384  * Global variables
385  *============================================================================*/
386 
387 /*============================================================================
388  * Public function prototypes
389  *============================================================================*/
390 
391 /*----------------------------------------------------------------------------*/
400 /*----------------------------------------------------------------------------*/
401 
402 void
404  cs_param_var_type_t var_type,
405  const void *val,
406  cs_def_t *def);
407 
408 /*----------------------------------------------------------------------------*/
416 /*----------------------------------------------------------------------------*/
417 
420 
421 /*----------------------------------------------------------------------------*/
433 /*----------------------------------------------------------------------------*/
434 
435 void
437  int loc_id,
438  cs_param_bc_type_t bc_type,
439  cs_param_var_type_t var_type,
440  cs_param_def_type_t def_type,
441  const void *coef1,
442  const void *coef2);
443 
444 /*----------------------------------------------------------------------------*/
456 /*----------------------------------------------------------------------------*/
457 
458 void
460  const char *r_name,
461  cs_param_hodge_type_t h_type,
462  cs_param_hodge_algo_t h_algo,
464 
465 /*----------------------------------------------------------------------------*/
479 /*----------------------------------------------------------------------------*/
480 
481 void
483  const char *st_name,
484  int ml_id,
486  cs_param_var_type_t var_type,
487  cs_quadra_type_t quad_type,
488  cs_param_def_type_t def_type,
489  const void *val);
490 
491 /*----------------------------------------------------------------------------*/
499 /*----------------------------------------------------------------------------*/
500 
501 const char *
503 
504 /*----------------------------------------------------------------------------*/
512 /*----------------------------------------------------------------------------*/
513 
514 const char *
516 
517 /*----------------------------------------------------------------------------*/
525 /*----------------------------------------------------------------------------*/
526 
527 const char *
529 
530 /*----------------------------------------------------------------------------*/
538 /*----------------------------------------------------------------------------*/
539 
540 const char *
542 
543 /*----------------------------------------------------------------------------*/
551 /*----------------------------------------------------------------------------*/
552 
553 const char *
555 
556 /*----------------------------------------------------------------------------*/
564 /*----------------------------------------------------------------------------*/
565 
566 const char *
568 
569 /*----------------------------------------------------------------------------*/
577 /*----------------------------------------------------------------------------*/
578 
579 const char *
581 
582 /*----------------------------------------------------------------------------*/
590 /*----------------------------------------------------------------------------*/
591 
592 const char *
594 
595 /*----------------------------------------------------------------------------*/
603 /*----------------------------------------------------------------------------*/
604 
605 const char *
607 
608 /*----------------------------------------------------------------------------*/
616 /*----------------------------------------------------------------------------*/
617 
618 const char *
620 
621 /*----------------------------------------------------------------------------*/
629 /*----------------------------------------------------------------------------*/
630 
631 const char *
633 
634 /*----------------------------------------------------------------------------*/
642 /*----------------------------------------------------------------------------*/
643 
644 const char *
646 
647 /*----------------------------------------------------------------------------*/
648 
650 
651 #endif /* __CS_PARAM_H__ */
cs_quadra_type_t quad_type
Definition: cs_param.h:332
cs_time_scheme_t
Definition: cs_param.h:146
cs_param_bc_t * cs_param_bc_create(cs_param_bc_type_t default_bc)
Allocate and initialize a new cs_param_bc_t structure.
Definition: cs_param.c:275
Definition: cs_param.h:149
void cs_param_set_def(cs_param_def_type_t def_type, cs_param_var_type_t var_type, const void *val, cs_def_t *def)
Set a cs_def_t structure.
Definition: cs_param.c:180
Definition: cs_param.h:116
cs_param_hodge_algo_t algo
Definition: cs_param.h:136
cs_param_advection_weight_algo_t weight_algo
Definition: cs_param.h:207
cs_param_precond_type_t precond
Definition: cs_param.h:371
#define restrict
Definition: cs_defs.h:122
cs_param_bc_def_t * defs
Definition: cs_param.h:303
const char * cs_param_reaction_get_name(const cs_param_reaction_t r_info)
Get the name related to a reaction term.
Definition: cs_param.c:450
Definition: cs_param.h:347
cs_param_def_type_t def_type
Definition: cs_param.h:331
Definition: cs_param.h:316
Definition: cs_param.h:349
cs_real_t theta
Definition: cs_param.h:160
cs_param_boundary_type_t
Definition: cs_param.h:237
cs_onevar_law_func_t * law1_func
Definition: cs_param.h:79
Definition: cs_param.h:103
Definition: cs_param.h:101
Definition: cs_param.h:99
Definition: cs_param.h:198
bool inv_pty
Definition: cs_param.h:132
const char * cs_param_source_term_get_type_name(const cs_param_source_term_t st_info)
Get the name of type of a given source term structure.
Definition: cs_param.c:553
void cs_param_bc_def_set(cs_param_bc_def_t *bcpd, int loc_id, cs_param_bc_type_t bc_type, cs_param_var_type_t var_type, cs_param_def_type_t def_type, const void *coef1, const void *coef2)
Set a cs_param_bc_def_t structure.
Definition: cs_param.c:308
Definition: cs_param.h:360
Definition: cs_param.h:266
cs_def_t def_coef1
Definition: cs_param.h:289
Definition: cs_param.h:363
cs_param_var_type_t var_type
Definition: cs_param.h:283
cs_user_func_t * user_func
Definition: cs_param.h:78
cs_param_itsol_type_t solver
Definition: cs_param.h:372
const char * cs_param_get_bc_enforcement_name(cs_param_bc_enforce_t type)
Get the name of the type of enforcement of the boundary condition.
Definition: cs_param.c:378
Definition: cs_param.h:188
Definition: cs_param.h:253
#define BEGIN_C_DECLS
Definition: cs_defs.h:429
Definition: cs_param.h:254
Definition: cs_param.h:100
Definition: cs_param.h:346
Definition: cs_param.h:123
Definition: cs_param.h:196
Definition: cs_param.h:241
const char * cs_param_get_precond_name(cs_param_precond_type_t precond)
Get the name of the preconditioner.
Definition: cs_param.c:635
cs_param_advection_weight_t
Definition: cs_param.h:194
Definition: cs_param.h:364
Definition: cs_param.h:262
Definition: cs_param.h:320
Definition: cs_param.h:183
void cs_param_source_term_add(cs_param_source_term_t *stp, const char *st_name, int ml_id, cs_param_source_term_type_t type, cs_param_var_type_t var_type, cs_quadra_type_t quad_type, cs_param_def_type_t def_type, const void *val)
Define a source term. This source term is added to the list of source terms associated to an equation...
Definition: cs_param.c:500
Definition: cs_param.h:350
cs_param_source_term_type_t
Definition: cs_param.h:311
Definition: cs_param.h:117
Definition: cs_param.h:112
Definition: cs_param.h:174
cs_param_advection_form_t
Definition: cs_param.h:172
Definition: cs_param.h:197
Definition: cs_param.h:361
Definition: cs_param.h:150
Definition: cs_cdo.h:71
Definition: cs_param.h:115
Definition: cs_param.h:102
Definition: cs_param.h:239
Definition: cs_param.h:314
cs_def_t def
Definition: cs_param.h:337
const char * cs_param_reaction_get_type_name(cs_param_reaction_t r_info)
Get the name of the type of reaction term.
Definition: cs_param.c:466
int ml_id
Definition: cs_param.h:324
char * name
Definition: cs_param.h:225
cs_def_t def_coef2
Definition: cs_param.h:290
Definition: cs_param.h:219
Definition: cs_param.h:353
Definition: cs_param.h:315
Definition: cs_param.h:126
Definition: cs_param.h:204
int loc_id
Definition: cs_param.h:280
bool do_lumping
Definition: cs_param.h:161
Definition: cs_param.h:184
Definition: cs_param.h:250
cs_timestep_func_t * time_func
Definition: cs_param.h:77
cs_param_advection_weight_algo_t
Definition: cs_param.h:181
Definition: cs_param.h:89
cs_time_scheme_t scheme
Definition: cs_param.h:159
const char * cs_param_hodge_get_type_name(const cs_param_hodge_t h_info)
Get the type of discrete Hodge operator.
Definition: cs_param.c:585
Definition: cs_param.h:175
void( cs_onevar_law_func_t)(double var_value, const void *law_param, cs_get_t *retval)
Compute the value of a quantity according to a law depending only on one variable. This law is described by a set of parameters stored in a structure. result = law(var_value)
Definition: cs_cdo.h:128
int output_freq
Definition: cs_param.h:377
void( cs_analytic_func_t)(cs_real_t time, const cs_real_3_t xyz, cs_get_t *retval)
Generic analytic function.
Definition: cs_cdo.h:96
int n_max_iter
Definition: cs_param.h:374
Definition: cs_param.h:91
Definition: cs_param.h:268
cs_param_hodge_t hodge
Definition: cs_param.h:228
cs_quadra_type_t quad_type
Definition: cs_param.h:209
const char * cs_param_get_bc_name(cs_param_bc_type_t bc)
Get the name of the type of boundary condition.
Definition: cs_param.c:343
int n_defs
Definition: cs_param.h:302
const char * cs_param_get_def_type_name(const cs_param_def_type_t type)
Get the name related to a type of definition.
Definition: cs_param.c:163
const char * cs_param_hodge_get_algo_name(const cs_param_hodge_t h_info)
Get the name of algorithm related to a discrete Hdoge operator.
Definition: cs_param.c:569
cs_analytic_func_t * analytic
Definition: cs_param.h:76
cs_param_precond_type_t
Definition: cs_param.h:344
cs_param_hodge_type_t type
Definition: cs_param.h:135
Definition: cs_param.h:157
Definition: cs_param.h:113
cs_param_itsol_type_t
Definition: cs_param.h:358
cs_param_advection_form_t formulation
Definition: cs_param.h:206
cs_param_def_type_t def_type
Definition: cs_param.h:284
Definition: cs_param.h:242
cs_real_t cs_real_3_t[3]
vector of 3 floating-point values
Definition: cs_defs.h:307
cs_param_bc_type_t
Definition: cs_param.h:248
int post
Definition: cs_param.h:325
const char * cs_param_source_term_get_name(const cs_param_source_term_t st_info)
Get the name related to a source term.
Definition: cs_param.c:537
cs_param_def_type_t ic_def_type
Definition: cs_param.h:164
cs_param_bc_enforce_t enforcement
Definition: cs_param.h:297
Definition: cs_param.h:240
Definition: cs_param.h:186
Definition: cs_param.h:90
cs_real_t( cs_timestep_func_t)(int time_iter)
Simple function to define the time step according to the number of iteration already done...
Definition: cs_cdo.h:112
Definition: cs_param.h:265
cs_quadra_type_t
Definition: cs_quadrature.h:40
Definition: cs_param.h:85
Definition: cs_param.h:73
Definition: cs_param.h:255
Definition: cs_param.h:348
cs_quadra_type_t quad_type
Definition: cs_param.h:298
cs_param_advection_weight_t weight_criterion
Definition: cs_param.h:208
Definition: cs_param.h:148
void( cs_user_func_t)(const void *input1, const void *input2, cs_real_t tcur, const cs_real_3_t xyz, cs_get_t *output)
Definition: cs_param.h:67
cs_param_hodge_type_t
Definition: cs_param.h:110
bool do_lumping
Definition: cs_param.h:229
bool use_subdiv
Definition: cs_param.h:333
Definition: cs_param.h:151
const char * cs_param_get_var_type_name(const cs_param_var_type_t type)
Get the name related to a type of variable.
Definition: cs_param.c:147
Definition: cs_param.h:218
Definition: cs_param.h:362
cs_param_source_term_type_t type
Definition: cs_param.h:329
const char * cs_param_get_solver_name(cs_param_itsol_type_t solver)
Get the name of the solver.
Definition: cs_param.c:601
Definition: cs_param.h:125
bool use_subdiv
Definition: cs_param.h:299
#define END_C_DECLS
Definition: cs_defs.h:430
char *restrict name
Definition: cs_param.h:322
double cs_real_t
Definition: cs_defs.h:296
Definition: cs_param.h:243
cs_param_bc_type_t default_bc
Definition: cs_param.h:296
cs_param_reaction_type_t type
Definition: cs_param.h:226
cs_param_var_type_t
Definition: cs_param.h:97
Definition: cs_param.h:252
Definition: cs_param.h:92
Definition: cs_param.h:223
bool resid_normalized
Definition: cs_param.h:378
cs_param_var_type_t var_type
Definition: cs_param.h:330
Definition: cs_param.h:278
Definition: cs_param.h:313
Definition: cs_param.h:114
cs_param_bc_type_t bc_type
Definition: cs_param.h:282
double coef
Definition: cs_param.h:137
Definition: cs_param.h:263
Definition: cs_param.h:251
Definition: cs_param.h:294
Definition: cs_param.h:351
cs_param_reaction_type_t
Definition: cs_param.h:216
cs_param_hodge_algo_t
Definition: cs_param.h:121
Definition: cs_param.h:130
double eps
Definition: cs_param.h:375
Definition: cs_param.h:187
void cs_param_reaction_add(cs_param_reaction_t *rp, const char *r_name, cs_param_hodge_type_t h_type, cs_param_hodge_algo_t h_algo, cs_param_source_term_type_t r_type)
Define a new reaction term. The structure related to this reaction term has already been allocated am...
Definition: cs_param.c:415
Definition: cs_param.h:88
cs_param_bc_enforce_t
Definition: cs_param.h:260
Definition: cs_param.h:352
cs_param_def_type_t
Definition: cs_param.h:83
Definition: cs_param.h:87
Definition: cs_param.h:152
cs_def_t ic_def
Definition: cs_param.h:165
Definition: cs_param.h:86
Definition: cs_param.h:176
Definition: cs_param.h:369
Definition: cs_param.h:124