programmer's documentation
cs_mesh_quantities.h
Go to the documentation of this file.
1 #ifndef __CS_MESH_QUANTITIES_H__
2 #define __CS_MESH_QUANTITIES_H__
3 
4 /*============================================================================
5  * Management of mesh quantities
6  *============================================================================*/
7 
8 /*
9  This file is part of Code_Saturne, a general-purpose CFD tool.
10 
11  Copyright (C) 1998-2019 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_mesh.h"
36 #include "cs_internal_coupling.h"
37 
38 /*----------------------------------------------------------------------------*/
39 
41 
42 /*=============================================================================
43  * Macro definitions
44  *============================================================================*/
45 
52 /*
53  * Cell quantities correction types
54  */
55 
57 #define CS_BAD_CELLS_WARPED_CORRECTION (1 << 0)
58 
60 #define CS_BAD_CELLS_REGULARISATION (1 << 1)
61 
63 #define CS_CELL_FACE_CENTER_CORRECTION (1 << 2)
64 
66 #define CS_CELL_CENTER_CORRECTION (1 << 3)
67 
69 #define CS_FACE_DISTANCE_CLIP (1 << 4)
70 
72 #define CS_FACE_RECONSTRUCTION_CLIP (1 << 5)
73 
75 #define CS_CELL_VOLUME_RATIO_CORRECTION (1 << 6)
76 
80 #define CS_FACE_CENTER_REFINE (1 << 7)
81 
84 /*============================================================================
85  * Type definition
86  *============================================================================*/
87 
88 /* Structure associated to mesh quantities management */
89 
90 typedef struct {
91 
92  cs_real_t *cell_cen; /* Cell center coordinates */
93  cs_real_t *cell_vol; /* Cell volume */
94  cs_real_t *cell_f_vol; /* Cell fluid volume */
95 
96  cs_real_t *i_face_normal; /* Surface normal of interior faces.
97  (L2 norm equals area of the face) */
98  cs_real_t *b_face_normal; /* Surface normal of border faces.
99  (L2 norm equals area of the face) */
100  cs_real_t *i_f_face_normal;/* Fluid Surface normal of interior faces.
101  (L2 norm equals area of the face) */
102  cs_real_t *b_f_face_normal;/* Fluid Surface normal of border faces.
103  (L2 norm equals area of the face) */
104  cs_real_t *i_face_cog; /* Center of gravity of interior faces */
105  cs_real_t *b_face_cog; /* Center of gravity of border faces */
106 
107  cs_real_t *i_face_surf; /* Surface of interior faces. */
108  cs_real_t *b_face_surf; /* Surface of boundary faces. */
109 
110  cs_real_t *i_f_face_surf; /* Fluid surface of interior faces. */
111  cs_real_t *b_f_face_surf; /* Fluid surface of boundary faces. */
112 
113  cs_real_2_t *i_f_face_factor;/* Fluid surface factor of interior faces. */
114  cs_real_t *b_f_face_factor;/* Fluid surface factor of boundary faces. */
115 
116  cs_real_t *dijpf; /* Vector I'J' for interior faces */
117  cs_real_t *diipb; /* Vector II' for border faces */
118  cs_real_t *dofij; /* Vector OF for interior faces */
119  cs_real_t *diipf; /* Vector II' for interior faces */
120  cs_real_t *djjpf; /* Vector JJ' for interior faces */
121 
122  cs_real_t *i_dist; /* Distance between the cell center and
123  the center of gravity of interior faces */
124  cs_real_t *b_dist; /* Distance between the cell center and
125  the center of gravity of border faces */
126 
127  cs_real_t *weight; /* Interior faces weighting factor */
128 
129  cs_real_t min_vol; /* Minimum cell volume */
130  cs_real_t max_vol; /* Maximum cell volume */
131  cs_real_t tot_vol; /* Total volume */
132 
133  cs_real_t min_f_vol; /* Minimum cell volume */
134  cs_real_t max_f_vol; /* Maximum cell volume */
135  cs_real_t tot_f_vol; /* Total volume */
136 
137  cs_real_33_t *cocgb_s_it; /* coupling of gradient components for
138  iterative reconstruction at boundary */
139  cs_real_33_t *cocg_s_it; /* coupling of gradient components for
140  iterative reconstruction */
141  cs_real_33_t *cocgb_s_lsq; /* coupling of gradient components for
142  least-square reconstruction at boundary */
143 
144  cs_real_33_t *cocg_it; /* Interleaved cocg matrix
145  for iterative gradients */
146  cs_real_33_t *cocg_lsq; /* Interleaved cocg matrix
147  for least square gradients */
148 
149  cs_real_t *corr_grad_lin_det; /* Determinant of geometrical matrix
150  linear gradient correction */
151  cs_real_33_t *corr_grad_lin; /* Geometrical matrix
152  linear gradient correction */
153 
154  cs_int_t *b_sym_flag; /* Symmetry flag for boundary faces */
155  cs_int_t *c_solid_flag; /* Is the fluid volume 0 flag */
156  unsigned *bad_cell_flag; /* Flag (mask) for bad cells detected */
157 
159 
160 /*============================================================================
161  * Static global variables
162  *============================================================================*/
163 
164 /* Pointer to mesh quantities structure associated to the main mesh */
165 
167 
168 /* Flag (mask) to activate bad cells correction */
169 extern unsigned cs_glob_mesh_quantities_flag;
170 
171 /* Choice of the porous model */
172 extern int cs_glob_porous_model;
173 
174 /*============================================================================
175  * Public function prototypes for API Fortran
176  *============================================================================*/
177 
178 /*----------------------------------------------------------------------------
179  * Set behavior for computing the cocg matrixes for the iterative algo
180  * and for the Least square method for scalar and vector gradients.
181  *
182  * Fortran interface :
183  *
184  * subroutine comcoc (imrgra)
185  * *****************
186  *
187  * integer imrgra : <-- : gradient reconstruction option
188  *----------------------------------------------------------------------------*/
189 
190 void
191 CS_PROCF (comcoc, COMCOC) (const cs_int_t *const imrgra);
192 
193 /*=============================================================================
194  * Public function prototypes
195  *============================================================================*/
196 
197 /*----------------------------------------------------------------------------*/
207 /*----------------------------------------------------------------------------*/
208 
209 int
210 cs_mesh_quantities_cell_cen_choice(int algo_choice);
211 
212 /*----------------------------------------------------------------------------*/
223 /*----------------------------------------------------------------------------*/
224 
225 int
226 cs_mesh_quantities_face_cog_choice(int algo_choice);
227 
228 /*----------------------------------------------------------------------------
229  * Compute cocg for iterative gradient reconstruction for scalars.
230  *
231  * parameters:
232  * gradient_option <-- gradient option (Fortran IMRGRA)
233  *----------------------------------------------------------------------------*/
234 
235 void
236 cs_mesh_quantities_set_cocg_options(int gradient_option);
237 
238 /*----------------------------------------------------------------------------
239  * Compute Fluid volumes and fluid surface in addition to cell volume and surfaces.
240  *
241  * parameters:
242  * porous_model <-- porous model option (> 0 for porosity)
243  *----------------------------------------------------------------------------*/
244 
245 void
246 cs_mesh_quantities_set_porous_model(int porous_model);
247 
248 /*----------------------------------------------------------------------------*/
254 /*----------------------------------------------------------------------------*/
255 
258 
259 /*----------------------------------------------------------------------------*/
267 /*----------------------------------------------------------------------------*/
268 
271 
272 /*----------------------------------------------------------------------------*/
278 /*----------------------------------------------------------------------------*/
279 
280 void
282 
283 /*----------------------------------------------------------------------------*/
290 /*----------------------------------------------------------------------------*/
291 
292 void
294  cs_mesh_quantities_t *mesh_quantities);
295 
296 /*----------------------------------------------------------------------------*/
303 /*----------------------------------------------------------------------------*/
304 
305 void
307  cs_mesh_quantities_t *mesh_quantities);
308 
309 /*----------------------------------------------------------------------------
310  * Compute fluid mesh quantities
311  *
312  * parameters:
313  * mesh <-- pointer to a cs_mesh_t structure
314  * mesh_quantities <-> pointer to a cs_mesh_quantities_t structure
315  *----------------------------------------------------------------------------*/
316 
317 void
319  cs_mesh_quantities_t *mesh_quantities);
320 
321 /*----------------------------------------------------------------------------
322  * Compute the total, min, and max fluid volumes of cells
323  *
324  * parameters:
325  * mesh <-- pointer to mesh structure
326  * mesh_quantities <-> pointer to a mesh quantities structure
327  *----------------------------------------------------------------------------*/
328 
329 void
331  cs_mesh_quantities_t *mesh_quantities);
332 
333 /*----------------------------------------------------------------------------
334  * Compute fluid section mesh quantities at the initial step
335  *
336  * parameters:
337  * mesh <-- pointer to a cs_mesh_t structure
338  * mesh_quantities <-> pointer to a cs_mesh_quantities_t structure
339  *----------------------------------------------------------------------------*/
340 
341 void
343  cs_mesh_quantities_t *mesh_quantities);
344 
345 /*----------------------------------------------------------------------------
346  * Compute mesh quantities
347  *
348  * parameters:
349  * mesh <-- pointer to a cs_mesh_t structure
350  * mesh_quantities <-> pointer to a cs_mesh_quantities_t structure
351  *----------------------------------------------------------------------------*/
352 
353 void
355  cs_mesh_quantities_t *mesh_quantities);
356 
357 /*----------------------------------------------------------------------------
358  * Compute internal and border face normal.
359  *
360  * parameters:
361  * mesh <-- pointer to a cs_mesh_t structure
362  * p_i_face_normal <-> pointer to the internal face normal array
363  * p_b_face_normal <-> pointer to the border face normal array
364  *----------------------------------------------------------------------------*/
365 
366 void
368  cs_real_t *p_i_face_normal[],
369  cs_real_t *p_b_face_normal[]);
370 
371 /*----------------------------------------------------------------------------
372  * Compute interior face centers and normals.
373  *
374  * The corresponding arrays are allocated by this function, and it is the
375  * caller's responsibility to free them when they are no longer needed.
376  *
377  * parameters:
378  * mesh <-- pointer to a cs_mesh_t structure
379  * p_i_face_cog <-> pointer to the interior face center array
380  * p_i_face_normal <-> pointer to the interior face normal array
381  *----------------------------------------------------------------------------*/
382 
383 void
385  cs_real_t *p_i_face_cog[],
386  cs_real_t *p_i_face_normal[]);
387 
388 /*----------------------------------------------------------------------------
389  * Compute border face centers and normals.
390  *
391  * The corresponding arrays are allocated by this function, and it is the
392  * caller's responsibility to free them when they are no longer needed.
393  *
394  * parameters:
395  * mesh <-- pointer to a cs_mesh_t structure
396  * p_b_face_cog <-> pointer to the border face center array
397  * p_b_face_normal <-> pointer to the border face normal array
398  *----------------------------------------------------------------------------*/
399 
400 void
402  cs_real_t *p_b_face_cog[],
403  cs_real_t *p_b_face_normal[]);
404 
405 /*----------------------------------------------------------------------------*/
425 /*----------------------------------------------------------------------------*/
426 
427 void
429  const cs_real_t i_face_norm[],
430  const cs_real_t i_face_cog[],
431  const cs_real_t b_face_norm[],
432  const cs_real_t b_face_cog[],
433  cs_real_t cell_cen[]);
434 
435 /*----------------------------------------------------------------------------
436  * Compute cell volumes.
437  *
438  * The corresponding array is allocated by this function, and it is the
439  * caller's responsability to free it when they are no longer needed.
440  *
441  * parameters:
442  * mesh <-- pointer to a cs_mesh_t structure
443  *
444  * return:
445  * pointer to newly allocated cell volumes array
446  *----------------------------------------------------------------------------*/
447 
448 cs_real_t *
450 
451 /*----------------------------------------------------------------------------
452  * Check that no negative volumes are present, and exit on error otherwise.
453  *
454  * parameters:
455  * mesh <-- pointer to mesh structure
456  * mesh_quantities <-- pointer to mesh quantities structure
457  * allow_error <-- 1 if errors are allowed, 0 otherwise
458  *----------------------------------------------------------------------------*/
459 
460 void
462  const cs_mesh_quantities_t *mesh_quantities,
463  int allow_error);
464 
465 /*----------------------------------------------------------------------------
466  * Update mesh quantities relative to extended ghost cells when the
467  * neighborhood is reduced.
468  *
469  * parameters:
470  * mesh <-- pointer to a cs_mesh_t structure
471  * mesh_quantities <-> pointer to a cs_mesh_quantities_t structure
472  *----------------------------------------------------------------------------*/
473 
474 void
476  cs_mesh_quantities_t *mesh_quantities);
477 
478 /*----------------------------------------------------------------------------
479  * Return the number of times mesh quantities have been computed.
480  *
481  * returns:
482  * number of times mesh quantities have been computed
483  *----------------------------------------------------------------------------*/
484 
485 int
487 
488 /*----------------------------------------------------------------------------*/
498 /*----------------------------------------------------------------------------*/
499 
500 void
502  const cs_mesh_quantities_t *mq,
503  int n_passes,
504  cs_real_t b_thickness[]);
505 
506 /*----------------------------------------------------------------------------*/
515 /*----------------------------------------------------------------------------*/
516 
517 void
519  const cs_mesh_quantities_t *mq,
520  int n_passes,
521  cs_real_t b_thickness[]);
522 
523 /*----------------------------------------------------------------------------*/
527 /*----------------------------------------------------------------------------*/
528 
529 void
531 
532 /*----------------------------------------------------------------------------
533  * Dump a cs_mesh_quantities_t structure
534  *
535  * parameters:
536  * mesh <-- pointer to a cs_mesh_t structure
537  * mesh_quantities <-- pointer to a cs_mesh_quantities_t structure
538  *----------------------------------------------------------------------------*/
539 
540 void
542  const cs_mesh_quantities_t *mesh_quantities);
543 
544 /*----------------------------------------------------------------------------
545  * Compute 3x3 matrix cocg for the scalar gradient least squares algorithm
546  * adapted for internal coupling.
547  *
548  * parameters:
549  * m <-- mesh
550  * fvq <-> mesh quantities
551  * ce <-> coupling
552  *----------------------------------------------------------------------------*/
553 
554 void
558 
559 /*----------------------------------------------------------------------------
560  * Compute 3x3 matrix cocg for the scalar gradient iterative algorithm
561  * adapted for internal coupling.
562  *
563  * parameters:
564  * m <-- mesh
565  * fvq <-> mesh quantities
566  * ce <-> coupling
567  *----------------------------------------------------------------------------*/
568 
569 void
573 
574 /*----------------------------------------------------------------------------*/
575 
577 
578 #endif /* __CS_MESH_QUANTITIES_H__ */
void cs_mesh_quantities_check_vol(const cs_mesh_t *mesh, const cs_mesh_quantities_t *mesh_quantities, int allow_error)
Definition: cs_mesh_quantities.c:3735
cs_real_33_t * cocgb_s_lsq
Definition: cs_mesh_quantities.h:141
void cs_mesh_quantities_reduce_extended(const cs_mesh_t *mesh, cs_mesh_quantities_t *mesh_quantities)
Definition: cs_mesh_quantities.c:3787
void cs_mesh_quantities_dump(const cs_mesh_t *mesh, const cs_mesh_quantities_t *mesh_quantities)
Definition: cs_mesh_quantities.c:3997
cs_real_t cs_real_2_t[2]
vector of 2 floating-point values
Definition: cs_defs.h:314
cs_real_t * b_dist
Definition: cs_mesh_quantities.h:124
void cs_mesh_quantities_b_thickness_v(const cs_mesh_t *m, const cs_mesh_quantities_t *mq, int n_passes, cs_real_t b_thickness[])
Determine local boundary thickness around each vertex.
Definition: cs_mesh_quantities.c:3820
cs_real_t * corr_grad_lin_det
Definition: cs_mesh_quantities.h:149
cs_real_t * cell_f_vol
Definition: cs_mesh_quantities.h:94
cs_real_t * b_face_surf
Definition: cs_mesh_quantities.h:108
cs_real_t * cs_mesh_quantities_cell_volume(const cs_mesh_t *mesh)
Definition: cs_mesh_quantities.c:3694
cs_real_t * djjpf
Definition: cs_mesh_quantities.h:120
void cs_mesh_quantities_compute_preprocess(const cs_mesh_t *mesh, cs_mesh_quantities_t *mesh_quantities)
Compute mesh quantities needed for preprocessing.
Definition: cs_mesh_quantities.c:2867
cs_real_t min_f_vol
Definition: cs_mesh_quantities.h:133
cs_int_t * c_solid_flag
Definition: cs_mesh_quantities.h:155
Definition: cs_internal_coupling.h:62
cs_real_t max_f_vol
Definition: cs_mesh_quantities.h:134
#define BEGIN_C_DECLS
Definition: cs_defs.h:467
int cs_int_t
Fortran-compatible integer.
Definition: cs_defs.h:301
void cs_compute_cell_cocg_it_coupling(const cs_mesh_t *m, cs_mesh_quantities_t *fvq, cs_internal_coupling_t *ce)
Definition: cs_mesh_quantities.c:4112
cs_real_33_t * corr_grad_lin
Definition: cs_mesh_quantities.h:151
cs_mesh_quantities_t * cs_mesh_quantities_destroy(cs_mesh_quantities_t *mesh_quantities)
Destroy a mesh quantities structure.
Definition: cs_mesh_quantities.c:2797
int cs_mesh_quantities_face_cog_choice(int algo_choice)
Query or modification of the option for computing face centers.
Definition: cs_mesh_quantities.c:2658
cs_real_t * diipf
Definition: cs_mesh_quantities.h:119
cs_real_t * dofij
Definition: cs_mesh_quantities.h:118
cs_real_t * b_face_cog
Definition: cs_mesh_quantities.h:105
double cs_real_t
Floating-point value.
Definition: cs_defs.h:302
void cs_mesh_quantities_face_normal(const cs_mesh_t *mesh, cs_real_t *p_i_face_normal[], cs_real_t *p_b_face_normal[])
Definition: cs_mesh_quantities.c:3443
cs_real_t max_vol
Definition: cs_mesh_quantities.h:130
unsigned * bad_cell_flag
Definition: cs_mesh_quantities.h:156
Definition: cs_mesh.h:63
void cs_mesh_quantities_free_all(cs_mesh_quantities_t *mq)
Reset a mesh quantities structure to its empty initial state.
Definition: cs_mesh_quantities.c:2815
cs_real_33_t * cocg_s_it
Definition: cs_mesh_quantities.h:139
cs_real_t * i_f_face_normal
Definition: cs_mesh_quantities.h:100
void cs_mesh_init_fluid_sections(const cs_mesh_t *mesh, cs_mesh_quantities_t *mesh_quantities)
Definition: cs_mesh_quantities.c:3362
void cs_mesh_quantities_fluid_vol_reductions(const cs_mesh_t *mesh, cs_mesh_quantities_t *mesh_quantities)
Definition: cs_mesh_quantities.c:3322
int cs_mesh_quantities_cell_cen_choice(int algo_choice)
Query or modification of the option for computing cell centers.
Definition: cs_mesh_quantities.c:2636
cs_real_t tot_vol
Definition: cs_mesh_quantities.h:131
cs_real_t tot_f_vol
Definition: cs_mesh_quantities.h:135
void cs_mesh_quantities_set_cocg_options(int gradient_option)
Definition: cs_mesh_quantities.c:2674
cs_real_t * dijpf
Definition: cs_mesh_quantities.h:116
void cs_mesh_quantities_b_faces(const cs_mesh_t *mesh, cs_real_t *p_b_face_cog[], cs_real_t *p_b_face_normal[])
Definition: cs_mesh_quantities.c:3523
cs_real_t * cell_cen
Definition: cs_mesh_quantities.h:92
cs_mesh_quantities_t * cs_glob_mesh_quantities
cs_real_t * i_dist
Definition: cs_mesh_quantities.h:122
cs_real_t * i_face_normal
Definition: cs_mesh_quantities.h:96
Definition: cs_mesh_quantities.h:90
cs_real_2_t * i_f_face_factor
Definition: cs_mesh_quantities.h:113
cs_real_33_t * cocgb_s_it
Definition: cs_mesh_quantities.h:137
int cs_glob_porous_model
cs_mesh_quantities_t * cs_mesh_quantities_create(void)
Create a mesh quantities structure.
Definition: cs_mesh_quantities.c:2743
void comcoc(const cs_int_t *const imrgra)
Definition: cs_mesh_quantities.c:2576
unsigned cs_glob_mesh_quantities_flag
void cs_mesh_quantities_log_setup(void)
Log mesh quantities options to setup file.
Definition: cs_mesh_quantities.c:3952
cs_real_t * b_f_face_surf
Definition: cs_mesh_quantities.h:111
cs_real_t * weight
Definition: cs_mesh_quantities.h:127
cs_real_t * b_f_face_factor
Definition: cs_mesh_quantities.h:114
cs_real_t min_vol
Definition: cs_mesh_quantities.h:129
#define END_C_DECLS
Definition: cs_defs.h:468
cs_real_33_t * cocg_it
Definition: cs_mesh_quantities.h:144
void cs_mesh_quantities_cell_faces_cog(const cs_mesh_t *mesh, const cs_real_t i_face_norm[], const cs_real_t i_face_cog[], const cs_real_t b_face_norm[], const cs_real_t b_face_cog[], cs_real_t cell_cen[])
Compute approximate cells centers as the mean of the given face centers weighted by the associated su...
Definition: cs_mesh_quantities.c:3566
cs_real_t * i_f_face_surf
Definition: cs_mesh_quantities.h:110
void cs_compute_cell_cocg_lsq_coupling(const cs_mesh_t *m, cs_mesh_quantities_t *fvq, cs_internal_coupling_t *ce)
Definition: cs_mesh_quantities.c:4094
#define CS_PROCF(x, y)
Definition: cs_defs.h:481
void cs_mesh_quantities_fluid_compute(const cs_mesh_t *mesh, cs_mesh_quantities_t *mesh_quantities)
Definition: cs_mesh_quantities.c:3306
cs_real_t cs_real_33_t[3][3]
3x3 matrix of floating-point values
Definition: cs_defs.h:321
cs_real_t * b_face_normal
Definition: cs_mesh_quantities.h:98
cs_real_t * diipb
Definition: cs_mesh_quantities.h:117
cs_real_t * cell_vol
Definition: cs_mesh_quantities.h:93
void cs_mesh_quantities_b_thickness_f(const cs_mesh_t *m, const cs_mesh_quantities_t *mq, int n_passes, cs_real_t b_thickness[])
Determine local boundary thickness around each boundary face.
Definition: cs_mesh_quantities.c:3910
void cs_mesh_quantities_compute(const cs_mesh_t *mesh, cs_mesh_quantities_t *mesh_quantities)
Compute mesh quantities.
Definition: cs_mesh_quantities.c:3101
void cs_mesh_quantities_sup_vectors(const cs_mesh_t *mesh, cs_mesh_quantities_t *mesh_quantities)
Definition: cs_mesh_quantities.c:3408
cs_real_t * i_face_surf
Definition: cs_mesh_quantities.h:107
int cs_mesh_quantities_compute_count(void)
Definition: cs_mesh_quantities.c:3802
cs_real_t * i_face_cog
Definition: cs_mesh_quantities.h:104
cs_int_t * b_sym_flag
Definition: cs_mesh_quantities.h:154
Definition: mesh.f90:26
integer(c_int), pointer, save imrgra
type of gradient reconstruction
Definition: optcal.f90:286
cs_real_33_t * cocg_lsq
Definition: cs_mesh_quantities.h:146
cs_real_t * b_f_face_normal
Definition: cs_mesh_quantities.h:102
void cs_mesh_quantities_set_porous_model(int porous_model)
Definition: cs_mesh_quantities.c:2729
void cs_mesh_quantities_i_faces(const cs_mesh_t *mesh, cs_real_t *p_i_face_cog[], cs_real_t *p_i_face_normal[])
Definition: cs_mesh_quantities.c:3490