programmer's documentation
Main Page
Related Pages
Modules
Data Structures
Files
File List
Globals
All
Data Structures
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Macros
Groups
Pages
src
mesh
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-2013 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
39
BEGIN_C_DECLS
40
41
/*=============================================================================
42
* Local Macro definitions
43
*============================================================================*/
44
45
/*============================================================================
46
* Type definition
47
*============================================================================*/
48
49
/* Structure associated to mesh quantities management */
50
51
typedef
struct
{
52
53
cs_real_t
*
cell_cen
;
/* Cell center coordinates */
54
cs_real_t
*
cell_vol
;
/* Cell volume */
55
56
cs_real_t
*
i_face_normal
;
/* Surface normal of interior faces.
57
(L2 norm equals area of the face) */
58
cs_real_t
*
b_face_normal
;
/* Surface normal of border faces.
59
(L2 norm equals area of the face) */
60
cs_real_t
*
i_face_cog
;
/* Center of gravity of interior faces */
61
cs_real_t
*
b_face_cog
;
/* Center of gravity of border faces */
62
63
cs_real_t
*
i_face_surf
;
/* Surface of interior faces. */
64
cs_real_t
*
b_face_surf
;
/* Surface of boundary faces. */
65
66
cs_real_t
*
dijpf
;
/* Vector I'J' for interior faces */
67
cs_real_t
*
diipb
;
/* Vector II' for border faces */
68
cs_real_t
*
dofij
;
/* Vector OF for interior faces */
69
cs_real_t
*
diipf
;
/* Vector II' for interior faces */
70
cs_real_t
*
djjpf
;
/* Vector JJ' for interior faces */
71
72
cs_real_t
*
i_dist
;
/* Distance between the cell center and
73
the center of gravity of interior faces */
74
cs_real_t
*
b_dist
;
/* Distance between the cell center and
75
the center of gravity of border faces */
76
77
cs_real_t
*
weight
;
/* Interior faces weighting factor */
78
79
cs_real_t
min_vol
;
/* Minimum cell volume */
80
cs_real_t
max_vol
;
/* Maximum cell volume */
81
cs_real_t
tot_vol
;
/* Total volume */
82
83
cs_real_33_t
*
cocgb_s_it
;
/* coupling of gradient compponents for
84
iterative reconstruction at boundary */
85
cs_real_33_t
*
cocg_s_it
;
/* coupling of gradient compponents for
86
iterative reconstruction */
87
cs_real_33_t
*
cocgb_s_lsq
;
/* coupling of gradient compponents for
88
least-square reconstruction at boundary */
89
cs_real_33_t
*
cocg_s_lsq
;
/* coupling of gradient compponents for
90
least-square reconstruction */
91
92
cs_real_33_t
*
cocg_it
;
/* Interleaved cocg matrix
93
for iterative gradients */
94
cs_real_33_t
*
cocg_lsq
;
/* Interleaved cocg matrix
95
for least square gradients */
96
97
cs_int_t
*
b_sym_flag
;
/* Symmetry flag for boundary faces */
98
unsigned
*
bad_cell_flag
;
/* Flag (mask) for bad cells detected */
99
100
}
cs_mesh_quantities_t
;
101
102
/*============================================================================
103
* Static global variables
104
*============================================================================*/
105
106
/* Pointer to mesh quantities structure associated to the main mesh */
107
108
extern
cs_mesh_quantities_t
*
cs_glob_mesh_quantities
;
109
110
/*============================================================================
111
* Public function prototypes for API Fortran
112
*============================================================================*/
113
114
/*----------------------------------------------------------------------------
115
* Query or modification of the option for computing cell centers.
116
*
117
* This function returns 1 or 2 according to the selected algorithm.
118
*
119
* Fortran interface :
120
*
121
* SUBROUTINE ALGCEN (IOPT)
122
* *****************
123
*
124
* INTEGER IOPT : <-> : Choice of the algorithm
125
* < 0 : query
126
* 0 : computation based
127
* on faces (default choice)
128
* 1 : computation based
129
* on vertices
130
*----------------------------------------------------------------------------*/
131
132
void
133
CS_PROCF
(
algcen
, ALGCEN) (
cs_int_t
*
const
iopt);
134
135
/*----------------------------------------------------------------------------
136
* Set behavior for computing the cocg matrixes for the iterative algo
137
* and for the Least square method for scalar and vector gradients.
138
*
139
* Fortran interface :
140
*
141
* subroutine comcoc (imrgra)
142
* *****************
143
*
144
* integer imrgra : <-- : gradient reconstruction option
145
*----------------------------------------------------------------------------*/
146
147
void
148
CS_PROCF
(
comcoc
, COMCOC) (
const
cs_int_t
*
const
imrgra);
149
150
/*=============================================================================
151
* Public function prototypes
152
*============================================================================*/
153
154
/*----------------------------------------------------------------------------
155
* Query or modification of the option for computing cell centers.
156
*
157
* < 0 : query
158
* 0 : computation based on faces (default choice)
159
* 1 : computation based on vertices
160
*
161
* algo_choice <-- choice of algorithm to compute cell centers.
162
*
163
* returns:
164
* 1 or 2 according to the selected algorithm.
165
*----------------------------------------------------------------------------*/
166
167
int
168
cs_mesh_quantities_cell_cen_choice
(
const
int
algo_choice);
169
170
/*----------------------------------------------------------------------------
171
* Compute cocg for iterative gradient reconstruction for scalars.
172
*
173
* parameters:
174
* gradient_option <-- gradient option (Fortran IMRGRA)
175
*----------------------------------------------------------------------------*/
176
177
void
178
cs_mesh_quantities_set_cocg_options
(
int
gradient_option);
179
180
/*----------------------------------------------------------------------------
181
* Create a mesh quantities structure.
182
*
183
* returns:
184
* pointer to created cs_mesh_quantities_t structure
185
*----------------------------------------------------------------------------*/
186
187
cs_mesh_quantities_t
*
188
cs_mesh_quantities_create
(
void
);
189
190
/*----------------------------------------------------------------------------
191
* Destroy a mesh quantities structure
192
*
193
* parameters:
194
* mesh_quantities <-- pointer to a cs_mesh_quantities_t structure
195
*
196
* returns:
197
* NULL
198
*----------------------------------------------------------------------------*/
199
200
cs_mesh_quantities_t
*
201
cs_mesh_quantities_destroy
(
cs_mesh_quantities_t
*mesh_quantities);
202
203
/*----------------------------------------------------------------------------
204
* Compute mesh quantities
205
*
206
* parameters:
207
* mesh <-- pointer to a cs_mesh_t structure
208
* mesh_quantities <-> pointer to a cs_mesh_quantities_t structure
209
*----------------------------------------------------------------------------*/
210
211
void
212
cs_mesh_quantities_compute
(
const
cs_mesh_t
*
mesh
,
213
cs_mesh_quantities_t
*mesh_quantities);
214
215
/*----------------------------------------------------------------------------
216
* Compute mesh quantities
217
*
218
* parameters:
219
* mesh <-- pointer to a cs_mesh_t structure
220
* mesh_quantities <-> pointer to a cs_mesh_quantities_t structure
221
*----------------------------------------------------------------------------*/
222
223
void
224
cs_mesh_quantities_sup_vectors
(
const
cs_mesh_t
*
mesh
,
225
cs_mesh_quantities_t
*mesh_quantities);
226
227
/*----------------------------------------------------------------------------
228
* Compute internal and border face normal.
229
*
230
* parameters:
231
* mesh <-- pointer to a cs_mesh_t structure
232
* p_i_face_normal <-> pointer to the internal face normal array
233
* p_b_face_normal <-> pointer to the border face normal array
234
*----------------------------------------------------------------------------*/
235
236
void
237
cs_mesh_quantities_face_normal
(
const
cs_mesh_t
*
mesh
,
238
cs_real_t
*p_i_face_normal[],
239
cs_real_t
*p_b_face_normal[]);
240
241
/*----------------------------------------------------------------------------
242
* Compute interior face centers and normals.
243
*
244
* The corresponding arrays are allocated by this function, and it is the
245
* caller's responsibility to free them when they are no longer needed.
246
*
247
* parameters:
248
* mesh <-- pointer to a cs_mesh_t structure
249
* p_i_face_cog <-> pointer to the interior face center array
250
* p_i_face_normal <-> pointer to the interior face normal array
251
*----------------------------------------------------------------------------*/
252
253
void
254
cs_mesh_quantities_i_faces
(
const
cs_mesh_t
*
mesh
,
255
cs_real_t
*p_i_face_cog[],
256
cs_real_t
*p_i_face_normal[]);
257
258
/*----------------------------------------------------------------------------
259
* Compute border face centers and normals.
260
*
261
* The corresponding arrays are allocated by this function, and it is the
262
* caller's responsibility to free them when they are no longer needed.
263
*
264
* parameters:
265
* mesh <-- pointer to a cs_mesh_t structure
266
* p_b_face_cog <-> pointer to the border face center array
267
* p_b_face_normal <-> pointer to the border face normal array
268
*----------------------------------------------------------------------------*/
269
270
void
271
cs_mesh_quantities_b_faces
(
const
cs_mesh_t
*
mesh
,
272
cs_real_t
*p_b_face_cog[],
273
cs_real_t
*p_b_face_normal[]);
274
275
/*----------------------------------------------------------------------------
276
* Check that no negative volumes are present, and exit on error otherwise.
277
*
278
* parameters:
279
* mesh <-- pointer to mesh structure
280
* mesh_quantities <-- pointer to mesh quantities structure
281
* allow_error <-- 1 if errors are allowed, 0 otherwise
282
*----------------------------------------------------------------------------*/
283
284
void
285
cs_mesh_quantities_check_vol
(
const
cs_mesh_t
*
mesh
,
286
const
cs_mesh_quantities_t
*mesh_quantities,
287
int
allow_error);
288
289
/*----------------------------------------------------------------------------
290
* Update mesh quantities relative to extended ghost cells when the
291
* neighborhood is reduced.
292
*
293
* parameters:
294
* mesh <-- pointer to a cs_mesh_t structure
295
* mesh_quantities <-> pointer to a cs_mesh_quantities_t structure
296
*----------------------------------------------------------------------------*/
297
298
void
299
cs_mesh_quantities_reduce_extended
(
const
cs_mesh_t
*
mesh
,
300
cs_mesh_quantities_t
*mesh_quantities);
301
302
/*----------------------------------------------------------------------------
303
* Return the number of times mesh quantities have been computed.
304
*
305
* returns:
306
* number of times mesh quantities have been computed
307
*----------------------------------------------------------------------------*/
308
309
int
310
cs_mesh_quantities_compute_count
(
void
);
311
312
/*----------------------------------------------------------------------------
313
* Dump a cs_mesh_quantities_t structure
314
*
315
* parameters:
316
* mesh <-- pointer to a cs_mesh_t structure
317
* mesh_quantities <-- pointer to a cs_mesh_quantities_t structure
318
*----------------------------------------------------------------------------*/
319
320
void
321
cs_mesh_quantities_dump
(
const
cs_mesh_t
*
mesh
,
322
const
cs_mesh_quantities_t
*mesh_quantities);
323
324
/*----------------------------------------------------------------------------*/
325
326
END_C_DECLS
327
328
#endif
/* __CS_MESH_QUANTITIES_H__ */
Generated on Thu Feb 27 2014 19:21:34 by
1.8.3.1