Code_Saturne
CFD tool
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-2012 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 
71  /* Local dimensions */
72 
73  cs_lnum_t n_cells; /* Number of cells */
74  cs_lnum_t n_i_faces; /* Number of interior faces */
75  cs_lnum_t n_b_faces; /* Number of boundary faces */
76  cs_lnum_t n_vertices; /* Number of vertices */
77 
78  cs_lnum_t i_face_vtx_connect_size; /* Size of the connectivity
79  interior faces -> vertices */
80  cs_lnum_t b_face_vtx_connect_size; /* Size of the connectivity
81  boundary faces -> vertices */
82 
83  /* Local structures */
84 
85  cs_real_t *vtx_coord; /* Vertex coordinates */
86 
87  cs_lnum_t *i_face_cells; /* Interior faces -> cells connectivity */
88  cs_lnum_t *b_face_cells; /* Boundary faces -> cells connectivity */
89 
90  cs_lnum_t *i_face_vtx_idx; /* Interior faces -> vertices index */
91  cs_lnum_t *i_face_vtx_lst; /* Interior faces -> vertices connectivity */
92 
93  cs_lnum_t *b_face_vtx_idx; /* Boundary faces -> vertices index */
94  cs_lnum_t *b_face_vtx_lst; /* Boundary faces -> vertices connectivity */
95 
96  /* Global dimension */
97 
98  cs_gnum_t n_g_cells; /* Global number of cells */
99  cs_gnum_t n_g_i_faces; /* Global number of interior faces */
100  cs_gnum_t n_g_b_faces; /* Global number of boundary faces */
101  cs_gnum_t n_g_vertices; /* Global number of vertices */
102 
103  /* Global numbering */
104 
105  cs_gnum_t *global_cell_num; /* Global cell numbering */
106  cs_gnum_t *global_i_face_num; /* Global interior face numbering */
107  cs_gnum_t *global_b_face_num; /* Global boundary face numbering */
108  cs_gnum_t *global_vtx_num; /* Global vertex numbering */
109 
110  /* Periodictity features */
111 
112  int n_init_perio; /* Number of initial periodicities */
113  int n_transforms; /* Number of transformations */
114 
115  int have_rotation_perio; /* Periodicity rotation indicator */
116 
117  fvm_periodicity_t *periodicity; /* parameters of each periodicity */
118 
119  /* Parallelism and/or periodic features */
120 
121  cs_halo_type_t halo_type; /* Halo type */
122 
123  cs_lnum_t n_cells_with_ghosts; /* Total number of cells on the local rank
124  (n_cells + n_ghost_cells) */
125  cs_lnum_t n_ghost_cells; /* Number of "ghost" cells */
126 
127  cs_interface_set_t *vtx_interfaces; /* Vertices interface set */
128  cs_halo_t *halo; /* Ghost cells structure */
129 
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 modified; /* Modification status */
176 
177 } cs_mesh_t;
178 
179 /*============================================================================
180  * Static global variables
181  *============================================================================*/
182 
183 extern cs_mesh_t *cs_glob_mesh; /* Pointer to main mesh structure */
184 
185 /*============================================================================
186  * Public function prototypes for Fortran API
187  *============================================================================*/
188 
189 /*----------------------------------------------------------------------------
190  * Return the group number corresponding to a given name. If the group exists,
191  * the number corresponds to the group rank (starting from 1) in the list of
192  * the meshe's groups, multiplied by -1. This numbering is that used in
193  * family (group class) description array IPRFML(NFML, NPRFML).
194  *
195  * If the group of the given name is not found, 9999 is returned.
196  *
197  * Fortran interface:
198  *
199  * FUNCTION NUMGRP (NAME, LEN)
200  * ***************
201  *
202  * CHARACTER* NAME : <-- : Name of the group
203  * INTEGER LEN : <-- : Group name length
204  *----------------------------------------------------------------------------*/
205 
206 cs_int_t CS_PROCF (numgrp, NUMGRP)
207 (
208  const char *name, /* <-- Group name */
209  const cs_int_t *len /* <-- Name length */
210  CS_ARGF_SUPP_CHAINE /* (possible 'length' arguments added
211  by many Fortran compilers) */
212 );
213 
214 /*----------------------------------------------------------------------------
215  * Update a scalar array in case of parallelism and/or periodicity.
216  *
217  * Fortran interface:
218  *
219  * subroutine synsca(var)
220  * *****************
221  *
222  * var : <-> : scalar array
223  *----------------------------------------------------------------------------*/
224 
225 void CS_PROCF(synsca, SYNSCA)
226 (
227  cs_real_t var[]
228 );
229 
230 /*----------------------------------------------------------------------------
231  * Update a scalar array in case of parallelism and/or periodicity,
232  * using an extended halo.
233  *
234  * Fortran interface:
235  *
236  * subroutine synsce(var)
237  * *****************
238  *
239  * var : <-> : scalar array
240  *----------------------------------------------------------------------------*/
241 
242 void CS_PROCF(synsce, SYNSCE)
243 (
244  cs_real_t var[]
245 );
246 
247 /*----------------------------------------------------------------------------
248  * Update a scalar array in case of parallelism and/or periodicity,
249  * ignoring periodicity of rotation
250  *
251  * Fortran interface:
252  *
253  * subroutine syncmp(var)
254  * *****************
255  *
256  * var : <-> : scalar array
257  *----------------------------------------------------------------------------*/
258 
259 void CS_PROCF(syncmp, SYNCMP)
260 (
261  cs_real_t var[]
262 );
263 
264 /*----------------------------------------------------------------------------
265  * Update a vector array in case of parallelism and/or periodicity.
266  *
267  * Fortran interface:
268  *
269  * subroutine synvec(var)
270  * *****************
271  *
272  * var1 : <-> : vector component 1 array
273  * var2 : <-> : vector component 2 array
274  * var3 : <-> : vector component 3 array
275  *----------------------------------------------------------------------------*/
276 
277 void CS_PROCF(synvec, SYNVEC)
278 (
279  cs_real_t var1[],
280  cs_real_t var2[],
281  cs_real_t var3[]
282 );
283 
284 /*----------------------------------------------------------------------------
285  * Update a vector array in case of parallelism and/or periodicity.
286  *
287  * Fortran interface:
288  *
289  * subroutine synvin(var)
290  * *****************
291  *
292  * var : <-> : interleaved vector (of dimension 3)
293  *----------------------------------------------------------------------------*/
294 
295 void CS_PROCF(synvin, SYNVIN)
296 (
297  cs_real_t var[]
298 );
299 
300 /*----------------------------------------------------------------------------
301  * Update a vector array in case of parallelism and/or periodicity,
302  * ignoring periodicity of rotation.
303  *
304  * Fortran interface:
305  *
306  * subroutine synvnr(var)
307  * *****************
308  *
309  * var : <-> : interleaved vector (of dimension 3)
310  *----------------------------------------------------------------------------*/
311 
312 void
313 CS_PROCF (synvnr, SYNVNR)
314 (
315  cs_real_t var[]
316 );
317 
318 /*----------------------------------------------------------------------------
319  * Update a diagonal tensor array in case of parallelism and/or periodicity.
320  *
321  * Fortran interface:
322  *
323  * subroutine syndia(var)
324  * *****************
325  *
326  * var11 : <-> : diagonal tensor component 11 array
327  * var22 : <-> : diagonal tensor component 22 array
328  * var33 : <-> : diagonal tensor component 33 array
329  *----------------------------------------------------------------------------*/
330 
331 void CS_PROCF(syndia, SYNDIA)
332 (
333  cs_real_t var11[],
334  cs_real_t var22[],
335  cs_real_t var33[]
336 );
337 
338 /*----------------------------------------------------------------------------
339  * Update a diagonal tensor array in case of parallelism and/or periodicity.
340  *
341  * Fortran interface:
342  *
343  * subroutine syndin(var)
344  * *****************
345  *
346  * var : <-> : interleaved diagonal tensor (of dimension 3)
347  *----------------------------------------------------------------------------*/
348 
349 void CS_PROCF(syndin, SYNDIN)
350 (
351  cs_real_t var[]
352 );
353 
354 /*----------------------------------------------------------------------------
355  * Update a tensor array in case of parallelism and/or periodicity.
356  *
357  * Fortran interface:
358  *
359  * subroutine synten(var)
360  * *****************
361  *
362  * var11 : <-> : tensor component 11 array
363  * var12 : <-> : tensor component 12 array
364  * var13 : <-> : tensor component 13 array
365  * var21 : <-> : tensor component 21 array
366  * var22 : <-> : tensor component 22 array
367  * var23 : <-> : tensor component 23 array
368  * var31 : <-> : tensor component 31 array
369  * var32 : <-> : tensor component 32 array
370  * var33 : <-> : tensor component 33 array
371  *----------------------------------------------------------------------------*/
372 
373 void CS_PROCF(synten, SYNTEN)
374 (
375  cs_real_t var11[],
376  cs_real_t var12[],
377  cs_real_t var13[],
378  cs_real_t var21[],
379  cs_real_t var22[],
380  cs_real_t var23[],
381  cs_real_t var31[],
382  cs_real_t var32[],
383  cs_real_t var33[]
384 );
385 
386 /*----------------------------------------------------------------------------
387  * Update a tensor array in case of parallelism and/or periodicity.
388  *
389  * Fortran interface:
390  *
391  * subroutine syntin(var)
392  * *****************
393  *
394  * var : <-> : interleaved tensor (of dimension 3x3)
395  *----------------------------------------------------------------------------*/
396 
397 void CS_PROCF(syntin, SYNTIN)
398 (
399  cs_real_t var[]
400 );
401 
402 /*=============================================================================
403  * Public function prototypes
404  *============================================================================*/
405 
406 /*----------------------------------------------------------------------------
407  * Create an empty mesh structure
408  *
409  * returns:
410  * pointer to created mesh structure
411  *----------------------------------------------------------------------------*/
412 
413 cs_mesh_t *
414 cs_mesh_create(void);
415 
416 /*----------------------------------------------------------------------------
417  * Destroy a mesh structure
418  *
419  * mesh <-> pointer to a mesh structure
420  *
421  * returns:
422  * NULL pointer
423  *----------------------------------------------------------------------------*/
424 
425 cs_mesh_t *
427 
428 /*----------------------------------------------------------------------------
429  * Remove arrays and structures that mey be rebuilt.
430  *
431  * mesh <-> pointer to a mesh structure
432  * free_halos <-- if true, free halos and parallel/periodic interface
433  * structures
434  *----------------------------------------------------------------------------*/
435 
436 void
438  bool free_halos);
439 
440 /*----------------------------------------------------------------------------
441  * Discard free (isolated) faces from a mesh.
442  *
443  * This should always be done before using the mesh for computation.
444  *
445  * parameters:
446  * mesh <-> pointer to mesh structure
447  *----------------------------------------------------------------------------*/
448 
449 void
451 
452 /*----------------------------------------------------------------------------
453  * Renumber vertices.
454  *
455  * Ensure: if i < j then mesh->global_vtx_num[i] < mesh->global_vtx_num[j]
456  *
457  * parameters:
458  * mesh <-> pointer to mesh structure
459  *----------------------------------------------------------------------------*/
460 
461 void
463 
464 /*----------------------------------------------------------------------------
465  * Compute or update mesh structure members the depend on other members,
466  * but whose results may be reused, such as global number of elements
467  * (cells, vertices, interior and boundary faces) and sync cell family.
468  *
469  * parameters:
470  * mesh <-> pointer to a cs_mesh_t structure
471  *----------------------------------------------------------------------------*/
472 
473 void
475 
476 /*----------------------------------------------------------------------------
477  * Creation and initialization of mesh face and vertex interfaces.
478  *
479  * parameters:
480  * mesh <-> pointer to mesh structure
481  * mb <-> pointer to mesh builder (in case of periodicity)
482  *----------------------------------------------------------------------------*/
483 
484 void
486  cs_mesh_builder_t *mb);
487 
488 /*----------------------------------------------------------------------------
489  * Creation and initialization of halo structures.
490  *
491  * Treatment of parallel and/or periodic halos for standard and extended
492  * ghost cells according to halo type requested by global options.
493  *
494  * parameters:
495  * mesh <-> pointer to mesh structure
496  * mb <-> pointer to mesh builder (in case of periodicity)
497  *----------------------------------------------------------------------------*/
498 
499 void
501  cs_mesh_builder_t *mb);
502 
503 /*----------------------------------------------------------------------------
504  * Get the global number of ghost cells.
505  *
506  * parameters:
507  * mesh <-- pointer to a mesh structure
508  *
509  * returns:
510  * Global number of ghost cells
511  *---------------------------------------------------------------------------*/
512 
513 cs_int_t
515 
516 /*----------------------------------------------------------------------------
517  * Update a scalar array in case of parallelism and/or periodicity.
518  *
519  * Note: this function is only present so that a C equivalent to the
520  * Fortran wrappers is available. In C code, directly using
521  * cs_halo_sync_var() is preferred.
522  *
523  * parameters:
524  * var <-> scalar array
525  *----------------------------------------------------------------------------*/
526 
527 void
529 
530 /*----------------------------------------------------------------------------
531  * Update a scalar array in case of parallelism and/or periodicity,
532  * using an extended halo.
533  *
534  * Note: this function is only present so that a C equivalent to the
535  * Fortran wrappers is available. In C code, directly using the
536  * cs_halo_sync_var() is preferred.
537  *
538  * parameters:
539  * var <-> scalar array
540  *----------------------------------------------------------------------------*/
541 
542 void
544 
545 /*----------------------------------------------------------------------------
546  * Update a component of a vector for parallelism and/or periodicity,
547  * ignoring periodicity of rotation.
548  *
549  * Note: this function is only present so that a C equivalent to the
550  * Fortran wrappers is available. In C code, directly using the
551  * cs_halo_sync_var() is preferred.
552  *
553  * parameters:
554  * var <-> scalar array
555  *----------------------------------------------------------------------------*/
556 
557 void
559 
560 /*----------------------------------------------------------------------------
561  * Update a vector array in case of parallelism and/or periodicity.
562  *
563  * parameters:
564  * var1 <-> vector component 1 array
565  * var2 <-> vector component 2 array
566  * var3 <-> vector component 3 array
567  *----------------------------------------------------------------------------*/
568 
569 void
571  cs_real_t *var2,
572  cs_real_t *var3);
573 
574 /*----------------------------------------------------------------------------
575  * Update a vector array in case of parallelism and/or periodicity.
576  *
577  * parameters:
578  * var <-> interleaved vector (of dimension 3)
579  *----------------------------------------------------------------------------*/
580 
581 void
583 
584 /*----------------------------------------------------------------------------
585  * Update a components of a vector for parallelism and/or periodicity,
586  * ignoring periodicity of rotation.
587  *
588  * var <-> gradient components (interleaved)
589  *----------------------------------------------------------------------------*/
590 
591 void
593 
594 /*----------------------------------------------------------------------------
595  * Update a diagonal tensor array in case of parallelism and/or periodicity.
596  *
597  * parameters:
598  * var11 <-> diagonal tensor component 11 array
599  * var22 <-> diagonal tensor component 22 array
600  * var33 <-> diagonal tensor component 33 array
601  *----------------------------------------------------------------------------*/
602 
603 void
605  cs_real_t *var22,
606  cs_real_t *var33);
607 
608 /*----------------------------------------------------------------------------
609  * Update a diagonal tensor array in case of parallelism and/or periodicity.
610  *
611  * parameters:
612  * var <-> diagonal tensor interleaved array
613  *----------------------------------------------------------------------------*/
614 
615 void
617 
618 /*----------------------------------------------------------------------------
619  * Update a tensor array in case of parallelism and/or periodicity.
620  *
621  * parameters:
622  * var11 <-> tensor component 11 array
623  * var12 <-> tensor component 12 array
624  * var13 <-> tensor component 13 array
625  * var21 <-> tensor component 21 array
626  * var22 <-> tensor component 22 array
627  * var23 <-> tensor component 23 array
628  * var31 <-> tensor component 31 array
629  * var32 <-> tensor component 32 array
630  * var33 <-> tensor component 33 array
631  *----------------------------------------------------------------------------*/
632 
633 void
635  cs_real_t *var12,
636  cs_real_t *var13,
637  cs_real_t *var21,
638  cs_real_t *var22,
639  cs_real_t *var23,
640  cs_real_t *var31,
641  cs_real_t *var32,
642  cs_real_t *var33);
643 
644 /*----------------------------------------------------------------------------
645  * Update a tensor array in case of parallelism and/or periodicity.
646  *
647  * parameters:
648  * var <-> interleaved tensor (of dimension 3x3)
649  *----------------------------------------------------------------------------*/
650 
651 void
653 
654 /*----------------------------------------------------------------------------
655  * Order family numbers and remove duplicates
656  *
657  * parameters
658  * mesh <-> pointer to mesh structure
659  *----------------------------------------------------------------------------*/
660 
661 void
663 
664 /*----------------------------------------------------------------------------
665  * Add colors to group class descriptions for group names which are
666  * convertible to integers.
667  *
668  * parameters
669  * mesh <-> pointer to mesh structure
670  *----------------------------------------------------------------------------*/
671 
672 void
674 
675 /*----------------------------------------------------------------------------
676  * Define group classes for a mesh based on its family definitions.
677  *
678  * parameters:
679  * mesh <-> pointer to mesh structure
680  *----------------------------------------------------------------------------*/
681 
682 void
684 
685 /*----------------------------------------------------------------------------
686  * Assign selectors to global mesh.
687  *
688  * Should be called once the mesh is fully built.
689  *----------------------------------------------------------------------------*/
690 
691 void
693 
694 /*----------------------------------------------------------------------------
695  * Get global lists of periodic face couples.
696  *
697  * In parallel, each face couple may appear on only one rank.
698  *
699  * The caller is responsible for freeing the arrays allocated and returned
700  * by this function once they are no onger needed.
701  *
702  * parameters:
703  * mesh <-- pointer to mesh structure
704  * n_perio_face_couples --> global number of periodic couples per
705  * periodicity (size: mesh->n_init_perio)
706  * perio_face_couples --> arrays of global periodic couple face numbers,
707  * for each periodicity
708  *----------------------------------------------------------------------------*/
709 
710 void
712  cs_lnum_t **n_perio_face_couples,
713  cs_gnum_t ***perio_face_couples);
714 
715 /*----------------------------------------------------------------------------
716  * Build global cell numbering array extended to ghost cell values.
717  *
718  * If the blank_perio flag is nonzero, periodic ghost cell numbers
719  * are set to zero instead of the value of the matching cell.
720  *
721  * The caller is responsible for freeing the returned array when it
722  * is no longer useful.
723  *
724  * parameters:
725  * mesh <-- pointer to mesh structure
726  * blank_perio <-- flag to zeroe periodic cell values
727  *----------------------------------------------------------------------------*/
728 
729 cs_gnum_t *
731  int blank_perio);
732 
733 /*----------------------------------------------------------------------------
734  * Mark interior faces with the number of their associated periodic
735  * transform id.
736  *
737  * parameters:
738  * mesh <-- pointer to mesh structure
739  * perio_num --> periodicity number associated with each face, signed for
740  * direct/reverse transform, 0 for non-periodic faces
741  * (size: mesh->n_i_faces)
742  *----------------------------------------------------------------------------*/
743 
744 void
746  int perio_num[]);
747 
748 /*----------------------------------------------------------------------------
749  * Print information on a mesh structure.
750  *
751  * parameters:
752  * mesh <-- pointer to mesh structure.
753  * name <-- associated name.
754  *----------------------------------------------------------------------------*/
755 
756 void
758  const char *name);
759 
760 /*----------------------------------------------------------------------------
761  * Compute global face connectivity size.
762  *
763  * Faces on simple parallel boundaries are counted only once, but periodic
764  * faces are counted twice.
765  *
766  * parameters:
767  * mesh <-- pointer to a cs_mesh_t structure
768  * g_i_face_vertices_size --> global interior face connectivity size, or NULL
769  * g_b_face_vertices_size --> global boundary face connectivity size, or NULL
770  *----------------------------------------------------------------------------*/
771 
772 void
774  cs_gnum_t *g_i_face_vertices_size,
775  cs_gnum_t *g_b_face_vertices_size);
776 
777 /*----------------------------------------------------------------------------
778  * Print statistics about mesh selectors usage to log.
779  *
780  * parameters:
781  * mesh <-- pointer to a mesh structure
782  *----------------------------------------------------------------------------*/
783 
784 void
786 
787 /*----------------------------------------------------------------------------
788  * Dump of a mesh structure.
789  *
790  * parameters:
791  * mesh <-> pointer to mesh structure.
792  *----------------------------------------------------------------------------*/
793 
794 void
795 cs_mesh_dump(const cs_mesh_t *mesh);
796 
797 /*----------------------------------------------------------------------------*/
798 
800 
801 #endif /* __CS_MESH_H__ */
void cs_mesh_sync_var_diag(cs_real_t *var)
Definition: cs_mesh.c:3491
cs_lnum_t * i_face_cells
Definition: cs_mesh.h:87
Definition: fvm_periodicity.c:123
cs_lnum_t * cell_family
Definition: cs_mesh.h:159
int n_transforms
Definition: cs_mesh.h:113
void cs_mesh_selector_stats(cs_mesh_t *mesh)
Definition: cs_mesh.c:3843
size_t len
Definition: mei_scanner.c:639
cs_lnum_t * gcell_vtx_idx
Definition: cs_mesh.h:147
fvm_periodicity_t * periodicity
Definition: cs_mesh.h:117
cs_gnum_t * global_b_face_num
Definition: cs_mesh.h:107
Definition: cs_mesh_builder.h:56
void syncmp(cs_real_t var[])
Definition: cs_mesh.c:1971
cs_gnum_t * cs_mesh_get_cell_gnum(const cs_mesh_t *mesh, int blank_perio)
Definition: cs_mesh.c:3644
cs_mesh_t * cs_mesh_create(void)
Definition: cs_mesh.c:2151
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:2550
void cs_mesh_sync_var_vect_ni(cs_real_t *var1, cs_real_t *var2, cs_real_t *var3)
Definition: cs_mesh.c:3393
void synvnr(cs_real_t var[])
Definition: cs_mesh.c:2034
cs_lnum_t * b_face_vtx_lst
Definition: cs_mesh.h:94
cs_int_t numgrp(const char *name, const cs_int_t *len CS_ARGF_SUPP_CHAINE)
Definition: cs_mesh.c:1894
cs_gnum_t n_g_cells
Definition: cs_mesh.h:98
void cs_mesh_sync_var_scal(cs_real_t *var)
Definition: cs_mesh.c:3330
void cs_mesh_sync_var_diag_ni(cs_real_t *var11, cs_real_t *var22, cs_real_t *var33)
Definition: cs_mesh.c:3465
void synvin(cs_real_t var[])
Definition: cs_mesh.c:2013
cs_lnum_t n_domains
Definition: cs_mesh.h:68
#define BEGIN_C_DECLS
Definition: cs_defs.h:365
cs_lnum_t n_families
Definition: cs_mesh.h:156
void cs_mesh_sync_var_component(cs_real_t *var)
Definition: cs_mesh.c:3372
cs_lnum_t i_face_vtx_connect_size
Definition: cs_mesh.h:78
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:3521
cs_mesh_t * cs_glob_mesh
Definition: cs_mesh.c:94
cs_interface_set_t * vtx_interfaces
Definition: cs_mesh.h:127
void synvec(cs_real_t var1[], cs_real_t var2[], cs_real_t var3[])
Definition: cs_mesh.c:1992
void cs_mesh_build_colors(cs_mesh_t *mesh)
Definition: cs_mesh.c:3133
cs_lnum_t * i_face_vtx_idx
Definition: cs_mesh.h:90
cs_lnum_t * i_face_vtx_lst
Definition: cs_mesh.h:91
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:100
void cs_mesh_init_selectors(void)
Definition: cs_mesh.c:3282
cs_gnum_t n_g_free_faces
Definition: cs_mesh.h:173
Definition: cs_halo.h:75
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:3592
cs_real_t * vtx_coord
Definition: cs_mesh.h:85
#define CS_ARGF_SUPP_CHAINE
Definition: cs_defs.h:394
void cs_mesh_dump(const cs_mesh_t *mesh)
Definition: cs_mesh.c:3890
int cs_int_t
Definition: cs_defs.h:263
void cs_mesh_clean_families(cs_mesh_t *mesh)
Definition: cs_mesh.c:3014
void cs_mesh_sync_var_vect_no_rotation(cs_real_t *var)
Definition: cs_mesh.c:3442
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:101
void cs_mesh_free_rebuildable(cs_mesh_t *mesh, bool free_halos)
Definition: cs_mesh.c:2310
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:105
cs_lnum_t n_vertices
Definition: cs_mesh.h:76
cs_lnum_t n_cells
Definition: cs_mesh.h:73
cs_lnum_t domain_num
Definition: cs_mesh.h:67
cs_mesh_t * cs_mesh_destroy(cs_mesh_t *mesh)
Definition: cs_mesh.c:2266
int n_init_perio
Definition: cs_mesh.h:112
void syntin(cs_real_t var[])
Definition: cs_mesh.c:2132
int cs_lnum_t
Definition: cs_defs.h:260
cs_gnum_t n_g_i_faces
Definition: cs_mesh.h:99
int modified
Definition: cs_mesh.h:175
void synsca(cs_real_t var[])
Definition: cs_mesh.c:1931
void cs_mesh_init_interfaces(cs_mesh_t *mesh, cs_mesh_builder_t *mb)
cs_halo_type_t
Definition: cs_halo.h:49
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:3351
unsigned cs_gnum_t
Definition: cs_defs.h:255
Definition: fvm_group.c:83
void cs_mesh_get_face_perio_num(const cs_mesh_t *mesh, int perio_num[])
Definition: cs_mesh.c:3721
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:3561
void cs_mesh_discard_free_faces(cs_mesh_t *mesh)
Definition: cs_mesh.c:2374
void synsce(cs_real_t var[])
Definition: cs_mesh.c:1951
void cs_mesh_print_info(const cs_mesh_t *mesh, const char *name)
Definition: cs_mesh.c:3765
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:2103
cs_lnum_t dim
Definition: cs_mesh.h:66
void cs_mesh_init_group_classes(cs_mesh_t *mesh)
Definition: cs_mesh.c:3235
void cs_mesh_init_halo(cs_mesh_t *mesh, cs_mesh_builder_t *mb)
Definition: cs_mesh.c:2740
cs_lnum_t n_cells_with_ghosts
Definition: cs_mesh.h:123
cs_lnum_t n_ghost_cells
Definition: cs_mesh.h:125
cs_int_t cs_mesh_n_g_ghost_cells(cs_mesh_t *mesh)
Definition: cs_mesh.c:2985
cs_lnum_t * cell_cells_idx
Definition: cs_mesh.h:140
cs_gnum_t * global_i_face_num
Definition: cs_mesh.h:106
cs_lnum_t * b_face_vtx_idx
Definition: cs_mesh.h:93
#define END_C_DECLS
Definition: cs_defs.h:366
cs_lnum_t * i_face_family
Definition: cs_mesh.h:160
void cs_mesh_sync_var_vect(cs_real_t *var)
Definition: cs_mesh.c:3419
double cs_real_t
Definition: cs_defs.h:264
cs_numbering_t * b_face_numbering
Definition: cs_mesh.h:131
cs_gnum_t * global_vtx_num
Definition: cs_mesh.h:108
Definition: fvm_selector.c:104
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:379
Definition: cs_interface.c:106
void syndin(cs_real_t var[])
Definition: cs_mesh.c:2076
cs_lnum_t * b_face_family
Definition: cs_mesh.h:161
cs_lnum_t n_b_cells
Definition: cs_mesh.h:135
int have_rotation_perio
Definition: cs_mesh.h:115
fvm_group_class_set_t * class_defs
Definition: cs_mesh.h:163
cs_halo_type_t halo_type
Definition: cs_mesh.h:121
void cs_mesh_update_auxiliary(cs_mesh_t *mesh)
Definition: cs_mesh.c:2642
cs_lnum_t n_b_faces
Definition: cs_mesh.h:75
cs_lnum_t b_face_vtx_connect_size
Definition: cs_mesh.h:80
cs_lnum_t * cell_cells_lst
Definition: cs_mesh.h:143
Definition: cs_numbering.h:66
fvm_selector_t * select_b_faces
Definition: cs_mesh.h:169
cs_lnum_t n_i_faces
Definition: cs_mesh.h:74
Definition: mesh.f90:25
cs_halo_t * halo
Definition: cs_mesh.h:128
void syndia(cs_real_t var11[], cs_real_t var22[], cs_real_t var33[])
Definition: cs_mesh.c:2055
void cs_mesh_order_vertices(cs_mesh_t *mesh)
Definition: cs_mesh.c:2476
cs_lnum_t * b_face_cells
Definition: cs_mesh.h:88