6.2
general 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-2020 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 #include "cs_range_set.h"
45 
46 #include "cs_mesh_builder.h"
47 
48 /*----------------------------------------------------------------------------*/
49 
51 
52 /*=============================================================================
53  * Macro definitions
54  *============================================================================*/
55 
56 /*============================================================================
57  * Type definitions
58  *============================================================================*/
59 
61 /* -------------------- */
62 
63 typedef enum {
64 
70 
72 /* ------------------------- */
73 
74 typedef struct {
75 
76  /* General features */
77 
79  int domain_num;
80  int n_domains;
84  /* Local dimensions */
85 
96  /* Local structures */
97 
109  /* Global dimension */
110 
120  /* Global numbering */
121 
127  /* Periodictity features */
128 
136  /* Parallelism and/or periodic features */
137 
154  /* Re-computable connectivity features */
155 
159  /* Extended neighborhood features */
160 
171  /* Group and family features */
172 
173  int n_groups;
174  int *group_idx;
175  char *group;
179  int *family_item;
180  int *cell_family;
192  /* Refinement features */
193 
194  char *i_face_r_gen;
196  /* Status flags */
197 
206  int verbosity;
207  int modified;
213 } cs_mesh_t;
214 
215 /*============================================================================
216  * Static global variables
217  *============================================================================*/
218 
219 extern cs_mesh_t *cs_glob_mesh; /* Pointer to main mesh structure */
220 
221 /*============================================================================
222  * Public function prototypes for Fortran API
223  *============================================================================*/
224 
225 /*----------------------------------------------------------------------------
226  * Update a scalar array in case of parallelism and/or periodicity.
227  *
228  * Fortran interface:
229  *
230  * subroutine synsca(var)
231  * *****************
232  *
233  * var : <-> : scalar array
234  *----------------------------------------------------------------------------*/
235 
236 void CS_PROCF(synsca, SYNSCA)
237 (
238  cs_real_t var[]
239 );
240 
241 /*----------------------------------------------------------------------------
242  * Update a scalar array in case of parallelism and/or periodicity,
243  * using an extended halo.
244  *
245  * Fortran interface:
246  *
247  * subroutine synsce(var)
248  * *****************
249  *
250  * var : <-> : scalar array
251  *----------------------------------------------------------------------------*/
252 
253 void CS_PROCF(synsce, SYNSCE)
254 (
255  cs_real_t var[]
256 );
257 
258 /*----------------------------------------------------------------------------
259  * Update a scalar array in case of parallelism and/or periodicity,
260  * ignoring periodicity of rotation
261  *
262  * Fortran interface:
263  *
264  * subroutine syncmp(var)
265  * *****************
266  *
267  * var : <-> : scalar array
268  *----------------------------------------------------------------------------*/
269 
270 void CS_PROCF(syncmp, SYNCMP)
271 (
272  cs_real_t var[]
273 );
274 
275 /*----------------------------------------------------------------------------
276  * Update a vector array in case of parallelism and/or periodicity.
277  *
278  * Fortran interface:
279  *
280  * subroutine synvec(var)
281  * *****************
282  *
283  * var1 : <-> : vector component 1 array
284  * var2 : <-> : vector component 2 array
285  * var3 : <-> : vector component 3 array
286  *----------------------------------------------------------------------------*/
287 
288 void CS_PROCF(synvec, SYNVEC)
289 (
290  cs_real_t var1[],
291  cs_real_t var2[],
292  cs_real_t var3[]
293 );
294 
295 /*----------------------------------------------------------------------------
296  * Update a vector array in case of parallelism and/or periodicity.
297  *
298  * Fortran interface:
299  *
300  * subroutine synvin(var)
301  * *****************
302  *
303  * var : <-> : interleaved vector (of dimension 3)
304  *----------------------------------------------------------------------------*/
305 
306 void CS_PROCF(synvin, SYNVIN)
307 (
308  cs_real_t var[]
309 );
310 
311 /*----------------------------------------------------------------------------
312  * Update a vector array in case of parallelism and/or periodicity,
313  * using an extended halo.
314  *
315  * Fortran interface:
316  *
317  * subroutine synvin(var)
318  * *****************
319  *
320  * var : <-> : interleaved vector (of dimension 3)
321  *----------------------------------------------------------------------------*/
322 
323 void CS_PROCF(synvie, SYNVIE)
324 (
325  cs_real_t var[]
326 );
327 
328 /*----------------------------------------------------------------------------
329  * Update a tensor array in case of parallelism and/or periodicity.
330  *
331  * Fortran interface:
332  *
333  * subroutine synten(var)
334  * *****************
335  *
336  * var11 : <-> : tensor component 11 array
337  * var12 : <-> : tensor component 12 array
338  * var13 : <-> : tensor component 13 array
339  * var21 : <-> : tensor component 21 array
340  * var22 : <-> : tensor component 22 array
341  * var23 : <-> : tensor component 23 array
342  * var31 : <-> : tensor component 31 array
343  * var32 : <-> : tensor component 32 array
344  * var33 : <-> : tensor component 33 array
345  *----------------------------------------------------------------------------*/
346 
347 void CS_PROCF(synten, SYNTEN)
348 (
349  cs_real_t var11[],
350  cs_real_t var12[],
351  cs_real_t var13[],
352  cs_real_t var21[],
353  cs_real_t var22[],
354  cs_real_t var23[],
355  cs_real_t var31[],
356  cs_real_t var32[],
357  cs_real_t var33[]
358 );
359 
360 /*----------------------------------------------------------------------------
361  * Update a tensor array in case of parallelism and/or periodicity.
362  *
363  * Fortran interface:
364  *
365  * subroutine syntin(var)
366  * *****************
367  *
368  * var : <-> : interleaved tensor (of dimension 3x3)
369  *----------------------------------------------------------------------------*/
370 
371 void CS_PROCF(syntin, SYNTIN)
372 (
373  cs_real_t var[]
374 );
375 
376 /*----------------------------------------------------------------------------
377  * Update a symmetric tensor array in case of parallelism and/or periodicity.
378  *
379  * Fortran interface:
380  *
381  * subroutine syntis(var)
382  * *****************
383  *
384  * var : <-> : interleaved symmetric tensor (of dimension 6)
385  *----------------------------------------------------------------------------*/
386 
387 void CS_PROCF(syntis, SYNTIS)
388 (
389  cs_real_t var[]
390 );
391 
392 /*=============================================================================
393  * Public function prototypes
394  *============================================================================*/
395 
396 /*----------------------------------------------------------------------------
397  * Create an empty mesh structure
398  *
399  * returns:
400  * pointer to created mesh structure
401  *----------------------------------------------------------------------------*/
402 
403 cs_mesh_t *
404 cs_mesh_create(void);
405 
406 /*----------------------------------------------------------------------------
407  * Destroy a mesh structure
408  *
409  * mesh <-> pointer to a mesh structure
410  *
411  * returns:
412  * NULL pointer
413  *----------------------------------------------------------------------------*/
414 
415 cs_mesh_t *
417 
418 /*----------------------------------------------------------------------------
419  * Update (compactify) an array of global numbers.
420  *
421  * parameters:
422  * n_elts <-> number of local elements
423  * elt_gnum <-> global element numbers
424  *
425  * return:
426  * associated global number of elements
427  *----------------------------------------------------------------------------*/
428 
429 cs_gnum_t
431  cs_gnum_t *elt_gnum);
432 
433 /*----------------------------------------------------------------------------
434  * Remove arrays and structures that mey be rebuilt.
435  *
436  * mesh <-> pointer to a mesh structure
437  * free_halos <-- if true, free halos and parallel/periodic interface
438  * structures
439  *----------------------------------------------------------------------------*/
440 
441 void
443  bool free_halos);
444 
445 /*----------------------------------------------------------------------------
446  * Discard free (isolated) faces from a mesh.
447  *
448  * This should always be done before using the mesh for computation.
449  *
450  * parameters:
451  * mesh <-> pointer to mesh structure
452  *----------------------------------------------------------------------------*/
453 
454 void
456 
457 /*----------------------------------------------------------------------------
458  * Discard free (isolated) vertices from a mesh.
459  *
460  * This is recommended before using the mesh for computation.
461  *
462  * parameters:
463  * mesh <-> pointer to mesh structure
464  *----------------------------------------------------------------------------*/
465 
466 void
468 
469 /*----------------------------------------------------------------------------
470  * Generate or update list of mesh boundary cells.
471  *
472  * parameters:
473  * mesh <-> pointer to a cs_mesh_t structure
474  *----------------------------------------------------------------------------*/
475 
476 void
478 
479 /*----------------------------------------------------------------------------
480  * Compute or update mesh structure members that depend on other members,
481  * but whose results may be reused, such as global number of elements
482  * (cells, vertices, interior and boundary faces) and sync cell family.
483  *
484  * parameters:
485  * mesh <-> pointer to a cs_mesh_t structure
486  *----------------------------------------------------------------------------*/
487 
488 void
490 
491 /*----------------------------------------------------------------------------
492  * Creation and initialization of mesh face and vertex interfaces.
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  * Creation and initialization of halo structures.
505  *
506  * Treatment of parallel and/or periodic halos for standard and extended
507  * ghost cells according to halo type requested by global options.
508  *
509  * parameters:
510  * mesh <-> pointer to mesh structure
511  * mb <-> pointer to mesh builder (in case of periodicity)
512  * halo_type <-> type of halo (standard or extended)
513  *----------------------------------------------------------------------------*/
514 
515 void
517  cs_mesh_builder_t *mb,
518  cs_halo_type_t halo_type);
519 
520 /*----------------------------------------------------------------------------
521  * Get the global number of ghost cells.
522  *
523  * parameters:
524  * mesh <-- pointer to a mesh structure
525  *
526  * returns:
527  * Global number of ghost cells
528  *---------------------------------------------------------------------------*/
529 
530 cs_gnum_t
532 
533 /*----------------------------------------------------------------------------
534  * Update a scalar array in case of parallelism and/or periodicity.
535  *
536  * Note: this function is only present so that a C equivalent to the
537  * Fortran wrappers is available. In C code, directly using
538  * cs_halo_sync_var() is preferred.
539  *
540  * parameters:
541  * var <-> scalar array
542  *----------------------------------------------------------------------------*/
543 
544 void
546 
547 /*----------------------------------------------------------------------------
548  * Update a scalar array in case of parallelism and/or periodicity,
549  * using an extended halo.
550  *
551  * Note: this function is only present so that a C equivalent to the
552  * Fortran wrappers is available. In C code, directly using the
553  * cs_halo_sync_var() is preferred.
554  *
555  * parameters:
556  * var <-> scalar array
557  *----------------------------------------------------------------------------*/
558 
559 void
561 
562 /*----------------------------------------------------------------------------
563  * Update a component of a vector for parallelism and/or periodicity,
564  * ignoring periodicity of rotation.
565  *
566  * Note: this function is only present so that a C equivalent to the
567  * Fortran wrappers is available. In C code, directly using the
568  * cs_halo_sync_var() is preferred.
569  *
570  * parameters:
571  * var <-> scalar array
572  *----------------------------------------------------------------------------*/
573 
574 void
576 
577 /*----------------------------------------------------------------------------
578  * Update a vector array in case of parallelism and/or periodicity.
579  *
580  * parameters:
581  * var1 <-> vector component 1 array
582  * var2 <-> vector component 2 array
583  * var3 <-> vector component 3 array
584  *----------------------------------------------------------------------------*/
585 
586 void
588  cs_real_t *var2,
589  cs_real_t *var3);
590 
591 /*----------------------------------------------------------------------------
592  * Update a vector array in case of parallelism and/or periodicity.
593  *
594  * parameters:
595  * var <-> interleaved vector (of dimension 3)
596  *----------------------------------------------------------------------------*/
597 
598 void
600 
601 /*----------------------------------------------------------------------------
602  * Update a vector array in case of parallelism and/or periodicity,
603  * using an extended halo.
604  *
605  * parameters:
606  * var <-> interleaved vector (of dimension 3)
607  *----------------------------------------------------------------------------*/
608 
609 void
611 
612 /*----------------------------------------------------------------------------
613  * Update a components of a vector for parallelism and/or periodicity,
614  * ignoring periodicity of rotation.
615  *
616  * var <-> gradient components (interleaved)
617  *----------------------------------------------------------------------------*/
618 
619 void
621 
622 /*----------------------------------------------------------------------------
623  * Update a diagonal tensor array in case of parallelism and/or periodicity.
624  *
625  * parameters:
626  * var11 <-> diagonal tensor component 11 array
627  * var22 <-> diagonal tensor component 22 array
628  * var33 <-> diagonal tensor component 33 array
629  *----------------------------------------------------------------------------*/
630 
631 void
633  cs_real_t *var22,
634  cs_real_t *var33);
635 
636 /*----------------------------------------------------------------------------
637  * Update a tensor array in case of parallelism and/or periodicity.
638  *
639  * parameters:
640  * var11 <-> tensor component 11 array
641  * var12 <-> tensor component 12 array
642  * var13 <-> tensor component 13 array
643  * var21 <-> tensor component 21 array
644  * var22 <-> tensor component 22 array
645  * var23 <-> tensor component 23 array
646  * var31 <-> tensor component 31 array
647  * var32 <-> tensor component 32 array
648  * var33 <-> tensor component 33 array
649  *----------------------------------------------------------------------------*/
650 
651 void
653  cs_real_t *var12,
654  cs_real_t *var13,
655  cs_real_t *var21,
656  cs_real_t *var22,
657  cs_real_t *var23,
658  cs_real_t *var31,
659  cs_real_t *var32,
660  cs_real_t *var33);
661 
662 /*----------------------------------------------------------------------------
663  * Update a tensor array in case of parallelism and/or periodicity.
664  *
665  * parameters:
666  * var <-> interleaved tensor (of dimension 3x3)
667  *----------------------------------------------------------------------------*/
668 
669 void
671 
672 /*----------------------------------------------------------------------------
673  * Update a symmetric tensor array in case of parallelism and/or periodicity.
674  *
675  * parameters:
676  * var <-> symmetric interleaved tensor (of dimension 6)
677  *----------------------------------------------------------------------------*/
678 
679 void
681 
682 /*----------------------------------------------------------------------------
683  * Order family numbers and remove duplicates
684  *
685  * parameters
686  * mesh <-> pointer to mesh structure
687  *----------------------------------------------------------------------------*/
688 
689 void
691 
692 /*----------------------------------------------------------------------------
693  * Create group classes based on a mesh's family definitions.
694  *
695  * parameters:
696  * mesh <-- pointer to mesh structure
697  *
698  * returns:
699  * pointer to group classes structure based on mesh's family definitions
700  *----------------------------------------------------------------------------*/
701 
704 
705 /*----------------------------------------------------------------------------
706  * Define group classes for a mesh based on its family definitions.
707  *
708  * parameters:
709  * mesh <-> pointer to mesh structure
710  *----------------------------------------------------------------------------*/
711 
712 void
714 
715 /*----------------------------------------------------------------------------
716  * Assign selectors to global mesh.
717  *
718  * Should be called once the mesh is fully built.
719  *----------------------------------------------------------------------------*/
720 
721 void
723 
724 /*----------------------------------------------------------------------------
725  * Update selector and associated structures.
726  *
727  * parameters:
728  * mesh <-> pointer to a mesh structure
729  *----------------------------------------------------------------------------*/
730 
731 void
733 
734 /*----------------------------------------------------------------------------
735  * Get global lists of periodic face couples.
736  *
737  * In parallel, each face couple may appear on only one rank.
738  *
739  * The caller is responsible for freeing the arrays allocated and returned
740  * by this function once they are no onger needed.
741  *
742  * parameters:
743  * mesh <-- pointer to mesh structure
744  * n_perio_face_couples --> global number of periodic couples per
745  * periodicity (size: mesh->n_init_perio)
746  * perio_face_couples --> arrays of global periodic couple face numbers,
747  * for each periodicity
748  *----------------------------------------------------------------------------*/
749 
750 void
752  cs_lnum_t **n_perio_face_couples,
753  cs_gnum_t ***perio_face_couples);
754 
755 /*----------------------------------------------------------------------------
756  * Build global cell numbering array extended to ghost cell values.
757  *
758  * If the blank_perio flag is nonzero, periodic ghost cell numbers
759  * are set to zero instead of the value of the matching cell.
760  *
761  * The caller is responsible for freeing the returned array when it
762  * is no longer useful.
763  *
764  * parameters:
765  * mesh <-- pointer to mesh structure
766  * blank_perio <-- flag to zeroe periodic cell values
767  *----------------------------------------------------------------------------*/
768 
769 cs_gnum_t *
771  int blank_perio);
772 
773 /*----------------------------------------------------------------------------
774  * Mark interior faces with the number of their associated periodic
775  * transform id.
776  *
777  * parameters:
778  * mesh <-- pointer to mesh structure
779  * perio_num --> periodicity number associated with each face, signed for
780  * direct/reverse transform, 0 for non-periodic faces
781  * (size: mesh->n_i_faces)
782  *----------------------------------------------------------------------------*/
783 
784 void
786  int perio_num[]);
787 
788 /*----------------------------------------------------------------------------
789  * Print information on a mesh structure.
790  *
791  * parameters:
792  * mesh <-- pointer to mesh structure.
793  * name <-- associated name.
794  *----------------------------------------------------------------------------*/
795 
796 void
798  const char *name);
799 
800 /*----------------------------------------------------------------------------
801  * Compute global face connectivity size.
802  *
803  * Faces on simple parallel boundaries are counted only once, but periodic
804  * faces are counted twice.
805  *
806  * parameters:
807  * mesh <-- pointer to a cs_mesh_t structure
808  * g_i_face_vertices_size --> global interior face connectivity size, or NULL
809  * g_b_face_vertices_size --> global boundary face connectivity size, or NULL
810  *----------------------------------------------------------------------------*/
811 
812 void
814  cs_gnum_t *g_i_face_vertices_size,
815  cs_gnum_t *g_b_face_vertices_size);
816 
817 /*----------------------------------------------------------------------------
818  * Print statistics about mesh selectors usage to log.
819  *
820  * parameters:
821  * mesh <-- pointer to a mesh structure
822  *----------------------------------------------------------------------------*/
823 
824 void
826 
827 /*----------------------------------------------------------------------------
828  * Dump of a mesh structure.
829  *
830  * parameters:
831  * mesh <-> pointer to mesh structure.
832  *----------------------------------------------------------------------------*/
833 
834 void
835 cs_mesh_dump(const cs_mesh_t *mesh);
836 
837 /*----------------------------------------------------------------------------*/
838 
840 
841 #endif /* __CS_MESH_H__ */
int save_if_modified
Definition: cs_mesh.h:208
unsigned long cs_gnum_t
global mesh entity number
Definition: cs_defs.h:286
cs_gnum_t cs_mesh_compact_gnum(cs_lnum_t n_elts, cs_gnum_t *elt_gnum)
Definition: cs_mesh.c:2323
int n_transforms
Definition: cs_mesh.h:130
void cs_mesh_selector_stats(cs_mesh_t *mesh)
Definition: cs_mesh.c:3828
cs_lnum_t * gcell_vtx_idx
Definition: cs_mesh.h:168
fvm_periodicity_t * periodicity
Definition: cs_mesh.h:134
cs_gnum_t * global_b_face_num
Definition: cs_mesh.h:124
Definition: cs_mesh_builder.h:57
void syncmp(cs_real_t var[])
Definition: cs_mesh.c:1986
cs_gnum_t * cs_mesh_get_cell_gnum(const cs_mesh_t *mesh, int blank_perio)
Definition: cs_mesh.c:3629
cs_mesh_t * cs_mesh_create(void)
Definition: cs_mesh.c:2142
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:2528
void cs_mesh_sync_var_vect_ni(cs_real_t *var1, cs_real_t *var2, cs_real_t *var3)
Definition: cs_mesh.c:3354
int * b_face_family
Definition: cs_mesh.h:182
Definition: cs_mesh.h:67
cs_gnum_t n_g_b_faces_all
Definition: cs_mesh.h:201
cs_lnum_t * b_face_vtx_lst
Definition: cs_mesh.h:107
void cs_mesh_init_halo(cs_mesh_t *mesh, cs_mesh_builder_t *mb, cs_halo_type_t halo_type)
Definition: cs_mesh.c:2760
cs_gnum_t n_g_cells
Definition: cs_mesh.h:111
void cs_mesh_sync_var_scal(cs_real_t *var)
Definition: cs_mesh.c:3291
void cs_mesh_sync_var_diag_ni(cs_real_t *var11, cs_real_t *var22, cs_real_t *var33)
Definition: cs_mesh.c:3450
void synvin(cs_real_t var[])
Definition: cs_mesh.c:2028
cs_range_set_t * vtx_range_set
Definition: cs_mesh.h:146
#define BEGIN_C_DECLS
Definition: cs_defs.h:495
void cs_mesh_sync_var_component(cs_real_t *var)
Definition: cs_mesh.c:3333
cs_lnum_t i_face_vtx_connect_size
Definition: cs_mesh.h:91
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:3484
cs_mesh_t * cs_glob_mesh
cs_interface_set_t * vtx_interfaces
Definition: cs_mesh.h:144
void synvec(cs_real_t var1[], cs_real_t var2[], cs_real_t var3[])
Definition: cs_mesh.c:2007
cs_lnum_t * i_face_vtx_idx
Definition: cs_mesh.h:103
cs_lnum_t * i_face_vtx_lst
Definition: cs_mesh.h:104
cs_lnum_t * b_cells
Definition: cs_mesh.h:157
int * group_idx
Definition: cs_mesh.h:174
cs_gnum_t n_g_b_faces
Definition: cs_mesh.h:113
void cs_mesh_init_selectors(void)
Definition: cs_mesh.c:3229
cs_gnum_t n_g_free_faces
Definition: cs_mesh.h:198
Definition: cs_halo.h:71
char * group
Definition: cs_mesh.h:175
cs_gnum_t n_g_i_c_faces
Definition: cs_mesh.h:116
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:3577
cs_real_t * vtx_coord
Definition: cs_mesh.h:98
void cs_mesh_dump(const cs_mesh_t *mesh)
Definition: cs_mesh.c:3875
void cs_mesh_clean_families(cs_mesh_t *mesh)
Definition: cs_mesh.c:3046
void cs_mesh_update_b_cells(cs_mesh_t *mesh)
Definition: cs_mesh.c:2618
void cs_mesh_sync_var_vect_no_rotation(cs_real_t *var)
Definition: cs_mesh.c:3427
cs_numbering_t * vtx_numbering
Definition: cs_mesh.h:150
int n_groups
Definition: cs_mesh.h:173
struct _fvm_selector_t fvm_selector_t
Definition: fvm_selector.h:51
char * i_face_r_gen
Definition: cs_mesh.h:194
double cs_real_t
Floating-point value.
Definition: cs_defs.h:307
fvm_selector_t * select_i_faces
Definition: cs_mesh.h:189
cs_gnum_t n_g_vertices
Definition: cs_mesh.h:114
void cs_mesh_free_rebuildable(cs_mesh_t *mesh, bool free_halos)
Definition: cs_mesh.c:2357
Definition: cs_mesh.h:74
fvm_selector_t * select_cells
Definition: cs_mesh.h:188
int * cell_family
Definition: cs_mesh.h:180
cs_gnum_t * global_cell_num
Definition: cs_mesh.h:122
cs_lnum_t n_vertices
Definition: cs_mesh.h:89
cs_lnum_t n_cells
Definition: cs_mesh.h:86
cs_mesh_t * cs_mesh_destroy(cs_mesh_t *mesh)
Definition: cs_mesh.c:2274
int n_init_perio
Definition: cs_mesh.h:129
int domain_num
Definition: cs_mesh.h:79
void syntin(cs_real_t var[])
Definition: cs_mesh.c:2104
cs_gnum_t n_g_i_faces
Definition: cs_mesh.h:112
fvm_group_class_set_t * cs_mesh_create_group_classes(cs_mesh_t *mesh)
Definition: cs_mesh.c:3168
int modified
Definition: cs_mesh.h:207
void synsca(cs_real_t var[])
Definition: cs_mesh.c:1946
int n_families
Definition: cs_mesh.h:177
void cs_mesh_init_interfaces(cs_mesh_t *mesh, cs_mesh_builder_t *mb)
int verbosity
Definition: cs_mesh.h:206
Definition: cs_range_set.h:57
cs_halo_type_t
Definition: cs_halo.h:50
void synvie(cs_real_t var[])
Definition: cs_mesh.c:2048
cs_lnum_t * gcell_vtx_lst
Definition: cs_mesh.h:169
void cs_mesh_sync_var_scal_ext(cs_real_t *var)
Definition: cs_mesh.c:3312
void cs_mesh_get_face_perio_num(const cs_mesh_t *mesh, int perio_num[])
Definition: cs_mesh.c:3706
cs_gnum_t cs_mesh_n_g_ghost_cells(cs_mesh_t *mesh)
Definition: cs_mesh.c:3023
int * i_face_family
Definition: cs_mesh.h:181
struct _cs_interface_set_t cs_interface_set_t
Definition: cs_interface.h:61
cs_lnum_t cs_lnum_2_t[2]
vector of 2 local mesh-entity ids
Definition: cs_defs.h:313
cs_lnum_t n_b_faces_all
Definition: cs_mesh.h:203
void cs_mesh_sync_var_tens(cs_real_t *var)
Definition: cs_mesh.c:3524
void cs_mesh_discard_free_faces(cs_mesh_t *mesh)
Definition: cs_mesh.c:2416
void synsce(cs_real_t var[])
Definition: cs_mesh.c:1966
void cs_mesh_print_info(const cs_mesh_t *mesh, const char *name)
Definition: cs_mesh.c:3750
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:2075
struct _fvm_periodicity_t fvm_periodicity_t
Definition: fvm_periodicity.h:67
cs_lnum_t dim
Definition: cs_mesh.h:78
void cs_mesh_init_group_classes(cs_mesh_t *mesh)
Definition: cs_mesh.c:3214
Definition: cs_mesh.h:66
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:301
Definition: cs_mesh.h:65
cs_lnum_t n_cells_with_ghosts
Definition: cs_mesh.h:140
cs_lnum_t n_ghost_cells
Definition: cs_mesh.h:142
int * family_item
Definition: cs_mesh.h:179
cs_lnum_t * cell_cells_idx
Definition: cs_mesh.h:161
cs_gnum_t * global_i_face_num
Definition: cs_mesh.h:123
cs_lnum_t * b_face_vtx_idx
Definition: cs_mesh.h:106
#define END_C_DECLS
Definition: cs_defs.h:496
cs_numbering_t * cell_numbering
Definition: cs_mesh.h:149
void cs_mesh_sync_var_vect(cs_real_t *var)
Definition: cs_mesh.c:3380
void syntis(cs_real_t var[])
Definition: cs_mesh.c:2123
cs_numbering_t * b_face_numbering
Definition: cs_mesh.h:152
cs_gnum_t * global_vtx_num
Definition: cs_mesh.h:125
cs_numbering_t * i_face_numbering
Definition: cs_mesh.h:151
#define CS_PROCF(x, y)
Definition: cs_defs.h:509
void cs_mesh_sync_var_vect_ext(cs_real_t *var)
Definition: cs_mesh.c:3404
cs_lnum_t n_b_cells
Definition: cs_mesh.h:156
void cs_mesh_update_selectors(cs_mesh_t *mesh)
Definition: cs_mesh.c:3273
int have_rotation_perio
Definition: cs_mesh.h:132
fvm_group_class_set_t * class_defs
Definition: cs_mesh.h:184
cs_halo_type_t halo_type
Definition: cs_mesh.h:138
struct _fvm_group_class_set_t fvm_group_class_set_t
Definition: fvm_group.h:60
void cs_mesh_discard_free_vertices(cs_mesh_t *mesh)
Definition: cs_mesh.c:2497
cs_mesh_time_dep_t
Definition: cs_mesh.h:63
void cs_mesh_update_auxiliary(cs_mesh_t *mesh)
Definition: cs_mesh.c:2661
cs_lnum_2_t * i_face_cells
Definition: cs_mesh.h:100
int n_max_family_items
Definition: cs_mesh.h:178
cs_mesh_time_dep_t time_dep
Definition: cs_mesh.h:82
int n_domains
Definition: cs_mesh.h:80
cs_lnum_t n_b_faces
Definition: cs_mesh.h:88
cs_lnum_t b_face_vtx_connect_size
Definition: cs_mesh.h:93
cs_lnum_t * cell_cells_lst
Definition: cs_mesh.h:164
Definition: cs_numbering.h:83
fvm_selector_t * select_b_faces
Definition: cs_mesh.h:190
cs_lnum_t n_i_faces
Definition: cs_mesh.h:87
Definition: mesh.f90:26
void cs_mesh_sync_var_sym_tens(cs_real_t *var)
Definition: cs_mesh.c:3546
cs_halo_t * halo
Definition: cs_mesh.h:145
cs_lnum_t * b_face_cells
Definition: cs_mesh.h:101