programmer's documentation
cs_mesh.h
Go to the documentation of this file.
1 #ifndef __CS_MESH_H__
2 #define __CS_MESH_H__
3 
4 /*============================================================================
5  * Main structure associated to a mesh
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_defs.h"
35 
36 #include "fvm_group.h"
37 #include "fvm_selector.h"
38 #include "fvm_periodicity.h"
39 
40 #include "cs_base.h"
41 #include "cs_halo.h"
42 #include "cs_interface.h"
43 #include "cs_numbering.h"
44 
45 #include "cs_mesh_builder.h"
46 
47 /*----------------------------------------------------------------------------*/
48 
50 
51 /*=============================================================================
52  * Macro definitions
53  *============================================================================*/
54 
55 /*============================================================================
56  * Type definitions
57  *============================================================================*/
58 
59 /* Mesh structure definition */
60 /* ------------------------- */
61 
62 typedef struct {
63 
64  /* General features */
65 
66  cs_lnum_t dim; /* Space dimension */
67  cs_lnum_t domain_num; /* Local domain number */
68  cs_lnum_t n_domains; /* Number of domains */
69 
70  /* Local dimensions */
71 
72  cs_lnum_t n_cells; /* Number of cells */
73  cs_lnum_t n_i_faces; /* Number of interior faces */
74  cs_lnum_t n_b_faces; /* Number of boundary faces */
75  cs_lnum_t n_vertices; /* Number of vertices */
76 
77  cs_lnum_t i_face_vtx_connect_size; /* Size of the connectivity
78  interior faces -> vertices */
79  cs_lnum_t b_face_vtx_connect_size; /* Size of the connectivity
80  boundary faces -> vertices */
81 
82  /* Local structures */
83 
84  cs_real_t *vtx_coord; /* Vertex coordinates */
85 
86  cs_lnum_2_t *i_face_cells; /* Interior faces -> cells connectivity */
87  cs_lnum_t *b_face_cells; /* Boundary faces -> cells connectivity */
88 
89  cs_lnum_t *i_face_vtx_idx; /* Interior faces -> vertices index */
90  cs_lnum_t *i_face_vtx_lst; /* Interior faces -> vertices connectivity */
91 
92  cs_lnum_t *b_face_vtx_idx; /* Boundary faces -> vertices index */
93  cs_lnum_t *b_face_vtx_lst; /* Boundary faces -> vertices connectivity */
94 
95  /* Global dimension */
96 
97  cs_gnum_t n_g_cells; /* Global number of cells */
98  cs_gnum_t n_g_i_faces; /* Global number of interior faces */
99  cs_gnum_t n_g_b_faces; /* Global number of boundary faces */
100  cs_gnum_t n_g_vertices; /* Global number of vertices */
101 
102  /* Global numbering */
103 
104  cs_gnum_t *global_cell_num; /* Global cell numbering */
105  cs_gnum_t *global_i_face_num; /* Global interior face numbering */
106  cs_gnum_t *global_b_face_num; /* Global boundary face numbering */
107  cs_gnum_t *global_vtx_num; /* Global vertex numbering */
108 
109  /* Periodictity features */
110 
111  int n_init_perio; /* Number of initial periodicities */
112  int n_transforms; /* Number of transformations */
113 
114  int have_rotation_perio; /* Periodicity rotation indicator */
115 
116  fvm_periodicity_t *periodicity; /* parameters of each periodicity */
117 
118  /* Parallelism and/or periodic features */
119 
120  cs_halo_type_t halo_type; /* Halo type */
121 
122  cs_lnum_t n_cells_with_ghosts; /* Total number of cells on the local rank
123  (n_cells + n_ghost_cells) */
124  cs_lnum_t n_ghost_cells; /* Number of "ghost" cells */
125 
126  cs_interface_set_t *vtx_interfaces; /* Vertices interface set */
127  cs_halo_t *halo; /* Ghost cells structure */
128 
129  cs_numbering_t *cell_numbering; /* Cell numbering info */
130  cs_numbering_t *i_face_numbering; /* Interior face numbering info */
131  cs_numbering_t *b_face_numbering; /* Boundary face numbering info */
132 
133  /* Re-computable connectivity features */
134 
135  cs_lnum_t n_b_cells; /* Number of boundary cells */
136  cs_lnum_t *b_cells; /* Boundary cell list */
137 
138  /* Extended neighborhood features */
139 
140  cs_lnum_t *cell_cells_idx; /* "cell -> cells" connectivity index for
141  extended halo. Only defined if extended
142  neighborhood is built. */
143  cs_lnum_t *cell_cells_lst; /* "cell -> cells" connectivity list for
144  extended halo. Only defined if extended
145  neighborhood is built. */
146 
147  cs_lnum_t *gcell_vtx_idx; /* ghost cells -> vertices index */
148  cs_lnum_t *gcell_vtx_lst; /* ghost cells -> vertices list */
149 
150  /* Group and family features */
151 
152  cs_lnum_t n_groups; /* Number of groups */
153  cs_lnum_t *group_idx; /* Starting index in the in group_lst */
154  char *group_lst; /* List of group names */
155 
156  cs_lnum_t n_families; /* Number of families */
157  cs_lnum_t n_max_family_items; /* Max. number of items for one family */
158  cs_lnum_t *family_item; /* Family items */
159  cs_lnum_t *cell_family; /* Cell family */
160  cs_lnum_t *i_face_family; /* Interior face family */
161  cs_lnum_t *b_face_family; /* Boundary face family */
162 
163  fvm_group_class_set_t *class_defs; /* Definition of group classes for
164  selection and postprocessing (built
165  from element families and their
166  descriptions) */
167  fvm_selector_t *select_cells; /* Cells selection object */
168  fvm_selector_t *select_i_faces; /* Interior faces selection object */
169  fvm_selector_t *select_b_faces; /* Boundary faces selection object */
170 
171  /* Status flags */
172 
173  cs_gnum_t n_g_free_faces; /* Global number of boundary faces
174  which are in fact isolated */
175  int verbosity; /* Current verbosity level */
176  int modified; /* Modification status */
177 
178 } cs_mesh_t;
179 
180 /*============================================================================
181  * Static global variables
182  *============================================================================*/
183 
184 extern cs_mesh_t *cs_glob_mesh; /* Pointer to main mesh structure */
185 
186 /*============================================================================
187  * Public function prototypes for Fortran API
188  *============================================================================*/
189 
190 /*----------------------------------------------------------------------------
191  * Update a scalar array in case of parallelism and/or periodicity.
192  *
193  * Fortran interface:
194  *
195  * subroutine synsca(var)
196  * *****************
197  *
198  * var : <-> : scalar array
199  *----------------------------------------------------------------------------*/
200 
201 void CS_PROCF(synsca, SYNSCA)
202 (
203  cs_real_t var[]
204 );
205 
206 /*----------------------------------------------------------------------------
207  * Update a scalar array in case of parallelism and/or periodicity,
208  * using an extended halo.
209  *
210  * Fortran interface:
211  *
212  * subroutine synsce(var)
213  * *****************
214  *
215  * var : <-> : scalar array
216  *----------------------------------------------------------------------------*/
217 
218 void CS_PROCF(synsce, SYNSCE)
219 (
220  cs_real_t var[]
221 );
222 
223 /*----------------------------------------------------------------------------
224  * Update a scalar array in case of parallelism and/or periodicity,
225  * ignoring periodicity of rotation
226  *
227  * Fortran interface:
228  *
229  * subroutine syncmp(var)
230  * *****************
231  *
232  * var : <-> : scalar array
233  *----------------------------------------------------------------------------*/
234 
235 void CS_PROCF(syncmp, SYNCMP)
236 (
237  cs_real_t var[]
238 );
239 
240 /*----------------------------------------------------------------------------
241  * Update a vector array in case of parallelism and/or periodicity.
242  *
243  * Fortran interface:
244  *
245  * subroutine synvec(var)
246  * *****************
247  *
248  * var1 : <-> : vector component 1 array
249  * var2 : <-> : vector component 2 array
250  * var3 : <-> : vector component 3 array
251  *----------------------------------------------------------------------------*/
252 
253 void CS_PROCF(synvec, SYNVEC)
254 (
255  cs_real_t var1[],
256  cs_real_t var2[],
257  cs_real_t var3[]
258 );
259 
260 /*----------------------------------------------------------------------------
261  * Update a vector array in case of parallelism and/or periodicity.
262  *
263  * Fortran interface:
264  *
265  * subroutine synvin(var)
266  * *****************
267  *
268  * var : <-> : interleaved vector (of dimension 3)
269  *----------------------------------------------------------------------------*/
270 
271 void CS_PROCF(synvin, SYNVIN)
272 (
273  cs_real_t var[]
274 );
275 
276 /*----------------------------------------------------------------------------
277  * Update a vector array in case of parallelism and/or periodicity,
278  * using an extended halo.
279  *
280  * Fortran interface:
281  *
282  * subroutine synvin(var)
283  * *****************
284  *
285  * var : <-> : interleaved vector (of dimension 3)
286  *----------------------------------------------------------------------------*/
287 
288 void CS_PROCF(synvie, SYNVIE)
289 (
290  cs_real_t var[]
291 );
292 
293 /*----------------------------------------------------------------------------
294  * Update a vector array in case of parallelism and/or periodicity,
295  * ignoring periodicity of rotation.
296  *
297  * Fortran interface:
298  *
299  * subroutine synvnr(var)
300  * *****************
301  *
302  * var : <-> : interleaved vector (of dimension 3)
303  *----------------------------------------------------------------------------*/
304 
305 void
306 CS_PROCF (synvnr, SYNVNR)
307 (
308  cs_real_t var[]
309 );
310 
311 /*----------------------------------------------------------------------------
312  * Update a diagonal tensor array in case of parallelism and/or periodicity.
313  *
314  * Fortran interface:
315  *
316  * subroutine syndia(var)
317  * *****************
318  *
319  * var11 : <-> : diagonal tensor component 11 array
320  * var22 : <-> : diagonal tensor component 22 array
321  * var33 : <-> : diagonal tensor component 33 array
322  *----------------------------------------------------------------------------*/
323 
324 void CS_PROCF(syndia, SYNDIA)
325 (
326  cs_real_t var11[],
327  cs_real_t var22[],
328  cs_real_t var33[]
329 );
330 
331 /*----------------------------------------------------------------------------
332  * Update a tensor array in case of parallelism and/or periodicity.
333  *
334  * Fortran interface:
335  *
336  * subroutine synten(var)
337  * *****************
338  *
339  * var11 : <-> : tensor component 11 array
340  * var12 : <-> : tensor component 12 array
341  * var13 : <-> : tensor component 13 array
342  * var21 : <-> : tensor component 21 array
343  * var22 : <-> : tensor component 22 array
344  * var23 : <-> : tensor component 23 array
345  * var31 : <-> : tensor component 31 array
346  * var32 : <-> : tensor component 32 array
347  * var33 : <-> : tensor component 33 array
348  *----------------------------------------------------------------------------*/
349 
350 void CS_PROCF(synten, SYNTEN)
351 (
352  cs_real_t var11[],
353  cs_real_t var12[],
354  cs_real_t var13[],
355  cs_real_t var21[],
356  cs_real_t var22[],
357  cs_real_t var23[],
358  cs_real_t var31[],
359  cs_real_t var32[],
360  cs_real_t var33[]
361 );
362 
363 /*----------------------------------------------------------------------------
364  * Update a tensor array in case of parallelism and/or periodicity.
365  *
366  * Fortran interface:
367  *
368  * subroutine syntin(var)
369  * *****************
370  *
371  * var : <-> : interleaved tensor (of dimension 3x3)
372  *----------------------------------------------------------------------------*/
373 
374 void CS_PROCF(syntin, SYNTIN)
375 (
376  cs_real_t var[]
377 );
378 
379 /*----------------------------------------------------------------------------
380  * Update a symmetric tensor array in case of parallelism and/or periodicity.
381  *
382  * Fortran interface:
383  *
384  * subroutine syntis(var)
385  * *****************
386  *
387  * var : <-> : interleaved symmetric tensor (of dimension 6)
388  *----------------------------------------------------------------------------*/
389 
390 void CS_PROCF(syntis, SYNTIS)
391 (
392  cs_real_t var[]
393 );
394 
395 /*=============================================================================
396  * Public function prototypes
397  *============================================================================*/
398 
399 /*----------------------------------------------------------------------------
400  * Create an empty mesh structure
401  *
402  * returns:
403  * pointer to created mesh structure
404  *----------------------------------------------------------------------------*/
405 
406 cs_mesh_t *
407 cs_mesh_create(void);
408 
409 /*----------------------------------------------------------------------------
410  * Destroy a mesh structure
411  *
412  * mesh <-> pointer to a mesh structure
413  *
414  * returns:
415  * NULL pointer
416  *----------------------------------------------------------------------------*/
417 
418 cs_mesh_t *
420 
421 /*----------------------------------------------------------------------------
422  * Remove arrays and structures that mey be rebuilt.
423  *
424  * mesh <-> pointer to a mesh structure
425  * free_halos <-- if true, free halos and parallel/periodic interface
426  * structures
427  *----------------------------------------------------------------------------*/
428 
429 void
431  bool free_halos);
432 
433 /*----------------------------------------------------------------------------
434  * Discard free (isolated) faces from a mesh.
435  *
436  * This should always be done before using the mesh for computation.
437  *
438  * parameters:
439  * mesh <-> pointer to mesh structure
440  *----------------------------------------------------------------------------*/
441 
442 void
444 
445 /*----------------------------------------------------------------------------
446  * Compute or update mesh structure members that depend on other members,
447  * but whose results may be reused, such as global number of elements
448  * (cells, vertices, interior and boundary faces) and sync cell family.
449  *
450  * parameters:
451  * mesh <-> pointer to a cs_mesh_t structure
452  *----------------------------------------------------------------------------*/
453 
454 void
456 
457 /*----------------------------------------------------------------------------
458  * Creation and initialization of mesh face and vertex interfaces.
459  *
460  * parameters:
461  * mesh <-> pointer to mesh structure
462  * mb <-> pointer to mesh builder (in case of periodicity)
463  *----------------------------------------------------------------------------*/
464 
465 void
467  cs_mesh_builder_t *mb);
468 
469 /*----------------------------------------------------------------------------
470  * Creation and initialization of halo structures.
471  *
472  * Treatment of parallel and/or periodic halos for standard and extended
473  * ghost cells according to halo type requested by global options.
474  *
475  * parameters:
476  * mesh <-> pointer to mesh structure
477  * mb <-> pointer to mesh builder (in case of periodicity)
478  * halo_type <-> type of halo (standard or extended)
479  *----------------------------------------------------------------------------*/
480 
481 void
483  cs_mesh_builder_t *mb,
484  cs_halo_type_t halo_type);
485 
486 /*----------------------------------------------------------------------------
487  * Get the global number of ghost cells.
488  *
489  * parameters:
490  * mesh <-- pointer to a mesh structure
491  *
492  * returns:
493  * Global number of ghost cells
494  *---------------------------------------------------------------------------*/
495 
496 cs_gnum_t
498 
499 /*----------------------------------------------------------------------------
500  * Update a scalar array in case of parallelism and/or periodicity.
501  *
502  * Note: this function is only present so that a C equivalent to the
503  * Fortran wrappers is available. In C code, directly using
504  * cs_halo_sync_var() is preferred.
505  *
506  * parameters:
507  * var <-> scalar array
508  *----------------------------------------------------------------------------*/
509 
510 void
512 
513 /*----------------------------------------------------------------------------
514  * Update a scalar array in case of parallelism and/or periodicity,
515  * using an extended halo.
516  *
517  * Note: this function is only present so that a C equivalent to the
518  * Fortran wrappers is available. In C code, directly using the
519  * cs_halo_sync_var() is preferred.
520  *
521  * parameters:
522  * var <-> scalar array
523  *----------------------------------------------------------------------------*/
524 
525 void
527 
528 /*----------------------------------------------------------------------------
529  * Update a component of a vector for parallelism and/or periodicity,
530  * ignoring periodicity of rotation.
531  *
532  * Note: this function is only present so that a C equivalent to the
533  * Fortran wrappers is available. In C code, directly using the
534  * cs_halo_sync_var() is preferred.
535  *
536  * parameters:
537  * var <-> scalar array
538  *----------------------------------------------------------------------------*/
539 
540 void
542 
543 /*----------------------------------------------------------------------------
544  * Update a vector array in case of parallelism and/or periodicity.
545  *
546  * parameters:
547  * var1 <-> vector component 1 array
548  * var2 <-> vector component 2 array
549  * var3 <-> vector component 3 array
550  *----------------------------------------------------------------------------*/
551 
552 void
554  cs_real_t *var2,
555  cs_real_t *var3);
556 
557 /*----------------------------------------------------------------------------
558  * Update a vector array in case of parallelism and/or periodicity.
559  *
560  * parameters:
561  * var <-> interleaved vector (of dimension 3)
562  *----------------------------------------------------------------------------*/
563 
564 void
566 
567 /*----------------------------------------------------------------------------
568  * Update a vector array in case of parallelism and/or periodicity,
569  * using an extended halo.
570  *
571  * parameters:
572  * var <-> interleaved vector (of dimension 3)
573  *----------------------------------------------------------------------------*/
574 
575 void
577 
578 /*----------------------------------------------------------------------------
579  * Update a components of a vector for parallelism and/or periodicity,
580  * ignoring periodicity of rotation.
581  *
582  * var <-> gradient components (interleaved)
583  *----------------------------------------------------------------------------*/
584 
585 void
587 
588 /*----------------------------------------------------------------------------
589  * Update a diagonal tensor array in case of parallelism and/or periodicity.
590  *
591  * parameters:
592  * var11 <-> diagonal tensor component 11 array
593  * var22 <-> diagonal tensor component 22 array
594  * var33 <-> diagonal tensor component 33 array
595  *----------------------------------------------------------------------------*/
596 
597 void
599  cs_real_t *var22,
600  cs_real_t *var33);
601 
602 /*----------------------------------------------------------------------------
603  * Update a tensor array in case of parallelism and/or periodicity.
604  *
605  * parameters:
606  * var11 <-> tensor component 11 array
607  * var12 <-> tensor component 12 array
608  * var13 <-> tensor component 13 array
609  * var21 <-> tensor component 21 array
610  * var22 <-> tensor component 22 array
611  * var23 <-> tensor component 23 array
612  * var31 <-> tensor component 31 array
613  * var32 <-> tensor component 32 array
614  * var33 <-> tensor component 33 array
615  *----------------------------------------------------------------------------*/
616 
617 void
619  cs_real_t *var12,
620  cs_real_t *var13,
621  cs_real_t *var21,
622  cs_real_t *var22,
623  cs_real_t *var23,
624  cs_real_t *var31,
625  cs_real_t *var32,
626  cs_real_t *var33);
627 
628 /*----------------------------------------------------------------------------
629  * Update a tensor array in case of parallelism and/or periodicity.
630  *
631  * parameters:
632  * var <-> interleaved tensor (of dimension 3x3)
633  *----------------------------------------------------------------------------*/
634 
635 void
637 
638 /*----------------------------------------------------------------------------
639  * Update a symmetric tensor array in case of parallelism and/or periodicity.
640  *
641  * parameters:
642  * var <-> symmetric interleaved tensor (of dimension 6)
643  *----------------------------------------------------------------------------*/
644 
645 void
647 
648 /*----------------------------------------------------------------------------
649  * Order family numbers and remove duplicates
650  *
651  * parameters
652  * mesh <-> pointer to mesh structure
653  *----------------------------------------------------------------------------*/
654 
655 void
657 
658 /*----------------------------------------------------------------------------
659  * Create group classes based on a mesh's family definitions.
660  *
661  * parameters:
662  * mesh <-- pointer to mesh structure
663  *
664  * returns:
665  * pointer to group classes structure based on mesh's family definitions
666  *----------------------------------------------------------------------------*/
667 
670 
671 /*----------------------------------------------------------------------------
672  * Define group classes for a mesh based on its family definitions.
673  *
674  * parameters:
675  * mesh <-> pointer to mesh structure
676  *----------------------------------------------------------------------------*/
677 
678 void
680 
681 /*----------------------------------------------------------------------------
682  * Assign selectors to global mesh.
683  *
684  * Should be called once the mesh is fully built.
685  *----------------------------------------------------------------------------*/
686 
687 void
689 
690 /*----------------------------------------------------------------------------
691  * Get global lists of periodic face couples.
692  *
693  * In parallel, each face couple may appear on only one rank.
694  *
695  * The caller is responsible for freeing the arrays allocated and returned
696  * by this function once they are no onger needed.
697  *
698  * parameters:
699  * mesh <-- pointer to mesh structure
700  * n_perio_face_couples --> global number of periodic couples per
701  * periodicity (size: mesh->n_init_perio)
702  * perio_face_couples --> arrays of global periodic couple face numbers,
703  * for each periodicity
704  *----------------------------------------------------------------------------*/
705 
706 void
708  cs_lnum_t **n_perio_face_couples,
709  cs_gnum_t ***perio_face_couples);
710 
711 /*----------------------------------------------------------------------------
712  * Build global cell numbering array extended to ghost cell values.
713  *
714  * If the blank_perio flag is nonzero, periodic ghost cell numbers
715  * are set to zero instead of the value of the matching cell.
716  *
717  * The caller is responsible for freeing the returned array when it
718  * is no longer useful.
719  *
720  * parameters:
721  * mesh <-- pointer to mesh structure
722  * blank_perio <-- flag to zeroe periodic cell values
723  *----------------------------------------------------------------------------*/
724 
725 cs_gnum_t *
727  int blank_perio);
728 
729 /*----------------------------------------------------------------------------
730  * Mark interior faces with the number of their associated periodic
731  * transform id.
732  *
733  * parameters:
734  * mesh <-- pointer to mesh structure
735  * perio_num --> periodicity number associated with each face, signed for
736  * direct/reverse transform, 0 for non-periodic faces
737  * (size: mesh->n_i_faces)
738  *----------------------------------------------------------------------------*/
739 
740 void
742  int perio_num[]);
743 
744 /*----------------------------------------------------------------------------
745  * Print information on a mesh structure.
746  *
747  * parameters:
748  * mesh <-- pointer to mesh structure.
749  * name <-- associated name.
750  *----------------------------------------------------------------------------*/
751 
752 void
754  const char *name);
755 
756 /*----------------------------------------------------------------------------
757  * Compute global face connectivity size.
758  *
759  * Faces on simple parallel boundaries are counted only once, but periodic
760  * faces are counted twice.
761  *
762  * parameters:
763  * mesh <-- pointer to a cs_mesh_t structure
764  * g_i_face_vertices_size --> global interior face connectivity size, or NULL
765  * g_b_face_vertices_size --> global boundary face connectivity size, or NULL
766  *----------------------------------------------------------------------------*/
767 
768 void
770  cs_gnum_t *g_i_face_vertices_size,
771  cs_gnum_t *g_b_face_vertices_size);
772 
773 /*----------------------------------------------------------------------------
774  * Print statistics about mesh selectors usage to log.
775  *
776  * parameters:
777  * mesh <-- pointer to a mesh structure
778  *----------------------------------------------------------------------------*/
779 
780 void
782 
783 /*----------------------------------------------------------------------------
784  * Dump of a mesh structure.
785  *
786  * parameters:
787  * mesh <-> pointer to mesh structure.
788  *----------------------------------------------------------------------------*/
789 
790 void
791 cs_mesh_dump(const cs_mesh_t *mesh);
792 
793 /*----------------------------------------------------------------------------*/
794 
796 
797 #endif /* __CS_MESH_H__ */
unsigned long cs_gnum_t
global mesh entity number
Definition: cs_defs.h:280
cs_lnum_t * cell_family
Definition: cs_mesh.h:159
int n_transforms
Definition: cs_mesh.h:112
void cs_mesh_selector_stats(cs_mesh_t *mesh)
Definition: cs_mesh.c:3681
cs_lnum_t * gcell_vtx_idx
Definition: cs_mesh.h:147
fvm_periodicity_t * periodicity
Definition: cs_mesh.h:116
cs_gnum_t * global_b_face_num
Definition: cs_mesh.h:106
Definition: cs_mesh_builder.h:56
void syncmp(cs_real_t var[])
Definition: cs_mesh.c:1913
cs_gnum_t * cs_mesh_get_cell_gnum(const cs_mesh_t *mesh, int blank_perio)
Definition: cs_mesh.c:3482
cs_mesh_t * cs_mesh_create(void)
Definition: cs_mesh.c:2113
void cs_mesh_g_face_vertices_sizes(const cs_mesh_t *mesh, cs_gnum_t *g_i_face_vertices_size, cs_gnum_t *g_b_face_vertices_size)
Definition: cs_mesh.c:2445
void cs_mesh_sync_var_vect_ni(cs_real_t *var1, cs_real_t *var2, cs_real_t *var3)
Definition: cs_mesh.c:3207
void synvnr(cs_real_t var[])
Definition: cs_mesh.c:1996
cs_lnum_t * b_face_vtx_lst
Definition: cs_mesh.h:93
void cs_mesh_init_halo(cs_mesh_t *mesh, cs_mesh_builder_t *mb, cs_halo_type_t halo_type)
Definition: cs_mesh.c:2637
cs_gnum_t n_g_cells
Definition: cs_mesh.h:97
void cs_mesh_sync_var_scal(cs_real_t *var)
Definition: cs_mesh.c:3144
void cs_mesh_sync_var_diag_ni(cs_real_t *var11, cs_real_t *var22, cs_real_t *var33)
Definition: cs_mesh.c:3303
void synvin(cs_real_t var[])
Definition: cs_mesh.c:1955
cs_lnum_t n_domains
Definition: cs_mesh.h:68
#define BEGIN_C_DECLS
Definition: cs_defs.h:429
cs_lnum_t n_families
Definition: cs_mesh.h:156
void cs_mesh_sync_var_component(cs_real_t *var)
Definition: cs_mesh.c:3186
cs_lnum_t i_face_vtx_connect_size
Definition: cs_mesh.h:77
void cs_mesh_sync_var_tens_ni(cs_real_t *var11, cs_real_t *var12, cs_real_t *var13, cs_real_t *var21, cs_real_t *var22, cs_real_t *var23, cs_real_t *var31, cs_real_t *var32, cs_real_t *var33)
Definition: cs_mesh.c:3337
cs_mesh_t * cs_glob_mesh
cs_interface_set_t * vtx_interfaces
Definition: cs_mesh.h:126
void synvec(cs_real_t var1[], cs_real_t var2[], cs_real_t var3[])
Definition: cs_mesh.c:1934
cs_lnum_t * i_face_vtx_idx
Definition: cs_mesh.h:89
cs_lnum_t * i_face_vtx_lst
Definition: cs_mesh.h:90
cs_lnum_t * b_cells
Definition: cs_mesh.h:136
cs_lnum_t * family_item
Definition: cs_mesh.h:158
cs_gnum_t n_g_b_faces
Definition: cs_mesh.h:99
void cs_mesh_init_selectors(void)
Definition: cs_mesh.c:3096
cs_gnum_t n_g_free_faces
Definition: cs_mesh.h:173
Definition: cs_halo.h:70
void cs_mesh_get_perio_faces(const cs_mesh_t *mesh, cs_lnum_t **n_perio_face_couples, cs_gnum_t ***perio_face_couples)
Definition: cs_mesh.c:3430
cs_real_t * vtx_coord
Definition: cs_mesh.h:84
void cs_mesh_dump(const cs_mesh_t *mesh)
Definition: cs_mesh.c:3728
void cs_mesh_clean_families(cs_mesh_t *mesh)
Definition: cs_mesh.c:2913
void cs_mesh_sync_var_vect_no_rotation(cs_real_t *var)
Definition: cs_mesh.c:3280
struct _fvm_selector_t fvm_selector_t
Definition: fvm_selector.h:51
fvm_selector_t * select_i_faces
Definition: cs_mesh.h:168
cs_lnum_t * group_idx
Definition: cs_mesh.h:153
cs_gnum_t n_g_vertices
Definition: cs_mesh.h:100
void cs_mesh_free_rebuildable(cs_mesh_t *mesh, bool free_halos)
Definition: cs_mesh.c:2274
Definition: cs_mesh.h:62
fvm_selector_t * select_cells
Definition: cs_mesh.h:167
cs_gnum_t * global_cell_num
Definition: cs_mesh.h:104
cs_lnum_t n_vertices
Definition: cs_mesh.h:75
cs_lnum_t n_cells
Definition: cs_mesh.h:72
cs_lnum_t domain_num
Definition: cs_mesh.h:67
cs_mesh_t * cs_mesh_destroy(cs_mesh_t *mesh)
Definition: cs_mesh.c:2230
int n_init_perio
Definition: cs_mesh.h:111
void syntin(cs_real_t var[])
Definition: cs_mesh.c:2075
cs_gnum_t n_g_i_faces
Definition: cs_mesh.h:98
fvm_group_class_set_t * cs_mesh_create_group_classes(cs_mesh_t *mesh)
Definition: cs_mesh.c:3034
int modified
Definition: cs_mesh.h:176
void synsca(cs_real_t var[])
Definition: cs_mesh.c:1873
void cs_mesh_init_interfaces(cs_mesh_t *mesh, cs_mesh_builder_t *mb)
int verbosity
Definition: cs_mesh.h:175
cs_halo_type_t
Definition: cs_halo.h:49
void synvie(cs_real_t var[])
Definition: cs_mesh.c:1975
cs_lnum_t * gcell_vtx_lst
Definition: cs_mesh.h:148
void cs_mesh_sync_var_scal_ext(cs_real_t *var)
Definition: cs_mesh.c:3165
void cs_mesh_get_face_perio_num(const cs_mesh_t *mesh, int perio_num[])
Definition: cs_mesh.c:3559
cs_gnum_t cs_mesh_n_g_ghost_cells(cs_mesh_t *mesh)
Definition: cs_mesh.c:2890
struct _cs_interface_set_t cs_interface_set_t
Definition: cs_interface.h:61
int cs_lnum_2_t[2]
vector of 2 local mesh-entity ids
Definition: cs_defs.h:301
char * group_lst
Definition: cs_mesh.h:154
cs_lnum_t n_groups
Definition: cs_mesh.h:152
void cs_mesh_sync_var_tens(cs_real_t *var)
Definition: cs_mesh.c:3377
void cs_mesh_discard_free_faces(cs_mesh_t *mesh)
Definition: cs_mesh.c:2340
void synsce(cs_real_t var[])
Definition: cs_mesh.c:1893
void cs_mesh_print_info(const cs_mesh_t *mesh, const char *name)
Definition: cs_mesh.c:3603
void synten(cs_real_t var11[], cs_real_t var12[], cs_real_t var13[], cs_real_t var21[], cs_real_t var22[], cs_real_t var23[], cs_real_t var31[], cs_real_t var32[], cs_real_t var33[])
Definition: cs_mesh.c:2046
struct _fvm_periodicity_t fvm_periodicity_t
Definition: fvm_periodicity.h:67
cs_lnum_t dim
Definition: cs_mesh.h:66
void cs_mesh_init_group_classes(cs_mesh_t *mesh)
Definition: cs_mesh.c:3081
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:292
cs_lnum_t n_cells_with_ghosts
Definition: cs_mesh.h:122
cs_lnum_t n_ghost_cells
Definition: cs_mesh.h:124
cs_lnum_t * cell_cells_idx
Definition: cs_mesh.h:140
cs_gnum_t * global_i_face_num
Definition: cs_mesh.h:105
cs_lnum_t * b_face_vtx_idx
Definition: cs_mesh.h:92
#define END_C_DECLS
Definition: cs_defs.h:430
cs_lnum_t * i_face_family
Definition: cs_mesh.h:160
cs_numbering_t * cell_numbering
Definition: cs_mesh.h:129
void cs_mesh_sync_var_vect(cs_real_t *var)
Definition: cs_mesh.c:3233
double cs_real_t
Definition: cs_defs.h:296
void syntis(cs_real_t var[])
Definition: cs_mesh.c:2094
cs_numbering_t * b_face_numbering
Definition: cs_mesh.h:131
cs_gnum_t * global_vtx_num
Definition: cs_mesh.h:107
cs_lnum_t n_max_family_items
Definition: cs_mesh.h:157
cs_numbering_t * i_face_numbering
Definition: cs_mesh.h:130
#define CS_PROCF(x, y)
Definition: cs_defs.h:453
cs_lnum_t * b_face_family
Definition: cs_mesh.h:161
void cs_mesh_sync_var_vect_ext(cs_real_t *var)
Definition: cs_mesh.c:3257
cs_lnum_t n_b_cells
Definition: cs_mesh.h:135
int have_rotation_perio
Definition: cs_mesh.h:114
fvm_group_class_set_t * class_defs
Definition: cs_mesh.h:163
cs_halo_type_t halo_type
Definition: cs_mesh.h:120
struct _fvm_group_class_set_t fvm_group_class_set_t
Definition: fvm_group.h:60
void cs_mesh_update_auxiliary(cs_mesh_t *mesh)
Definition: cs_mesh.c:2537
cs_lnum_2_t * i_face_cells
Definition: cs_mesh.h:86
cs_lnum_t n_b_faces
Definition: cs_mesh.h:74
cs_lnum_t b_face_vtx_connect_size
Definition: cs_mesh.h:79
cs_lnum_t * cell_cells_lst
Definition: cs_mesh.h:143
Definition: cs_numbering.h:78
fvm_selector_t * select_b_faces
Definition: cs_mesh.h:169
cs_lnum_t n_i_faces
Definition: cs_mesh.h:73
Definition: mesh.f90:26
void cs_mesh_sync_var_sym_tens(cs_real_t *var)
Definition: cs_mesh.c:3399
cs_halo_t * halo
Definition: cs_mesh.h:127
void syndia(cs_real_t var11[], cs_real_t var22[], cs_real_t var33[])
Definition: cs_mesh.c:2017
cs_lnum_t * b_face_cells
Definition: cs_mesh.h:87