6.2
general documentation
cs_gradient.h
Go to the documentation of this file.
1 #ifndef __CS_GRADIENT_H__
2 #define __CS_GRADIENT_H__
3 
4 /*============================================================================
5  * Gradient reconstruction.
6  *============================================================================*/
7 
8 /*
9  This file is part of Code_Saturne, a general-purpose CFD tool.
10 
11  Copyright (C) 1998-2020 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_base.h"
35 #include "cs_halo.h"
36 #include "cs_internal_coupling.h"
37 #include "cs_mesh.h"
38 #include "cs_mesh_quantities.h"
39 
40 /*----------------------------------------------------------------------------*/
41 
43 
44 /*=============================================================================
45  * Local Macro definitions
46  *============================================================================*/
47 
48 /*============================================================================
49  * Type definition
50  *============================================================================*/
51 
52 /*----------------------------------------------------------------------------
53  * Gradient reconstruction method
54  *----------------------------------------------------------------------------*/
55 
56 typedef enum {
57 
65 
66 /*----------------------------------------------------------------------------
67  * Gradient limiter mode
68  *----------------------------------------------------------------------------*/
69 
70 typedef enum {
71 
82 
83 /*============================================================================
84  * Global variables
85  *============================================================================*/
86 
87 /* Short names for gradient types */
88 
89 extern const char *cs_gradient_type_name[];
90 
91 /*============================================================================
92  * Public function prototypes for Fortran API
93  *============================================================================*/
94 
95 /*----------------------------------------------------------------------------
96  * Compute the steady balance due to porous modelling for the pressure
97  * gradient
98  *----------------------------------------------------------------------------*/
99 
100 void CS_PROCF (grdpor, GRDPOR)
101 (
102  const int *const inc /* <-- 0 or 1: increment or not */
103 );
104 
105 /*----------------------------------------------------------------------------
106  * Compute cell gradient of vector field.
107  *----------------------------------------------------------------------------*/
108 
109 void CS_PROCF (cgdvec, CGDVEC)
110 (
111  const int *const f_id, /* <-- field id, or -1 */
112  const int *const imrgra, /* <-- gradient computation mode */
113  const int *const inc, /* <-- 0 or 1: increment or not */
114  const int *const n_r_sweeps,/* <-- >1: with reconstruction */
115  const int *const iwarnp, /* <-- verbosity level */
116  const int *const imligp, /* <-- type of clipping */
117  const cs_real_t *const epsrgp, /* <-- precision for iterative
118  gradient calculation */
119  const cs_real_t *const climgp, /* <-- clipping coefficient */
120  const cs_real_3_t coefav[], /* <-- boundary condition term */
121  const cs_real_33_t coefbv[], /* <-- boundary condition term */
122  cs_real_3_t pvar[], /* <-- gradient's base variable */
123  cs_real_33_t grad[] /* <-> gradient of the variable
124  (du_i/dx_j : gradv[][i][j]) */
125 );
126 
127 /*=============================================================================
128  * Public function prototypes
129  *============================================================================*/
130 
131 /*----------------------------------------------------------------------------
132  * Initialize gradient computation API.
133  *----------------------------------------------------------------------------*/
134 
135 void
137 
138 /*----------------------------------------------------------------------------
139  * Finalize gradient computation API.
140  *----------------------------------------------------------------------------*/
141 
142 void
144 
145 /*----------------------------------------------------------------------------*/
152 /*----------------------------------------------------------------------------*/
153 
154 void
156 
157 /*----------------------------------------------------------------------------*/
187 /*----------------------------------------------------------------------------*/
188 
189 void
190 cs_gradient_scalar(const char *var_name,
191  cs_gradient_type_t gradient_type,
192  cs_halo_type_t halo_type,
193  int inc,
194  bool recompute_cocg,
195  int n_r_sweeps,
196  int tr_dim,
197  int hyd_p_flag,
198  int w_stride,
199  int verbosity,
200  cs_gradient_limit_t clip_mode,
201  double epsilon,
202  double extrap,
203  double clip_coeff,
204  cs_real_3_t f_ext[],
205  const cs_real_t bc_coeff_a[],
206  const cs_real_t bc_coeff_b[],
207  cs_real_t var[restrict],
208  cs_real_t *restrict c_weight,
209  const cs_internal_coupling_t *cpl,
210  cs_real_t grad[restrict][3]);
211 
212 /*----------------------------------------------------------------------------*/
234 /*----------------------------------------------------------------------------*/
235 
236 void
237 cs_gradient_vector(const char *var_name,
238  cs_gradient_type_t gradient_type,
239  cs_halo_type_t halo_type,
240  int inc,
241  int n_r_sweeps,
242  int verbosity,
243  cs_gradient_limit_t clip_mode,
244  double epsilon,
245  double clip_coeff,
246  const cs_real_t bc_coeff_a[][3],
247  const cs_real_t bc_coeff_b[][3][3],
248  cs_real_t var[restrict][3],
249  cs_real_t *restrict c_weight,
250  const cs_internal_coupling_t *cpl,
251  cs_real_t gradv[restrict][3][3]);
252 
253 /*----------------------------------------------------------------------------*/
273 /*----------------------------------------------------------------------------*/
274 
275 void
276 cs_gradient_tensor(const char *var_name,
277  cs_gradient_type_t gradient_type,
278  cs_halo_type_t halo_type,
279  int inc,
280  int n_r_sweeps,
281  int verbosity,
282  cs_gradient_limit_t clip_mode,
283  double epsilon,
284  double clip_coeff,
285  const cs_real_6_t bc_coeff_a[],
286  const cs_real_66_t bc_coeff_b[],
287  cs_real_6_t *restrict var,
288  cs_real_63_t *restrict grad);
289 
290 /*----------------------------------------------------------------------------*/
324 /*----------------------------------------------------------------------------*/
325 
326 void
327 cs_gradient_scalar_synced_input(const char *var_name,
328  cs_gradient_type_t gradient_type,
329  cs_halo_type_t halo_type,
330  int inc,
331  bool recompute_cocg,
332  int n_r_sweeps,
333  int tr_dim,
334  int hyd_p_flag,
335  int w_stride,
336  int verbosity,
337  cs_gradient_limit_t clip_mode,
338  double epsilon,
339  double extrap,
340  double clip_coeff,
341  cs_real_t f_ext[][3],
342  const cs_real_t bc_coeff_a[],
343  const cs_real_t bc_coeff_b[],
344  const cs_real_t var[restrict],
345  const cs_real_t c_weight[restrict],
346  const cs_internal_coupling_t *cpl,
347  cs_real_t grad[restrict][3]);
348 
349 /*----------------------------------------------------------------------------*/
375 /*----------------------------------------------------------------------------*/
376 
377 void
378 cs_gradient_vector_synced_input(const char *var_name,
379  cs_gradient_type_t gradient_type,
380  cs_halo_type_t halo_type,
381  int inc,
382  int n_r_sweeps,
383  int verbosity,
384  cs_gradient_limit_t clip_mode,
385  double epsilon,
386  double clip_coeff,
387  const cs_real_t bc_coeff_a[][3],
388  const cs_real_t bc_coeff_b[][3][3],
389  const cs_real_t var[restrict][3],
390  const cs_real_t c_weight[restrict],
391  const cs_internal_coupling_t *cpl,
392  cs_real_t grad[restrict][3][3]);
393 
394 /*----------------------------------------------------------------------------*/
418 /*----------------------------------------------------------------------------*/
419 
420 void
421 cs_gradient_tensor_synced_input(const char *var_name,
422  cs_gradient_type_t gradient_type,
423  cs_halo_type_t halo_type,
424  int inc,
425  int n_r_sweeps,
426  int verbosity,
427  cs_gradient_limit_t clip_mode,
428  double epsilon,
429  double clip_coeff,
430  const cs_real_t bc_coeff_a[][6],
431  const cs_real_t bc_coeff_b[][6][6],
432  const cs_real_t var[restrict][6],
433  cs_real_63_t *restrict grad);
434 
435 /*----------------------------------------------------------------------------*/
458 /*----------------------------------------------------------------------------*/
459 
460 void
462  const cs_mesh_quantities_t *fvq,
463  cs_lnum_t c_id,
464  cs_halo_type_t halo_type,
465  const cs_real_t bc_coeff_a[],
466  const cs_real_t bc_coeff_b[],
467  const cs_real_t var[],
468  const cs_real_t c_weight[],
469  cs_real_t grad[3]);
470 
471 /*----------------------------------------------------------------------------*/
494 /*----------------------------------------------------------------------------*/
495 
496 void
498  const cs_mesh_quantities_t *fvq,
499  cs_lnum_t c_id,
500  cs_halo_type_t halo_type,
501  const cs_real_t bc_coeff_a[][3],
502  const cs_real_t bc_coeff_b[][3][3],
503  const cs_real_t var[restrict][3],
504  const cs_real_t c_weight[],
505  cs_real_t grad[3][3]);
506 
507 /*----------------------------------------------------------------------------*/
530 /*----------------------------------------------------------------------------*/
531 
532 void
534  const cs_mesh_quantities_t *fvq,
535  cs_lnum_t c_id,
536  cs_halo_type_t halo_type,
537  const cs_real_t bc_coeff_a[][6],
538  const cs_real_t bc_coeff_b[][6][6],
539  const cs_real_t var[restrict][6],
540  const cs_real_t c_weight[],
541  cs_real_t grad[6][3]);
542 
543 /*----------------------------------------------------------------------------
544  * Determine gradient type by Fortran "imrgra" value
545  *
546  * parameters:
547  * imrgra <-- Fortran gradient option
548  * gradient_type --> gradient type
549  * halo_type --> halo type
550  *----------------------------------------------------------------------------*/
551 
552 void
554  cs_gradient_type_t *gradient_type,
555  cs_halo_type_t *halo_type);
556 
557 /*----------------------------------------------------------------------------*/
558 
560 
561 #endif /* __CS_GRADIENT__ */
#define restrict
Definition: cs_defs.h:127
void cs_gradient_free_quantities(void)
Free saved gradient quantities.
Definition: cs_gradient.c:9150
cs_real_t cs_real_6_t[6]
vector of 6 floating-point values
Definition: cs_defs.h:322
Definition: cs_gradient.h:72
void cs_gradient_finalize(void)
Finalize gradient computation API.
Definition: cs_gradient.c:9115
void cs_gradient_tensor(const char *var_name, cs_gradient_type_t gradient_type, cs_halo_type_t halo_type, int inc, int n_r_sweeps, int verbosity, cs_gradient_limit_t clip_mode, double epsilon, double clip_coeff, const cs_real_6_t bc_coeff_a[], const cs_real_66_t bc_coeff_b[], cs_real_6_t *restrict var, cs_real_63_t *restrict grad)
Compute cell gradient of tensor.
Definition: cs_gradient.c:9416
Definition: cs_gradient.h:73
cs_real_t cs_real_66_t[6][6]
6x6 matrix of floating-point values
Definition: cs_defs.h:328
void cs_gradient_type_by_imrgra(int imrgra, cs_gradient_type_t *gradient_type, cs_halo_type_t *halo_type)
Definition: cs_gradient.c:10635
Definition: cs_internal_coupling.h:63
#define BEGIN_C_DECLS
Definition: cs_defs.h:495
Definition: cs_gradient.h:76
cs_gradient_limit_t
Definition: cs_gradient.h:70
void cs_gradient_tensor_synced_input(const char *var_name, cs_gradient_type_t gradient_type, cs_halo_type_t halo_type, int inc, int n_r_sweeps, int verbosity, cs_gradient_limit_t clip_mode, double epsilon, double clip_coeff, const cs_real_t bc_coeff_a[][6], const cs_real_t bc_coeff_b[][6][6], const cs_real_t var[restrict][6], cs_real_63_t *restrict grad)
Compute cell gradient of tensor.
Definition: cs_gradient.c:9715
double cs_real_t
Floating-point value.
Definition: cs_defs.h:307
void cs_gradient_scalar_synced_input(const char *var_name, cs_gradient_type_t gradient_type, cs_halo_type_t halo_type, int inc, bool recompute_cocg, int n_r_sweeps, int tr_dim, int hyd_p_flag, int w_stride, int verbosity, cs_gradient_limit_t clip_mode, double epsilon, double extrap, double clip_coeff, cs_real_t f_ext[][3], const cs_real_t bc_coeff_a[], const cs_real_t bc_coeff_b[], const cs_real_t var[restrict], const cs_real_t c_weight[restrict], const cs_internal_coupling_t *cpl, cs_real_t grad[restrict][3])
Compute cell gradient of scalar field or component of vector or tensor field.
Definition: cs_gradient.c:9523
Definition: cs_mesh.h:74
void cs_gradient_scalar_cell(const cs_mesh_t *m, const cs_mesh_quantities_t *fvq, cs_lnum_t c_id, cs_halo_type_t halo_type, const cs_real_t bc_coeff_a[], const cs_real_t bc_coeff_b[], const cs_real_t var[], const cs_real_t c_weight[], cs_real_t grad[3])
Compute the gradient of a scalar field at a given cell using least-squares reconstruction.
Definition: cs_gradient.c:9799
void cs_gradient_vector_cell(const cs_mesh_t *m, const cs_mesh_quantities_t *fvq, cs_lnum_t c_id, cs_halo_type_t halo_type, const cs_real_t bc_coeff_a[][3], const cs_real_t bc_coeff_b[][3][3], const cs_real_t var[restrict][3], const cs_real_t c_weight[], cs_real_t grad[3][3])
Compute the gradient of a vector field at a given cell using least-squares reconstruction.
Definition: cs_gradient.c:10053
Definition: cs_gradient.h:58
Definition: cs_gradient.h:62
Definition: cs_gradient.h:60
void grdpor(const int *const inc)
Definition: cs_gradient.c:8840
Definition: cs_mesh_quantities.h:89
cs_halo_type_t
Definition: cs_halo.h:50
cs_gradient_type_t
Definition: cs_gradient.h:56
void cgdvec(const int *const f_id, const int *const imrgra, const int *const inc, const int *const n_r_sweeps, const int *const iwarnp, const int *const imligp, const cs_real_t *const epsrgp, const cs_real_t *const climgp, const cs_real_3_t coefav[], const cs_real_33_t coefbv[], cs_real_3_t pvar[], cs_real_33_t grad[])
Definition: cs_gradient.c:9022
cs_real_t cs_real_3_t[3]
vector of 3 floating-point values
Definition: cs_defs.h:320
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:301
#define END_C_DECLS
Definition: cs_defs.h:496
void cs_gradient_tensor_cell(const cs_mesh_t *m, const cs_mesh_quantities_t *fvq, cs_lnum_t c_id, cs_halo_type_t halo_type, const cs_real_t bc_coeff_a[][6], const cs_real_t bc_coeff_b[][6][6], const cs_real_t var[restrict][6], const cs_real_t c_weight[], cs_real_t grad[6][3])
Compute the gradient of a tensor field at a given cell using least-squares reconstruction.
Definition: cs_gradient.c:10353
Definition: cs_gradient.h:59
#define CS_PROCF(x, y)
Definition: cs_defs.h:509
cs_real_t cs_real_33_t[3][3]
3x3 matrix of floating-point values
Definition: cs_defs.h:327
void cs_gradient_vector(const char *var_name, cs_gradient_type_t gradient_type, cs_halo_type_t halo_type, int inc, int n_r_sweeps, int verbosity, cs_gradient_limit_t clip_mode, double epsilon, double clip_coeff, const cs_real_t bc_coeff_a[][3], const cs_real_t bc_coeff_b[][3][3], cs_real_t var[restrict][3], cs_real_t *restrict c_weight, const cs_internal_coupling_t *cpl, cs_real_t gradv[restrict][3][3])
Compute cell gradient of vector field.
Definition: cs_gradient.c:9318
cs_real_t cs_real_63_t[6][3]
Definition: cs_defs.h:335
void cs_gradient_scalar(const char *var_name, cs_gradient_type_t gradient_type, cs_halo_type_t halo_type, int inc, bool recompute_cocg, int n_r_sweeps, int tr_dim, int hyd_p_flag, int w_stride, int verbosity, cs_gradient_limit_t clip_mode, double epsilon, double extrap, double clip_coeff, cs_real_3_t f_ext[], const cs_real_t bc_coeff_a[], const cs_real_t bc_coeff_b[], cs_real_t var[restrict], cs_real_t *restrict c_weight, const cs_internal_coupling_t *cpl, cs_real_t grad[restrict][3])
Compute cell gradient of scalar field or component of vector or tensor field.
Definition: cs_gradient.c:9198
const char * cs_gradient_type_name[]
void cs_gradient_initialize(void)
Initialize gradient computation API.
Definition: cs_gradient.c:9094
void cs_gradient_vector_synced_input(const char *var_name, cs_gradient_type_t gradient_type, cs_halo_type_t halo_type, int inc, int n_r_sweeps, int verbosity, cs_gradient_limit_t clip_mode, double epsilon, double clip_coeff, const cs_real_t bc_coeff_a[][3], const cs_real_t bc_coeff_b[][3][3], const cs_real_t var[restrict][3], const cs_real_t c_weight[restrict], const cs_internal_coupling_t *cpl, cs_real_t grad[restrict][3][3])
Compute cell gradient of vector field.
Definition: cs_gradient.c:9630
integer(c_int), pointer, save imrgra
type of gradient reconstruction
Definition: optcal.f90:258