7.1
general documentation
cs_post.h
Go to the documentation of this file.
1 #ifndef __CS_POST_H__
2 #define __CS_POST_H__
3 
4 /*============================================================================
5  * Post-processing management
6  *============================================================================*/
7 
8 /*
9  This file is part of Code_Saturne, a general-purpose CFD tool.
10 
11  Copyright (C) 1998-2021 EDF S.A.
12 
13  This program is free software; you can redistribute it and/or modify it under
14  the terms of the GNU General Public License as published by the Free Software
15  Foundation; either version 2 of the License, or (at your option) any later
16  version.
17 
18  This program is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20  FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
21  details.
22 
23  You should have received a copy of the GNU General Public License along with
24  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
25  Street, Fifth Floor, Boston, MA 02110-1301, USA.
26 */
27 
28 /*----------------------------------------------------------------------------*/
29 
30 /*----------------------------------------------------------------------------
31  * Standard C library headers
32  *----------------------------------------------------------------------------*/
33 
34 /*----------------------------------------------------------------------------
35  * Local headers
36  *----------------------------------------------------------------------------*/
37 
38 #include "fvm_nodal.h"
39 #include "fvm_writer.h"
40 
41 #include "cs_base.h"
42 #include "cs_interpolate.h"
43 #include "cs_probe.h"
44 #include "cs_time_step.h"
45 #include "cs_time_control.h"
46 
47 /*----------------------------------------------------------------------------*/
48 
49 BEGIN_C_DECLS
50 
51 /*============================================================================
52  * Macro definitions
53  *============================================================================*/
54 
55 /* Output type masks */
56 
57 #define CS_POST_ON_LOCATION (1 << 0) /* postprocess variables
58  on their base location
59  (volume for variables) */
60 #define CS_POST_BOUNDARY_NR (1 << 1) /* postprocess boundary
61  without reconstruction */
62 
63 #define CS_POST_MONITOR (1 << 2) /* monitor variables */
64 
65 /* Default writer ids and filters */
66 
67 #define CS_POST_WRITER_ALL_ASSOCIATED 0
69 #define CS_POST_WRITER_DEFAULT -1
70 #define CS_POST_WRITER_ERRORS -2
71 #define CS_POST_WRITER_PARTICLES -3
72 #define CS_POST_WRITER_TRAJECTORIES -4
73 #define CS_POST_WRITER_PROBES -5
74 #define CS_POST_WRITER_PROFILES -6
75 #define CS_POST_WRITER_HISTOGRAMS -7
77 /* Default mesh ids */
78 
79 #define CS_POST_MESH_VOLUME -1
80 #define CS_POST_MESH_BOUNDARY -2
81 #define CS_POST_MESH_PARTICLES -3
82 #define CS_POST_MESH_TRAJECTORIES -4
83 #define CS_POST_MESH_PROBES -5
85 /* Additional categories (no associated default mesh) */
86 
87 #define CS_POST_MESH_SURFACE -12 /* surface (boundary and/or
88  interior) mesh */
89 
90 /*============================================================================
91  * Local type definitions
92  *============================================================================*/
93 
94 /* Datatype enumeration */
95 
96 typedef enum {
97  CS_POST_TYPE_int,
98  CS_POST_TYPE_cs_real_t,
99  CS_POST_TYPE_float,
100  CS_POST_TYPE_double
101 } cs_post_type_t;
102 
103 /*----------------------------------------------------------------------------
104  * Function pointer to elements selection definition.
105  *
106  * Each function of this sort may be used to select a given type of element,
107  * usually cells, interior faces, boundary faces, or particles.
108  *
109  * If non-empty and not containing all elements, a list of elements of the
110  * main mesh should be allocated (using BFT_MALLOC) and defined by this
111  * function when called. This list's lifecycle is then managed by the
112  * postprocessing subsystem.
113  *
114  * Note: if the input pointer is non-NULL, it must point to valid data
115  * when the selection function is called, so either:
116  * - that value or structure should not be temporary (i.e. local);
117  * - post-processing output must be ensured using cs_post_write_meshes()
118  * with a fixed-mesh writer before the data pointed to goes out of scope;
119  *
120  * parameters:
121  * input <-> pointer to optional (untyped) value or structure.
122  * n_elts --> number of selected elements.
123  * elt_list --> list of selected elements (0 to n-1 numbering).
124  *----------------------------------------------------------------------------*/
125 
126 typedef void
127 (cs_post_elt_select_t) (void *input,
128  cs_lnum_t *n_elts,
129  cs_lnum_t **elt_list);
130 
131 /*----------------------------------------------------------------------------
132  * Function pointer associated with a specific post-processing output.
133  *
134  * Such functions are registered using the cs_post_add_time_dep_vars(),
135  * and all registered functions are automatically called by
136  * cs_post_write_vars().
137  *
138  * Note: if the input pointer is non-NULL, it must point to valid data
139  * when the output function is called, so either:
140  * - that value or structure should not be temporary (i.e. local);
141  * - post-processing output must be ensured using cs_post_write_var()
142  * or similar before the data pointed to goes out of scope.
143  *
144  * parameters:
145  * input <-> pointer to optional (untyped) value or structure.
146  * ts <-- time step status structure, or NULL
147  *----------------------------------------------------------------------------*/
148 
149 typedef void
150 (cs_post_time_dep_output_t) (void *input,
151  const cs_time_step_t *ts);
152 
153 /*----------------------------------------------------------------------------
154  * Function pointer associated with a specific post-processing output
155  * on multiple meshes.
156  *
157  * Such functions are registered using the cs_post_add_time_mesh_dep_vars(),
158  * and all registered functions are automatically called by
159  * cs_post_write_vars().
160  *
161  * Note: if the input pointer is non-NULL, it must point to valid data
162  * when the output function is called, so either:
163  * - that value or structure should not be temporary (i.e. local);
164  * - post-processing output must be ensured using cs_post_write_var()
165  * or similar before the data pointed to goes out of scope.
166  *
167  * parameters:
168  * input <-> pointer to optional (untyped) value or structure.
169  * mesh_id <-- id of the output mesh for the current call
170  * cat_id <-- category id of the output mesh for the current call
171  * ent_flag <-- indicate global presence of cells (ent_flag[0]), interior
172  * faces (ent_flag[1]), boundary faces (ent_flag[2]),
173  * particles (ent_flag[3]) or probes (ent_flag[4])
174  * n_cells <-- local number of cells of post_mesh
175  * n_i_faces <-- local number of interior faces of post_mesh
176  * n_b_faces <-- local number of boundary faces of post_mesh
177  * cell_ids <-- list of cells (0 to n-1) of post-processing mesh
178  * i_face_ids <-- list of interior faces (0 to n-1) of post-processing mesh
179  * b_face_ids <-- list of boundary faces (0 to n-1) of post-processing mesh
180  * ts <-- time step status structure, or NULL
181  *----------------------------------------------------------------------------*/
182 
183 typedef void
184 (cs_post_time_mesh_dep_output_t) (void *input,
185  int mesh_id,
186  int cat_id,
187  int ent_flag[5],
188  cs_lnum_t n_cells,
189  cs_lnum_t n_i_faces,
190  cs_lnum_t n_b_faces,
191  const cs_lnum_t cell_ids[],
192  const cs_lnum_t i_face_ids[],
193  const cs_lnum_t b_face_ids[],
194  const cs_time_step_t *ts);
195 
196 /*=============================================================================
197  * Global variables
198  *============================================================================*/
199 
200 /*============================================================================
201  * Public function prototypes
202  *============================================================================*/
203 
204 /*----------------------------------------------------------------------------*/
289 /*----------------------------------------------------------------------------*/
290 
291 void
292 cs_post_define_writer(int writer_id,
293  const char *case_name,
294  const char *dir_name,
295  const char *fmt_name,
296  const char *fmt_opts,
297  fvm_writer_time_dep_t time_dep,
298  bool output_at_start,
299  bool output_at_end,
300  int interval_n,
301  double interval_t);
302 
303 /*----------------------------------------------------------------------------*/
316 /*----------------------------------------------------------------------------*/
317 
318 void
319 cs_post_define_volume_mesh(int mesh_id,
320  const char *mesh_name,
321  const char *cell_criteria,
322  bool add_groups,
323  bool auto_variables,
324  int n_writers,
325  const int writer_ids[]);
326 
327 /*----------------------------------------------------------------------------*/
354 /*----------------------------------------------------------------------------*/
355 
356 void
357 cs_post_define_volume_mesh_by_func(int mesh_id,
358  const char *mesh_name,
359  cs_post_elt_select_t *cell_select_func,
360  void *cell_select_input,
361  bool time_varying,
362  bool add_groups,
363  bool auto_variables,
364  int n_writers,
365  const int writer_ids[]);
366 
367 /*----------------------------------------------------------------------------*/
381 /*----------------------------------------------------------------------------*/
382 
383 void
384 cs_post_define_surface_mesh(int mesh_id,
385  const char *mesh_name,
386  const char *i_face_criteria,
387  const char *b_face_criteria,
388  bool add_groups,
389  bool auto_variables,
390  int n_writers,
391  const int writer_ids[]);
392 
393 /*----------------------------------------------------------------------------*/
424 /*----------------------------------------------------------------------------*/
425 
426 void
427 cs_post_define_surface_mesh_by_func(int mesh_id,
428  const char *mesh_name,
429  cs_post_elt_select_t *i_face_select_func,
430  cs_post_elt_select_t *b_face_select_func,
431  void *i_face_select_input,
432  void *b_face_select_input,
433  bool time_varying,
434  bool add_groups,
435  bool auto_variables,
436  int n_writers,
437  const int writer_ids[]);
438 
439 /*----------------------------------------------------------------------------*/
464 /*----------------------------------------------------------------------------*/
465 
466 void
467 cs_post_define_particles_mesh(int mesh_id,
468  const char *mesh_name,
469  const char *cell_criteria,
470  double density,
471  bool trajectory,
472  bool auto_variables,
473  int n_writers,
474  const int writer_ids[]);
475 
476 /*----------------------------------------------------------------------------*/
506 /*----------------------------------------------------------------------------*/
507 
508 void
509 cs_post_define_particles_mesh_by_func(int mesh_id,
510  const char *mesh_name,
511  cs_post_elt_select_t *p_select_func,
512  void *p_select_input,
513  bool trajectory,
514  bool auto_variables,
515  int n_writers,
516  const int writer_ids[]);
517 
518 /*----------------------------------------------------------------------------*/
548 /*----------------------------------------------------------------------------*/
549 
550 void
551 cs_post_define_existing_mesh(int mesh_id,
552  fvm_nodal_t *exp_mesh,
553  int dim_shift,
554  bool transfer,
555  bool auto_variables,
556  int n_writers,
557  const int writer_ids[]);
558 
559 /*----------------------------------------------------------------------------*/
576 /*----------------------------------------------------------------------------*/
577 
578 void
579 cs_post_define_edges_mesh(int mesh_id,
580  int base_mesh_id,
581  int n_writers,
582  const int writer_ids[]);
583 
584 /*----------------------------------------------------------------------------*/
599 /*----------------------------------------------------------------------------*/
600 
601 void
602 cs_post_mesh_attach_writer(int mesh_id,
603  int writer_id);
604 
605 /*----------------------------------------------------------------------------*/
620 /*----------------------------------------------------------------------------*/
621 
622 void
623 cs_post_mesh_detach_writer(int mesh_id,
624  int writer_id);
625 
626 /*----------------------------------------------------------------------------*/
642 /*----------------------------------------------------------------------------*/
643 
644 void
645 cs_post_mesh_attach_field(int mesh_id,
646  int writer_id,
647  int field_id,
648  int comp_id);
649 
650 /*----------------------------------------------------------------------------*/
666 /*----------------------------------------------------------------------------*/
667 
668 const int *
669 cs_post_mesh_get_ent_flag(int mesh_id);
670 
671 /*----------------------------------------------------------------------------*/
679 /*----------------------------------------------------------------------------*/
680 
681 cs_lnum_t
682 cs_post_mesh_get_n_cells(int mesh_id);
683 
684 /*----------------------------------------------------------------------------*/
695 /*----------------------------------------------------------------------------*/
696 
697 void
698 cs_post_mesh_get_cell_ids(int mesh_id,
699  cs_lnum_t *cell_ids);
700 
701 /*----------------------------------------------------------------------------*/
709 /*----------------------------------------------------------------------------*/
710 
711 cs_lnum_t
712 cs_post_mesh_get_n_i_faces(int mesh_id);
713 
714 /*----------------------------------------------------------------------------*/
725 /*----------------------------------------------------------------------------*/
726 
727 void
728 cs_post_mesh_get_i_face_ids(int mesh_id,
729  cs_lnum_t i_face_ids[]);
730 
731 /*----------------------------------------------------------------------------*/
739 /*----------------------------------------------------------------------------*/
740 
741 cs_lnum_t
742 cs_post_mesh_get_n_b_faces(int mesh_id);
743 
744 /*----------------------------------------------------------------------------*/
755 /*----------------------------------------------------------------------------*/
756 
757 void
758 cs_post_mesh_get_b_face_ids(int mesh_id,
759  cs_lnum_t b_face_ids[]);
760 
761 /*----------------------------------------------------------------------------*/
769 /*----------------------------------------------------------------------------*/
770 
771 cs_lnum_t
772 cs_post_mesh_get_n_vertices(int mesh_id);
773 
774 /*----------------------------------------------------------------------------*/
785 /*----------------------------------------------------------------------------*/
786 
787 void
788 cs_post_mesh_get_vertex_ids(int mesh_id,
789  cs_lnum_t *vertex_ids);
790 
791 /*----------------------------------------------------------------------------*/
799 /*----------------------------------------------------------------------------*/
800 
801 void
802 cs_post_mesh_set_post_domain(int mesh_id,
803  bool post_domain);
804 
805 /*----------------------------------------------------------------------------*/
817 /*----------------------------------------------------------------------------*/
818 
819 void
820 cs_post_free_mesh(int mesh_id);
821 
822 /*----------------------------------------------------------------------------*/
830 /*----------------------------------------------------------------------------*/
831 
832 bool
833 cs_post_writer_exists(int writer_id);
834 
835 /*----------------------------------------------------------------------------*/
843 /*----------------------------------------------------------------------------*/
844 
845 bool
846 cs_post_mesh_exists(int mesh_id);
847 
848 /*----------------------------------------------------------------------------*/
854 /*----------------------------------------------------------------------------*/
855 
856 const char *
857 cs_post_get_default_format(void);
858 
859 /*----------------------------------------------------------------------------*/
865 /*----------------------------------------------------------------------------*/
866 
867 const char *
868 cs_post_get_default_format_options(void);
869 
870 /*----------------------------------------------------------------------------*/
876 /*----------------------------------------------------------------------------*/
877 
878 int
879 cs_post_get_free_writer_id(void);
880 
881 /*----------------------------------------------------------------------------*/
887 /*----------------------------------------------------------------------------*/
888 
889 int
890 cs_post_get_free_mesh_id(void);
891 
892 /*----------------------------------------------------------------------------*/
902 /*----------------------------------------------------------------------------*/
903 
904 void
905 cs_post_activate_by_time_step(const cs_time_step_t *ts);
906 
907 /*----------------------------------------------------------------------------*/
915 /*----------------------------------------------------------------------------*/
916 
917 void
918 cs_post_activate_writer(int writer_id,
919  bool activate);
920 
921 /*----------------------------------------------------------------------------*/
936 /*----------------------------------------------------------------------------*/
937 
938 void
939 cs_post_disable_writer(int writer_id);
940 
941 /*----------------------------------------------------------------------------*/
955 /*----------------------------------------------------------------------------*/
956 
957 void
958 cs_post_enable_writer(int writer_id);
959 
960 /*----------------------------------------------------------------------------*/
968 /*----------------------------------------------------------------------------*/
969 
970 fvm_writer_t *
971 cs_post_get_writer(int writer_id);
972 
973 /*----------------------------------------------------------------------------*/
981 /*----------------------------------------------------------------------------*/
982 
983 cs_time_control_t *
984 cs_post_get_time_control(int writer_id);
985 
986 /*----------------------------------------------------------------------------*/
994 /*----------------------------------------------------------------------------*/
995 
996 fvm_writer_time_dep_t
997 cs_post_get_writer_time_dep(int writer_id);
998 
999 /*----------------------------------------------------------------------------*/
1009 /*----------------------------------------------------------------------------*/
1010 
1011 void
1012 cs_post_add_writer_t_step(int writer_id,
1013  int nt);
1014 
1015 /*----------------------------------------------------------------------------*/
1025 /*----------------------------------------------------------------------------*/
1026 
1027 void
1028 cs_post_add_writer_t_value(int writer_id,
1029  double t);
1030 
1031 /*----------------------------------------------------------------------------*/
1040 /*----------------------------------------------------------------------------*/
1041 
1042 void
1043 cs_post_write_meshes(const cs_time_step_t *ts);
1044 
1045 /*----------------------------------------------------------------------------*/
1066 /*----------------------------------------------------------------------------*/
1067 
1068 void
1069 cs_post_write_var(int mesh_id,
1070  int writer_id,
1071  const char *var_name,
1072  int var_dim,
1073  bool interlace,
1074  bool use_parent,
1075  cs_post_type_t var_type,
1076  const void *cel_vals,
1077  const void *i_face_vals,
1078  const void *b_face_vals,
1079  const cs_time_step_t *ts);
1080 
1081 /*----------------------------------------------------------------------------*/
1100 /*----------------------------------------------------------------------------*/
1101 
1102 void
1103 cs_post_write_vertex_var(int mesh_id,
1104  int writer_id,
1105  const char *var_name,
1106  int var_dim,
1107  bool interlace,
1108  bool use_parent,
1109  cs_post_type_t var_type,
1110  const void *vtx_vals,
1111  const cs_time_step_t *ts);
1112 
1113 /*----------------------------------------------------------------------------*/
1128 /*----------------------------------------------------------------------------*/
1129 
1130 void
1131 cs_post_write_particle_values(int mesh_id,
1132  int writer_id,
1133  int attr_id,
1134  const char *var_name,
1135  int component_id,
1136  const cs_time_step_t *ts);
1137 
1138 /*----------------------------------------------------------------------------*/
1159 /*----------------------------------------------------------------------------*/
1160 
1161 void
1162 cs_post_write_probe_values(int mesh_id,
1163  int writer_id,
1164  const char *var_name,
1165  int var_dim,
1166  cs_post_type_t var_type,
1167  int parent_location_id,
1168  cs_interpolate_from_location_t *interpolate_func,
1169  void *interpolate_input,
1170  const void *vals,
1171  const cs_time_step_t *ts);
1172 
1173 /*----------------------------------------------------------------------------*/
1185 /*----------------------------------------------------------------------------*/
1186 
1187 void
1188 cs_post_renum_cells(const cs_lnum_t init_cell_num[]);
1189 
1190 /*----------------------------------------------------------------------------*/
1203 /*----------------------------------------------------------------------------*/
1204 
1205 void
1206 cs_post_renum_faces(const cs_lnum_t init_i_face_num[],
1207  const cs_lnum_t init_b_face_num[]);
1208 
1209 /*----------------------------------------------------------------------------*/
1220 /*----------------------------------------------------------------------------*/
1221 
1222 void
1223 cs_post_set_changing_connectivity(void);
1224 
1225 /*----------------------------------------------------------------------------*/
1229 /*----------------------------------------------------------------------------*/
1230 
1231 void
1232 cs_post_init_writers(void);
1233 
1234 /*----------------------------------------------------------------------------*/
1252 /*----------------------------------------------------------------------------*/
1253 
1254 void
1255 cs_post_init_meshes(int check_mask);
1256 
1257 /*----------------------------------------------------------------------------*/
1264 /*----------------------------------------------------------------------------*/
1265 
1266 void
1267 cs_post_time_step_begin(const cs_time_step_t *ts);
1268 
1269 /*----------------------------------------------------------------------------*/
1279 /*----------------------------------------------------------------------------*/
1280 
1281 void
1282 cs_post_time_step_output(const cs_time_step_t *ts);
1283 
1284 /*----------------------------------------------------------------------------*/
1289 /*----------------------------------------------------------------------------*/
1290 
1291 void
1292 cs_post_time_step_end(void);
1293 
1294 /*----------------------------------------------------------------------------*/
1304 /*----------------------------------------------------------------------------*/
1305 
1306 void
1307 cs_post_write_vars(const cs_time_step_t *ts);
1308 
1309 /*----------------------------------------------------------------------------*/
1313 /*----------------------------------------------------------------------------*/
1314 
1315 void
1316 cs_post_finalize(void);
1317 
1318 /*----------------------------------------------------------------------------*/
1322 /*----------------------------------------------------------------------------*/
1323 
1324 void
1325 cs_post_add_free_faces(void);
1326 
1327 /*----------------------------------------------------------------------------*/
1333 /*----------------------------------------------------------------------------*/
1334 
1335 void
1336 cs_post_init_error_writer(void);
1337 
1338 /*----------------------------------------------------------------------------*/
1349 /*----------------------------------------------------------------------------*/
1350 
1351 int
1352 cs_post_init_error_writer_cells(void);
1353 
1354 /*----------------------------------------------------------------------------*/
1368 /*----------------------------------------------------------------------------*/
1369 
1370 void
1371 cs_post_add_time_dep_output(cs_post_time_dep_output_t *function,
1372  void *input);
1373 
1374 /*----------------------------------------------------------------------------*/
1388 /*----------------------------------------------------------------------------*/
1389 
1390 void
1391 cs_post_add_time_mesh_dep_output(cs_post_time_mesh_dep_output_t *function,
1392  void *input);
1393 
1394 /*----------------------------------------------------------------------------*/
1395 
1396 END_C_DECLS
1397 
1398 #endif /* __CS_POST_H__ */
cs_post_write_vars
void cs_post_write_vars(const cs_time_step_t *ts)
Loop on post-processing meshes to output variables.
Definition: cs_post.c:6985
CS_POST_TYPE_double
Definition: cs_post.h:100
cs_post_get_default_format
const char * cs_post_get_default_format(void)
Return the default writer format name.
Definition: cs_post.c:5099
cs_time_step_t
time step descriptor
Definition: cs_time_step.h:64
cs_post_mesh_get_i_face_ids
void cs_post_mesh_get_i_face_ids(int mesh_id, cs_lnum_t i_face_ids[])
Get a postprocessing mesh&#39;s list of boundary faces.
Definition: cs_post.c:4783
cs_post_init_error_writer
void cs_post_init_error_writer(void)
Initialize post-processing writer with same format and associated options as default writer...
Definition: cs_post.c:7312
cs_post_type_t
cs_post_type_t
Postprocessing input variable type.
Definition: cs_post.h:96
cs_interpolate.h
cs_base.h
cs_post_enable_writer
void cs_post_enable_writer(int writer_id)
Enable a specific writer or all writers currently disabled by previous calls to cs_post_disable_write...
Definition: cs_post.c:5287
cs_post_time_step_end
void cs_post_time_step_end(void)
Flush writers and free time-varying and Lagragian mesh if needed of meshes if there is a time-depende...
Definition: cs_post.c:6941
CS_POST_TYPE_float
Definition: cs_post.h:99
cs_time_control_t
Definition: cs_time_control.h:96
cs_post_define_surface_mesh_by_func
void cs_post_define_surface_mesh_by_func(int mesh_id, const char *mesh_name, cs_post_elt_select_t *i_face_select_func, cs_post_elt_select_t *b_face_select_func, void *i_face_select_input, void *b_face_select_input, bool time_varying, bool add_groups, bool auto_variables, int n_writers, const int writer_ids[])
Define a surface post-processing mesh using selection functions.
Definition: cs_post.c:4132
cs_post_mesh_get_n_vertices
cs_lnum_t cs_post_mesh_get_n_vertices(int mesh_id)
Get a postprocessing mesh&#39;s number of vertices.
Definition: cs_post.c:4898
cs_post_free_mesh
void cs_post_free_mesh(int mesh_id)
Remove a post-processing mesh.
Definition: cs_post.c:4980
cs_post_init_writers
void cs_post_init_writers(void)
Initialize post-processing writers.
Definition: cs_post.c:6360
cs_post_activate_by_time_step
void cs_post_activate_by_time_step(const cs_time_step_t *ts)
Update "active" or "inactive" flag of writers based on the time step.
Definition: cs_post.c:5159
cs_post_mesh_attach_writer
void cs_post_mesh_attach_writer(int mesh_id, int writer_id)
Associate a writer to a postprocessing mesh.
Definition: cs_post.c:4502
BEGIN_C_DECLS
#define BEGIN_C_DECLS
Definition: cs_defs.h:510
cs_post_mesh_get_ent_flag
const int * cs_post_mesh_get_ent_flag(int mesh_id)
Get a postprocessing meshes entity presence flag.
Definition: cs_post.c:4676
cs_post_define_particles_mesh_by_func
void cs_post_define_particles_mesh_by_func(int mesh_id, const char *mesh_name, cs_post_elt_select_t *p_select_func, void *p_select_input, bool trajectory, bool auto_variables, int n_writers, const int writer_ids[])
Define a particles post-processing mesh using a selection function.
Definition: cs_post.c:4271
cs_post_get_time_control
cs_time_control_t * cs_post_get_time_control(int writer_id)
Return a pointer to the time control associated to a writer_id.
Definition: cs_post.c:5343
cs_post_get_free_writer_id
int cs_post_get_free_writer_id(void)
Return the next "reservable" (i.e. non-user) writer id available.
Definition: cs_post.c:5127
cs_post_init_error_writer_cells
int cs_post_init_error_writer_cells(void)
Initialize post-processing writer with same format and associated options as default writer...
Definition: cs_post.c:7362
cs_post_define_existing_mesh
void cs_post_define_existing_mesh(int mesh_id, fvm_nodal_t *exp_mesh, int dim_shift, bool transfer, bool auto_variables, int n_writers, const int writer_ids[])
Create a post-processing mesh associated with an existing exportable mesh representation.
Definition: cs_post.c:4337
cs_post_disable_writer
void cs_post_disable_writer(int writer_id)
Disable specific writer or all writers not currently active until cs_post_enable_writer or cs_post_ac...
Definition: cs_post.c:5250
cs_post_mesh_set_post_domain
void cs_post_mesh_set_post_domain(int mesh_id, bool post_domain)
Set whether postprocessing mesh&#39;s parallel domain should be output.
Definition: cs_post.c:4957
fvm_writer_time_dep_t
fvm_writer_time_dep_t
Definition: fvm_writer.h:57
cs_post_get_writer
fvm_writer_t * cs_post_get_writer(int writer_id)
Return a pointer to the FVM writer associated to a writer_id.
Definition: cs_post.c:5318
cs_post_renum_faces
void cs_post_renum_faces(const cs_lnum_t init_i_face_num[], const cs_lnum_t init_b_face_num[])
Update references to parent mesh of post-processing meshes in case of computational mesh interior and...
Definition: cs_post.c:6253
cs_post_write_var
void cs_post_write_var(int mesh_id, int writer_id, const char *var_name, int var_dim, bool interlace, bool use_parent, cs_post_type_t var_type, const void *cel_vals, const void *i_face_vals, const void *b_face_vals, const cs_time_step_t *ts)
Output a variable defined at cells or faces of a post-processing mesh using associated writers...
Definition: cs_post.c:5505
cs_post_init_meshes
void cs_post_init_meshes(int check_mask)
Initialize main post-processing meshes.
Definition: cs_post.c:6474
cs_post_mesh_get_b_face_ids
void cs_post_mesh_get_b_face_ids(int mesh_id, cs_lnum_t b_face_ids[])
Get a postprocessing mesh&#39;s list of boundary faces.
Definition: cs_post.c:4856
cs_post_mesh_get_n_b_faces
cs_lnum_t cs_post_mesh_get_n_b_faces(int mesh_id)
Get a postprocessing mesh&#39;s number of boundary faces.
Definition: cs_post.c:4826
cs_post_mesh_get_n_i_faces
cs_lnum_t cs_post_mesh_get_n_i_faces(int mesh_id)
Get a postprocessing mesh&#39;s number of interior faces.
Definition: cs_post.c:4753
cs_probe.h
cs_post_get_default_format_options
const char * cs_post_get_default_format_options(void)
Return the default writer format options.
Definition: cs_post.c:5113
cs_post_define_particles_mesh
void cs_post_define_particles_mesh(int mesh_id, const char *mesh_name, const char *cell_criteria, double density, bool trajectory, bool auto_variables, int n_writers, const int writer_ids[])
Define a particles post-processing mesh.
Definition: cs_post.c:4203
cs_post_add_time_mesh_dep_output
void cs_post_add_time_mesh_dep_output(cs_post_time_mesh_dep_output_t *function, void *input)
Register a processing of time-dependent variables than can be output on different meshes to the call ...
Definition: cs_post.c:7445
cs_post_write_meshes
void cs_post_write_meshes(const cs_time_step_t *ts)
Output post-processing meshes using associated writers.
Definition: cs_post.c:5448
cs_post_get_writer_time_dep
fvm_writer_time_dep_t cs_post_get_writer_time_dep(int writer_id)
Return time dependency associated to a writer_id.
Definition: cs_post.c:5362
cs_post_elt_select_t
void() cs_post_elt_select_t(void *input, cs_lnum_t *n_elts, cs_lnum_t **elt_list)
Function pointer to elements selection definition.
Definition: cs_post.h:127
fvm_nodal.h
cs_post_define_volume_mesh
void cs_post_define_volume_mesh(int mesh_id, const char *mesh_name, const char *cell_criteria, bool add_groups, bool auto_variables, int n_writers, const int writer_ids[])
Define a volume post-processing mesh.
Definition: cs_post.c:3941
fvm_writer.h
cs_interpolate_from_location_t
void() cs_interpolate_from_location_t(void *input, cs_datatype_t datatype, int val_dim, cs_lnum_t n_points, const cs_lnum_t point_location[], const cs_real_3_t point_coords[], const void *location_vals, void *point_vals)
Function pointer for interpolatation of values defined on a mesh location at a given set of points...
Definition: cs_interpolate.h:71
CS_POST_TYPE_int
Definition: cs_post.h:97
cs_post_time_dep_output_t
void() cs_post_time_dep_output_t(void *input, const cs_time_step_t *ts)
Definition: cs_post.h:150
cs_post_finalize
void cs_post_finalize(void)
Destroy all structures associated with post-processing.
Definition: cs_post.c:7007
cs_post_write_probe_values
void cs_post_write_probe_values(int mesh_id, int writer_id, const char *var_name, int var_dim, cs_post_type_t var_type, int parent_location_id, cs_interpolate_from_location_t *interpolate_func, void *interpolate_input, const void *vals, const cs_time_step_t *ts)
Output a variable defined at cells or faces of a post-processing mesh using associated writers...
Definition: cs_post.c:6043
cs_post_define_surface_mesh
void cs_post_define_surface_mesh(int mesh_id, const char *mesh_name, const char *i_face_criteria, const char *b_face_criteria, bool add_groups, bool auto_variables, int n_writers, const int writer_ids[])
Define a surface post-processing mesh.
Definition: cs_post.c:4054
cs_post_mesh_detach_writer
void cs_post_mesh_detach_writer(int mesh_id, int writer_id)
De-associate a writer from a postprocessing mesh.
Definition: cs_post.c:4554
cs_post_set_changing_connectivity
void cs_post_set_changing_connectivity(void)
Configure the post-processing output so that mesh connectivity may be automatically updated...
Definition: cs_post.c:6348
atimbr::density
double precision, dimension(:,:,:), allocatable density
Definition: atimbr.f90:124
cs_post_time_mesh_dep_output_t
void() cs_post_time_mesh_dep_output_t(void *input, int mesh_id, int cat_id, int ent_flag[5], cs_lnum_t n_cells, cs_lnum_t n_i_faces, cs_lnum_t n_b_faces, const cs_lnum_t cell_ids[], const cs_lnum_t i_face_ids[], const cs_lnum_t b_face_ids[], const cs_time_step_t *ts)
Definition: cs_post.h:184
cs_post_time_step_output
void cs_post_time_step_output(const cs_time_step_t *ts)
Loop on post-processing meshes to output variables.
Definition: cs_post.c:6669
cs_post_get_free_mesh_id
int cs_post_get_free_mesh_id(void)
Return the next "reservable" (i.e. non-user) mesh id available.
Definition: cs_post.c:5141
cs_post_write_particle_values
void cs_post_write_particle_values(int mesh_id, int writer_id, int attr_id, const char *var_name, int component_id, const cs_time_step_t *ts)
Output an existing lagrangian particle attribute at particle positions or trajectory endpoints of a p...
Definition: cs_post.c:5875
cs_post_mesh_get_vertex_ids
void cs_post_mesh_get_vertex_ids(int mesh_id, cs_lnum_t *vertex_ids)
Get a postprocessing mesh&#39;s list of vertices.
Definition: cs_post.c:4928
cs_post_write_vertex_var
void cs_post_write_vertex_var(int mesh_id, int writer_id, const char *var_name, int var_dim, bool interlace, bool use_parent, cs_post_type_t var_type, const void *vtx_vals, const cs_time_step_t *ts)
Output a variable defined at vertices of a post-processing mesh using associated writers.
Definition: cs_post.c:5753
cs_lnum_t
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:316
cs_post_mesh_get_n_cells
cs_lnum_t cs_post_mesh_get_n_cells(int mesh_id)
Get a postprocessing mesh&#39;s number of cells.
Definition: cs_post.c:4694
cs_post_mesh_get_cell_ids
void cs_post_mesh_get_cell_ids(int mesh_id, cs_lnum_t *cell_ids)
Get a postprocessing mesh&#39;s list of cells.
Definition: cs_post.c:4724
cs_time_step.h
cs_post_activate_writer
void cs_post_activate_writer(int writer_id, bool activate)
Force the "active" or "inactive" flag for a specific writer or for all writers for the current time s...
Definition: cs_post.c:5213
cs_post_add_free_faces
void cs_post_add_free_faces(void)
Postprocess free (isolated) faces of the current global mesh.
Definition: cs_post.c:7101
END_C_DECLS
#define END_C_DECLS
Definition: cs_defs.h:511
cs_post_add_writer_t_value
void cs_post_add_writer_t_value(int writer_id, double t)
Add an activation time value for a specific writer or for all writers.
Definition: cs_post.c:5421
cs_post_add_time_dep_output
void cs_post_add_time_dep_output(cs_post_time_dep_output_t *function, void *input)
Register a processing of time-dependent variables to the call to cs_post_write_vars().
Definition: cs_post.c:7404
CS_POST_TYPE_cs_real_t
Definition: cs_post.h:98
cs_post_mesh_attach_field
void cs_post_mesh_attach_field(int mesh_id, int writer_id, int field_id, int comp_id)
Associate a field to a writer and postprocessing mesh combination.
Definition: cs_post.c:4612
cs_post_define_edges_mesh
void cs_post_define_edges_mesh(int mesh_id, int base_mesh_id, int n_writers, const int writer_ids[])
Create a mesh based upon the extraction of edges from an existing mesh.
Definition: cs_post.c:4461
cs_time_control.h
t
Definition: cs_field_pointer.h:92
cs_post_mesh_exists
bool cs_post_mesh_exists(int mesh_id)
Check for the existence of a post-processing mesh of the given id.
Definition: cs_post.c:5074
cs_post_add_writer_t_step
void cs_post_add_writer_t_step(int writer_id, int nt)
Add an activation time step for a specific writer or for all writers.
Definition: cs_post.c:5393
cs_post_define_writer
void cs_post_define_writer(int writer_id, const char *case_name, const char *dir_name, const char *fmt_name, const char *fmt_opts, fvm_writer_time_dep_t time_dep, bool output_at_start, bool output_at_end, int interval_n, double interval_t)
Define a writer; this objects manages a case&#39;s name, directory, and format, as well as associated mes...
Definition: cs_post.c:3786
cs_post_writer_exists
bool cs_post_writer_exists(int writer_id)
Check for the existence of a writer of the given id.
Definition: cs_post.c:5045
cs_post_define_volume_mesh_by_func
void cs_post_define_volume_mesh_by_func(int mesh_id, const char *mesh_name, cs_post_elt_select_t *cell_select_func, void *cell_select_input, bool time_varying, bool add_groups, bool auto_variables, int n_writers, const int writer_ids[])
Define a volume post-processing mesh using a selection function.
Definition: cs_post.c:4004
cs_post_renum_cells
void cs_post_renum_cells(const cs_lnum_t init_cell_num[])
Update references to parent mesh of post-processing meshes in case of computational mesh cell renumbe...
Definition: cs_post.c:6177
cs_post_time_step_begin
void cs_post_time_step_begin(const cs_time_step_t *ts)
Check if post-processing is activated and then update post-processing of meshes if there is a need to...
Definition: cs_post.c:6636