7.1
general 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-2021 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 
37 /*----------------------------------------------------------------------------*/
38 
40 
41 /*=============================================================================
42  * Macro definitions
43  *============================================================================*/
44 
51 /*
52  * Cell quantities correction types
53  */
54 
56 #define CS_BAD_CELLS_WARPED_CORRECTION (1 << 0)
57 
59 #define CS_BAD_CELLS_REGULARISATION (1 << 1)
60 
62 #define CS_CELL_FACE_CENTER_CORRECTION (1 << 2)
63 
65 #define CS_CELL_CENTER_CORRECTION (1 << 3)
66 
68 #define CS_FACE_DISTANCE_CLIP (1 << 4)
69 
71 #define CS_FACE_RECONSTRUCTION_CLIP (1 << 5)
72 
74 #define CS_CELL_VOLUME_RATIO_CORRECTION (1 << 6)
75 
79 #define CS_FACE_CENTER_REFINE (1 << 7)
80 
83 /*============================================================================
84  * Type definition
85  *============================================================================*/
86 
87 /* Structure associated to mesh quantities management */
88 
89 typedef struct {
90 
91  cs_real_t *cell_cen; /* Cell center coordinates */
92  cs_real_t *cell_vol; /* Cell volume */
93  cs_real_t *cell_f_vol; /* Cell fluid volume */
94 
95  cs_real_t *i_face_normal; /* Surface normal of interior faces.
96  (L2 norm equals area of the face) */
97  cs_real_t *b_face_normal; /* Surface normal of border faces.
98  (L2 norm equals area of the face) */
99  cs_real_t *i_f_face_normal;/* Fluid surface normal of interior faces.
100  (L2 norm equals area of the face) */
101  cs_real_t *b_f_face_normal;/* Fluid surface normal of border faces.
102  (L2 norm equals area of the face) */
103  cs_real_t *i_face_cog; /* Center of gravity of interior faces */
104  cs_real_t *b_face_cog; /* Center of gravity of border faces */
105 
106  cs_real_t *i_face_surf; /* Surface of interior faces. */
107  cs_real_t *b_face_surf; /* Surface of boundary faces. */
108 
109  cs_real_t *i_f_face_surf; /* Fluid surface of interior faces. */
110  cs_real_t *b_f_face_surf; /* Fluid surface of boundary faces. */
111 
112  cs_real_2_t *i_f_face_factor;/* Fluid surface factor of interior faces. */
113  cs_real_t *b_f_face_factor;/* Fluid surface factor of boundary faces. */
114 
115  cs_real_t *dijpf; /* Vector I'J' for interior faces */
116  cs_real_t *diipb; /* Vector II' for border faces */
117  cs_real_t *dofij; /* Vector OF for interior faces */
118  cs_real_t *diipf; /* Vector II' for interior faces */
119  cs_real_t *djjpf; /* Vector JJ' for interior faces */
120 
121  cs_real_t *i_dist; /* Distance between the centers of the two
122  cells sharing an interior face */
123  cs_real_t *b_dist; /* Distance between the cell center and
124  the center of gravity of border faces */
125 
126  cs_real_t *weight; /* Interior faces weighting factor */
127 
128  cs_real_t min_vol; /* Minimum cell volume */
129  cs_real_t max_vol; /* Maximum cell volume */
130  cs_real_t tot_vol; /* Total volume */
131 
132  cs_real_t min_f_vol; /* Minimum cell volume */
133  cs_real_t max_f_vol; /* Maximum cell volume */
134  cs_real_t tot_f_vol; /* Total volume */
135 
136  cs_real_t *corr_grad_lin_det; /* Determinant of geometrical matrix
137  linear gradient correction */
138  cs_real_33_t *corr_grad_lin; /* Geometrical matrix
139  linear gradient correction */
140 
141  int *b_sym_flag; /* Symmetry flag for boundary faces */
142  int has_disable_flag; /* Is the cell disabled?
143  0: unactivated
144  1: activated */
145  int *c_disable_flag; /* Is the cell disabled?
146  used for fluid solid and porous models */
147  unsigned *bad_cell_flag; /* Flag (mask) for bad cells detected */
148 
150 
151 /*============================================================================
152  * Global variables
153  *============================================================================*/
154 
155 /* Pointer to mesh quantities structure associated to the main mesh */
156 
158 
159 /* Flag (mask) to activate bad cells correction */
160 extern unsigned cs_glob_mesh_quantities_flag;
161 
162 /*=============================================================================
163  * Public function prototypes
164  *============================================================================*/
165 
166 /*----------------------------------------------------------------------------*/
176 /*----------------------------------------------------------------------------*/
177 
178 int
179 cs_mesh_quantities_cell_cen_choice(int algo_choice);
180 
181 /*----------------------------------------------------------------------------*/
192 /*----------------------------------------------------------------------------*/
193 
194 int
195 cs_mesh_quantities_face_cog_choice(int algo_choice);
196 
197 /*----------------------------------------------------------------------------*/
203 /*----------------------------------------------------------------------------*/
204 
207 
208 /*----------------------------------------------------------------------------*/
216 /*----------------------------------------------------------------------------*/
217 
220 
221 /*----------------------------------------------------------------------------*/
227 /*----------------------------------------------------------------------------*/
228 
229 void
231 
232 /*----------------------------------------------------------------------------*/
239 /*----------------------------------------------------------------------------*/
240 
241 void
244 
245 /*----------------------------------------------------------------------------*/
252 /*----------------------------------------------------------------------------*/
253 
254 void
257 
258 /*----------------------------------------------------------------------------
259  * Compute fluid mesh quantities
260  *
261  * parameters:
262  * mesh <-- pointer to a cs_mesh_t structure
263  * mesh_quantities <-> pointer to a cs_mesh_quantities_t structure
264  *----------------------------------------------------------------------------*/
265 
266 void
268  cs_mesh_quantities_t *mesh_quantities);
269 
270 /*----------------------------------------------------------------------------
271  * Compute the total, min, and max fluid volumes of cells
272  *
273  * parameters:
274  * mesh <-- pointer to mesh structure
275  * mesh_quantities <-> pointer to a mesh quantities structure
276  *----------------------------------------------------------------------------*/
277 
278 void
280  cs_mesh_quantities_t *mesh_quantities);
281 
282 /*----------------------------------------------------------------------------
283  * Compute fluid section mesh quantities at the initial step
284  *
285  * parameters:
286  * mesh <-- pointer to a cs_mesh_t structure
287  * mesh_quantities <-> pointer to a cs_mesh_quantities_t structure
288  *----------------------------------------------------------------------------*/
289 
290 void
292  cs_mesh_quantities_t *mesh_quantities);
293 
294 /*----------------------------------------------------------------------------
295  * Compute mesh quantities
296  *
297  * parameters:
298  * mesh <-- pointer to a cs_mesh_t structure
299  * mesh_quantities <-> pointer to a cs_mesh_quantities_t structure
300  *----------------------------------------------------------------------------*/
301 
302 void
304  cs_mesh_quantities_t *mesh_quantities);
305 
306 /*----------------------------------------------------------------------------
307  * Compute internal and border face normal.
308  *
309  * parameters:
310  * mesh <-- pointer to a cs_mesh_t structure
311  * p_i_face_normal <-> pointer to the internal face normal array
312  * p_b_face_normal <-> pointer to the border face normal array
313  *----------------------------------------------------------------------------*/
314 
315 void
317  cs_real_t *p_i_face_normal[],
318  cs_real_t *p_b_face_normal[]);
319 
320 /*----------------------------------------------------------------------------
321  * Compute interior face centers and normals.
322  *
323  * The corresponding arrays are allocated by this function, and it is the
324  * caller's responsibility to free them when they are no longer needed.
325  *
326  * parameters:
327  * mesh <-- pointer to a cs_mesh_t structure
328  * p_i_face_cog <-> pointer to the interior face center array
329  * p_i_face_normal <-> pointer to the interior face normal array
330  *----------------------------------------------------------------------------*/
331 
332 void
334  cs_real_t *p_i_face_cog[],
335  cs_real_t *p_i_face_normal[]);
336 
337 /*----------------------------------------------------------------------------
338  * Compute border face centers and normals.
339  *
340  * The corresponding arrays are allocated by this function, and it is the
341  * caller's responsibility to free them when they are no longer needed.
342  *
343  * parameters:
344  * mesh <-- pointer to a cs_mesh_t structure
345  * p_b_face_cog <-> pointer to the border face center array
346  * p_b_face_normal <-> pointer to the border face normal array
347  *----------------------------------------------------------------------------*/
348 
349 void
351  cs_real_t *p_b_face_cog[],
352  cs_real_t *p_b_face_normal[]);
353 
354 /*----------------------------------------------------------------------------*/
374 /*----------------------------------------------------------------------------*/
375 
376 void
378  const cs_real_t i_face_norm[],
379  const cs_real_t i_face_cog[],
380  const cs_real_t b_face_norm[],
381  const cs_real_t b_face_cog[],
382  cs_real_t cell_cen[]);
383 
384 /*----------------------------------------------------------------------------
385  * Compute cell volumes.
386  *
387  * The corresponding array is allocated by this function, and it is the
388  * caller's responsability to free it when they are no longer needed.
389  *
390  * parameters:
391  * mesh <-- pointer to a cs_mesh_t structure
392  *
393  * return:
394  * pointer to newly allocated cell volumes array
395  *----------------------------------------------------------------------------*/
396 
397 cs_real_t *
399 
400 /*----------------------------------------------------------------------------
401  * Check that no negative volumes are present, and exit on error otherwise.
402  *
403  * parameters:
404  * mesh <-- pointer to mesh structure
405  * mesh_quantities <-- pointer to mesh quantities structure
406  * allow_error <-- 1 if errors are allowed, 0 otherwise
407  *----------------------------------------------------------------------------*/
408 
409 void
411  const cs_mesh_quantities_t *mesh_quantities,
412  int allow_error);
413 
414 /*----------------------------------------------------------------------------*/
427 /*----------------------------------------------------------------------------*/
428 
429 cs_real_6_t *
431  cs_real_t tolerance);
432 
433 /*----------------------------------------------------------------------------
434  * Return the number of times mesh quantities have been computed.
435  *
436  * returns:
437  * number of times mesh quantities have been computed
438  *----------------------------------------------------------------------------*/
439 
440 int
442 
443 /*----------------------------------------------------------------------------*/
453 /*----------------------------------------------------------------------------*/
454 
455 void
457  const cs_mesh_quantities_t *mq,
458  int n_passes,
459  cs_real_t b_thickness[]);
460 
461 /*----------------------------------------------------------------------------*/
470 /*----------------------------------------------------------------------------*/
471 
472 void
474  const cs_mesh_quantities_t *mq,
475  int n_passes,
476  cs_real_t b_thickness[]);
477 
478 /*----------------------------------------------------------------------------*/
482 /*----------------------------------------------------------------------------*/
483 
484 void
486 
487 /*----------------------------------------------------------------------------
488  * Dump a cs_mesh_quantities_t structure
489  *
490  * parameters:
491  * mesh <-- pointer to a cs_mesh_t structure
492  * mesh_quantities <-- pointer to a cs_mesh_quantities_t structure
493  *----------------------------------------------------------------------------*/
494 
495 void
497  const cs_mesh_quantities_t *mesh_quantities);
498 
499 /*----------------------------------------------------------------------------*/
500 
502 
503 #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:3135
void cs_mesh_quantities_dump(const cs_mesh_t *mesh, const cs_mesh_quantities_t *mesh_quantities)
Definition: cs_mesh_quantities.c:3476
int has_disable_flag
Definition: cs_mesh_quantities.h:142
cs_real_t cs_real_2_t[2]
vector of 2 floating-point values
Definition: cs_defs.h:334
cs_real_t * b_dist
Definition: cs_mesh_quantities.h:123
cs_real_t cs_real_6_t[6]
vector of 6 floating-point values
Definition: cs_defs.h:337
void cs_mesh_quantities_compute(const cs_mesh_t *m, cs_mesh_quantities_t *mq)
Compute mesh quantities.
Definition: cs_mesh_quantities.c:2550
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:3299
cs_real_t * corr_grad_lin_det
Definition: cs_mesh_quantities.h:136
int * c_disable_flag
Definition: cs_mesh_quantities.h:145
cs_real_t * cell_f_vol
Definition: cs_mesh_quantities.h:93
cs_real_t * b_face_surf
Definition: cs_mesh_quantities.h:107
cs_real_t * cs_mesh_quantities_cell_volume(const cs_mesh_t *mesh)
Definition: cs_mesh_quantities.c:3094
cs_real_t * djjpf
Definition: cs_mesh_quantities.h:119
cs_real_t min_f_vol
Definition: cs_mesh_quantities.h:132
cs_real_t max_f_vol
Definition: cs_mesh_quantities.h:133
#define BEGIN_C_DECLS
Definition: cs_defs.h:510
cs_real_33_t * corr_grad_lin
Definition: cs_mesh_quantities.h:138
cs_real_6_t * cs_mesh_quantities_cell_extents(const cs_mesh_t *m, cs_real_t tolerance)
Compute the bounding box for cells.
Definition: cs_mesh_quantities.c:3193
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:2198
cs_real_t * diipf
Definition: cs_mesh_quantities.h:118
cs_real_t * dofij
Definition: cs_mesh_quantities.h:117
cs_real_t * b_face_cog
Definition: cs_mesh_quantities.h:104
double cs_real_t
Floating-point value.
Definition: cs_defs.h:322
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:2843
cs_real_t max_vol
Definition: cs_mesh_quantities.h:129
unsigned * bad_cell_flag
Definition: cs_mesh_quantities.h:147
Definition: cs_mesh.h:84
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:2283
cs_real_t * i_f_face_normal
Definition: cs_mesh_quantities.h:99
void cs_mesh_init_fluid_sections(const cs_mesh_t *mesh, cs_mesh_quantities_t *mesh_quantities)
Definition: cs_mesh_quantities.c:2762
void cs_mesh_quantities_fluid_vol_reductions(const cs_mesh_t *mesh, cs_mesh_quantities_t *mesh_quantities)
Definition: cs_mesh_quantities.c:2722
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:2176
cs_real_t tot_vol
Definition: cs_mesh_quantities.h:130
cs_real_t tot_f_vol
Definition: cs_mesh_quantities.h:134
cs_real_t * dijpf
Definition: cs_mesh_quantities.h:115
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:2923
cs_real_t * cell_cen
Definition: cs_mesh_quantities.h:91
cs_mesh_quantities_t * cs_glob_mesh_quantities
cs_real_t * i_dist
Definition: cs_mesh_quantities.h:121
cs_real_t * i_face_normal
Definition: cs_mesh_quantities.h:95
Definition: cs_mesh_quantities.h:89
cs_real_2_t * i_f_face_factor
Definition: cs_mesh_quantities.h:112
cs_mesh_quantities_t * cs_mesh_quantities_destroy(cs_mesh_quantities_t *mq)
Destroy a mesh quantities structure.
Definition: cs_mesh_quantities.c:2265
cs_mesh_quantities_t * cs_mesh_quantities_create(void)
Create a mesh quantities structure.
Definition: cs_mesh_quantities.c:2215
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:3431
cs_real_t * b_f_face_surf
Definition: cs_mesh_quantities.h:110
cs_real_t * weight
Definition: cs_mesh_quantities.h:126
cs_real_t * b_f_face_factor
Definition: cs_mesh_quantities.h:113
cs_real_t min_vol
Definition: cs_mesh_quantities.h:128
#define END_C_DECLS
Definition: cs_defs.h:511
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:2966
cs_real_t * i_f_face_surf
Definition: cs_mesh_quantities.h:109
void cs_mesh_quantities_compute_preprocess(const cs_mesh_t *m, cs_mesh_quantities_t *mq)
Compute mesh quantities needed for preprocessing.
Definition: cs_mesh_quantities.c:2318
void cs_mesh_quantities_fluid_compute(const cs_mesh_t *mesh, cs_mesh_quantities_t *mesh_quantities)
Definition: cs_mesh_quantities.c:2706
cs_real_t cs_real_33_t[3][3]
3x3 matrix of floating-point values
Definition: cs_defs.h:342
cs_real_t * b_face_normal
Definition: cs_mesh_quantities.h:97
int * b_sym_flag
Definition: cs_mesh_quantities.h:141
cs_real_t * diipb
Definition: cs_mesh_quantities.h:116
cs_real_t * cell_vol
Definition: cs_mesh_quantities.h:92
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:3389
void cs_mesh_quantities_sup_vectors(const cs_mesh_t *mesh, cs_mesh_quantities_t *mesh_quantities)
Definition: cs_mesh_quantities.c:2808
cs_real_t * i_face_surf
Definition: cs_mesh_quantities.h:106
int cs_mesh_quantities_compute_count(void)
Definition: cs_mesh_quantities.c:3281
cs_real_t * i_face_cog
Definition: cs_mesh_quantities.h:103
Definition: mesh.f90:26
cs_real_t * b_f_face_normal
Definition: cs_mesh_quantities.h:101
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:2890