programmer's documentation
cs_restart.h
Go to the documentation of this file.
1 #ifndef __CS_RESTART_H__
2 #define __CS_RESTART_H__
3 
4 /*============================================================================
5  * Manage checkpoint / restart files
6  *============================================================================*/
7 
8 /*
9  This file is part of Code_Saturne, a general-purpose CFD tool.
10 
11  Copyright (C) 1998-2016 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 "cs_defs.h"
39 #include "cs_time_step.h"
40 
41 /*----------------------------------------------------------------------------*/
42 
44 
45 /*============================================================================
46  * Macro definitions
47  *============================================================================*/
48 
49 /* Error codes */
50 
51 #define CS_RESTART_SUCCESS 0 /* Success */
52 #define CS_RESTART_ERR_FILE_NUM -1 /* No restart file for the given number */
53 #define CS_RESTART_ERR_LOCATION -2 /* Undefined location / incorrect size */
54 #define CS_RESTART_ERR_VAL_TYPE -3 /* Unknown or unexpected value type */
55 #define CS_RESTART_ERR_N_VALS -4 /* Number of values does not match */
56 #define CS_RESTART_ERR_MODE -5 /* Incompatible access mode */
57 #define CS_RESTART_ERR_EXISTS -6 /* Section not available */
58 
59 /*============================================================================
60  * Local type definitions
61  *============================================================================*/
62 
63 /* Read or write mode */
64 
65 typedef enum {
66 
67  CS_RESTART_MODE_READ, /* Read mode */
68  CS_RESTART_MODE_WRITE /* Write mode */
69 
71 
72 /* Datatype enumeration to transmit a data's type to a function */
73 
74 typedef enum {
80 
81 /*
82  Pointer associated with a restart file structure. The structure itself
83  is defined in "cs_restart.c", and is opaque outside that unit.
84 */
85 
86 typedef struct _cs_restart_t cs_restart_t;
87 
88 /*=============================================================================
89  * Global variables
90  *============================================================================*/
91 
92 /*============================================================================
93  * Public Fortran function prototypes
94  *============================================================================*/
95 
96 /*----------------------------------------------------------------------------
97  * Indicate if a restart directory is present.
98  *
99  * Fortran interface
100  *
101  * subroutine dflsui (ntsuit, ttsuit, wtsuit)
102  * *****************
103  *
104  * integer ntsuit : <-- : > 0: checkpoint time step interval
105  * : : 0: default interval
106  * : : -1: checkpoint at end
107  * : : -2: no checkpoint
108  * double precision ttsuit : <-- : if> 0, checkpoint time interval
109  * double precision wtsuit : <-- : if> 0, checkpoint wall time interval
110  *----------------------------------------------------------------------------*/
111 
112 void CS_PROCF (dflsui, DFLSUI)
113 (
114  cs_int_t *ntsuit,
115  cs_real_t *ttsuit,
116  cs_real_t *wtsuit
117 );
118 
119 /*----------------------------------------------------------------------------
120  * Check if checkpointing is recommended at a given time.
121  *
122  * Fortran interface
123  *
124  * subroutine reqsui (iisuit)
125  * *****************
126  *
127  * integer iisuit : --> : 0 if no restart required, 1 otherwise
128  *----------------------------------------------------------------------------*/
129 
130 void CS_PROCF (reqsui, RESSUI)
131 (
132  cs_int_t *iisuit
133 );
134 
135 /*----------------------------------------------------------------------------
136  * Indicate checkpointing has been done at a given time.
137  *
138  * This updates the status for future checks to determine
139  * if checkpointing is recommended at a given time.
140  *
141  * Fortran interface
142  *
143  * subroutine stusui
144  * *****************
145  *----------------------------------------------------------------------------*/
146 
147 void CS_PROCF (stusui, STUSUI)
148 (
149  void
150 );
151 
152 /*----------------------------------------------------------------------------
153  * Save output mesh for turbomachinery if needed
154  *
155  * Fortran interface
156  *
157  * subroutine trbsui
158  * *****************
159  *----------------------------------------------------------------------------*/
160 
161 void CS_PROCF (trbsui, TRBSUI)
162 (
163  void
164 );
165 
166 /*----------------------------------------------------------------------------
167  * Indicate if a restart directory is present.
168  *
169  * Fortran interface
170  *
171  * subroutine indsui (isuite)
172  * *****************
173  *
174  * integer isuite : --> : 1 for restart, 0 otherwise
175  *----------------------------------------------------------------------------*/
176 
177 void CS_PROCF (indsui, INDSUI)
178 (
180 );
181 
182 /*============================================================================
183  * Public function prototypes
184  *============================================================================*/
185 
186 /*----------------------------------------------------------------------------
187  * Define default checkpoint interval.
188  *
189  * parameters
190  * nt_interval <-- if > 0 time step interval for checkpoint
191  * if 0, default of 4 checkpoints per run
192  * if -1, checkpoint at end
193  * if -2, no checkpointing
194  * t_interval <-- if > 0, time value interval for checkpoint
195  * wt_interval <-- if > 0, wall-clock interval for checkpoints
196  *----------------------------------------------------------------------------*/
197 
198 void
199 cs_restart_checkpoint_set_defaults(int nt_interval,
200  double t_interval,
201  double wt_interval);
202 
203 /*----------------------------------------------------------------------------
204  * Define next forced checkpoint time step
205  *
206  * parameters
207  * nt_next <-- next time step for forced checkpoint
208  *----------------------------------------------------------------------------*/
209 
210 void
212 
213 /*----------------------------------------------------------------------------
214  * Define next forced checkpoint time value
215  *
216  * parameters
217  * t_next <-- next time value for forced checkpoint
218  *----------------------------------------------------------------------------*/
219 
220 void
221 cs_restart_checkpoint_set_next_tv(double t_next);
222 
223 /*----------------------------------------------------------------------------
224  * Define next forced checkpoint wall-clock time value
225  *
226  * parameters
227  * wt_next <-- next wall-clock time value for forced checkpoint
228  *----------------------------------------------------------------------------*/
229 
230 void
231 cs_restart_checkpoint_set_next_wt(double wt_next);
232 
233 /*----------------------------------------------------------------------------
234  * Check if checkpointing is recommended at a given time.
235  *
236  * parameters
237  * ts <-- time step status structure
238  *
239  * returns:
240  * true if checkpointing is recommended, 0 otherwise
241  *----------------------------------------------------------------------------*/
242 
243 bool
245 
246 /*----------------------------------------------------------------------------
247  * Indicate checkpointing has been done at a given time.
248  *
249  * This updates the status for future checks to determine
250  * if checkpointing is recommended at a given time.
251  *
252  * parameters
253  * ts <-- time step status structure
254  *----------------------------------------------------------------------------*/
255 
256 void
258 
259 /*----------------------------------------------------------------------------
260  * Check if we have a restart directory.
261  *
262  * returns:
263  * 1 if a restart directory is present, 0 otherwise.
264  *----------------------------------------------------------------------------*/
265 
266 int
267 cs_restart_present(void);
268 
269 /*----------------------------------------------------------------------------
270  * Initialize a restart file
271  *
272  * parameters:
273  * name <-- file name
274  * path <-- optional directory name for output
275  * (directory automatically created if necessary)
276  * mode <-- read or write
277  *
278  * returns:
279  * pointer to initialized restart file structure
280  *----------------------------------------------------------------------------*/
281 
282 cs_restart_t *
283 cs_restart_create(const char *name,
284  const char *path,
285  cs_restart_mode_t mode);
286 
287 /*----------------------------------------------------------------------------
288  * Destroy structure associated with a restart file (and close the file).
289  *
290  * parameters:
291  * restart <-- pointer to restart file structure pointer
292  *----------------------------------------------------------------------------*/
293 
294 void
296 
297 /*----------------------------------------------------------------------------
298  * Check the locations associated with a restart file.
299  *
300  * For each type of entity, the corresponding flag is set to true if the
301  * associated number of entities matches the current value (and so that we
302  * consider the mesh locations are the same), false otherwise.
303  *
304  * parameters:
305  * restart <-- associated restart file pointer
306  * match_cell <-- matching cells flag
307  * match_i_face <-- matching interior faces flag
308  * match_b_face <-- matching boundary faces flag
309  * match_vertex <-- matching vertices flag
310  *----------------------------------------------------------------------------*/
311 
312 void
314  bool *match_cell,
315  bool *match_i_face,
316  bool *match_b_face,
317  bool *match_vertex);
318 
319 /*----------------------------------------------------------------------------
320  * Add a location definition.
321  *
322  * parameters:
323  * restart <-- associated restart file pointer
324  * location_name <-- name associated with the location
325  * n_glob_ents <-- global number of entities
326  * n_ents <-- local number of entities
327  * ent_global_num <-- global entity numbers, or NULL
328  *
329  * returns:
330  * the location id assigned, or -1 in case of error
331  *----------------------------------------------------------------------------*/
332 
333 int
335  const char *location_name,
336  cs_gnum_t n_glob_ents,
337  cs_lnum_t n_ents,
338  const cs_gnum_t *ent_global_num);
339 
340 /*----------------------------------------------------------------------------
341  * Return name of restart file
342  *
343  * parameters:
344  * restart <-- associated restart file pointer
345  *
346  * returns:
347  * base name of restart file
348  *----------------------------------------------------------------------------*/
349 
350 const char *
351 cs_restart_get_name(const cs_restart_t *restart);
352 
353 /*----------------------------------------------------------------------------
354  * Print the index associated with a restart file in read mode
355  *
356  * parameters:
357  * restart <-- associated restart file pointer
358  *----------------------------------------------------------------------------*/
359 
360 void
361 cs_restart_dump_index(const cs_restart_t *restart);
362 
363 /*----------------------------------------------------------------------------
364  * Check the presence of a given section in a restart file.
365  *
366  * parameters:
367  * restart <-- associated restart file pointer
368  * sec_name <-- section name
369  * location_id <-- id of corresponding location
370  * n_location_vals <-- number of values per location (interlaced)
371  * val_type <-- value type
372  *
373  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
374  * or error code (CS_RESTART_ERR_xxx) in case of error
375  *----------------------------------------------------------------------------*/
376 
377 int
379  const char *sec_name,
380  int location_id,
381  int n_location_vals,
382  cs_restart_val_type_t val_type);
383 
384 /*----------------------------------------------------------------------------
385  * Read a section from a restart file.
386  *
387  * parameters:
388  * restart <-- associated restart file pointer
389  * sec_name <-- section name
390  * location_id <-- id of corresponding location
391  * n_location_vals <-- number of values per location (interlaced)
392  * val_type <-- value type
393  * val --> array of values
394  *
395  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
396  * or error code (CS_RESTART_ERR_xxx) in case of error
397  *----------------------------------------------------------------------------*/
398 
399 int
401  const char *sec_name,
402  int location_id,
403  int n_location_vals,
404  cs_restart_val_type_t val_type,
405  void *val);
406 
407 /*----------------------------------------------------------------------------
408  * Write a section to a restart file.
409  *
410  * parameters:
411  * restart <-- associated restart file pointer
412  * sec_name <-- section name
413  * location_id <-- id of corresponding location
414  * n_location_vals <-- number of values per location (interlaced)
415  * val_type <-- value type
416  * val <-- array of values
417  *----------------------------------------------------------------------------*/
418 
419 void
421  const char *sec_name,
422  int location_id,
423  int n_location_vals,
424  cs_restart_val_type_t val_type,
425  const void *val);
426 
427 /*----------------------------------------------------------------------------
428  * Read basic particles information from a restart file.
429  *
430  * This includes building a matching location and associated global numbering.
431  *
432  * parameters:
433  * restart <-- associated restart file pointer
434  * name <-- name of particles set
435  * n_particles --> number of particles, or NULL
436  *
437  * returns:
438  * the location id assigned to the particles, or -1 in case of error
439  *----------------------------------------------------------------------------*/
440 
441 int
443  const char *name,
444  cs_lnum_t *n_particles);
445 
446 /*----------------------------------------------------------------------------
447  * Read basic particles information from a restart file.
448  *
449  * parameters:
450  * restart <-- associated restart file pointer
451  * particles_location_id <-- location id of particles set
452  * particle_cell_id --> local cell id to which particles belong
453  * particle_coords --> local particle coordinates (interleaved)
454  *
455  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
456  * or error code (CS_RESTART_ERR_xxx) in case of error
457  *----------------------------------------------------------------------------*/
458 
459 int
461  int particles_location_id,
462  cs_lnum_t *particle_cell_id,
463  cs_real_t *particle_coords);
464 
465 /*----------------------------------------------------------------------------
466  * Write basic particles information to a restart file.
467  *
468  * This includes defining a matching location and associated global numbering,
469  * then writing particle coordinates and cell ids.
470  *
471  * parameters:
472  * restart <-- associated restart file pointer
473  * name <-- name of particles set
474  * number_by_coords <-- if true, numbering is based on current coordinates;
475  * otherwise, it is simply based on local numbers,
476  * plus the sum of particles on lower MPI ranks
477  * n_particles <-- local number of particles
478  * particle_cell_num <-- local cell number (1 to n) to which particles
479  * belong; 0 for untracked particles
480  * particle_coords <-- local particle coordinates (interleaved)
481  *
482  * returns:
483  * the location id assigned to the particles
484  *----------------------------------------------------------------------------*/
485 
486 int
488  const char *name,
489  bool number_by_coords,
490  cs_lnum_t n_particles,
491  const cs_lnum_t *particle_cell_num,
492  const cs_real_t *particle_coords);
493 
494 /*----------------------------------------------------------------------------
495  * Read a referenced location id section from a restart file.
496  *
497  * The section read from file contains the global ids matching the local
498  * element ids of a given location. Global id's are transformed to local
499  * ids by this function.
500  *
501  * In case global referenced ids read do not match those of local elements,
502  * id_base - 1 is assigned to the corresponding local ids.
503  *
504  * parameters:
505  * restart <-- associated restart file pointer
506  * sec_name <-- section name
507  * location_id <-- id of location on which id_ref is defined
508  * ref_location_id <-- id of referenced location
509  * ref_id_base <-- base of location entity id numbers (usually 0 or 1)
510  * ref_id --> array of location entity ids
511  *
512  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
513  * or error code (CS_RESTART_ERR_xxx) in case of error
514  *----------------------------------------------------------------------------*/
515 
516 int
518  const char *sec_name,
519  int location_id,
520  int ref_location_id,
521  cs_lnum_t ref_id_base,
522  cs_lnum_t *ref_id);
523 
524 /*----------------------------------------------------------------------------
525  * Write a referenced location id section to a restart file.
526  *
527  * The section written to file contains the global ids matching the
528  * local element ids of a given location.
529  *
530  * parameters:
531  * restart <-- associated restart file pointer
532  * sec_name <-- section name
533  * location_id <-- id of location on which id_ref is defined
534  * ref_location_id <-- id of referenced location
535  * ref_id_base <-- base of location entity id numbers (usually 0 or 1)
536  * ref_id <-- array of location entity ids
537  *----------------------------------------------------------------------------*/
538 
539 void
541  const char *sec_name,
542  int location_id,
543  int ref_location_id,
544  cs_lnum_t ref_id_base,
545  const cs_lnum_t *ref_id);
546 
547 /*----------------------------------------------------------------------------
548  * Read a section from a restart file, when that section may have used a
549  * different name in a previous version.
550  *
551  * parameters:
552  * restart <-- associated restart file pointer
553  * sec_name <-- section name
554  * location_id <-- id of corresponding location
555  * n_location_vals <-- number of values per location (interlaced)
556  * val_type <-- value type
557  * val --> array of values
558  *
559  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
560  * or error code (CS_RESTART_ERR_xxx) in case of error
561  *----------------------------------------------------------------------------*/
562 
563 int
565  const char *sec_name,
566  const char *old_name,
567  int location_id,
568  int n_location_vals,
569  cs_restart_val_type_t val_type,
570  void *val);
571 
572 /*----------------------------------------------------------------------------
573  * Read a cs_real_t section from a restart file, when that section may
574  * have used a different name in a previous version.
575  *
576  * parameters:
577  * restart <-- associated restart file pointer
578  * sec_name <-- section name
579  * location_id <-- id of corresponding location
580  * n_location_vals <-- number of values per location (interlaced)
581  * val --> array of values
582  *
583  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
584  * or error code (CS_RESTART_ERR_xxx) in case of error
585  *----------------------------------------------------------------------------*/
586 
587 int
589  const char *sec_name,
590  const char *old_name,
591  int location_id,
592  int n_location_vals,
593  cs_real_t *val);
594 
595 /*----------------------------------------------------------------------------
596  * Read a cs_real_3_t vector section from a restart file, when that
597  * section may have used a different name and been non-interleaved
598  * in a previous version.
599  *
600  * This file assumes a mesh-base location (i.e. location_id > 0)
601  *
602  * parameters:
603  * restart <-- associated restart file pointer
604  * sec_name <-- section name
605  * old_name_x <-- old name, x component
606  * old_name_y <-- old name, y component
607  * old_name_y <-- old name, z component
608  * location_id <-- id of corresponding location
609  * val --> array of values
610  *
611  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
612  * or error code (CS_RESTART_ERR_xxx) in case of error
613  *----------------------------------------------------------------------------*/
614 
615 int
617  const char *sec_name,
618  const char *old_name_x,
619  const char *old_name_y,
620  const char *old_name_z,
621  int location_id,
622  cs_real_3_t *val);
623 
624 /*----------------------------------------------------------------------------
625  * Read a cs_real_6_t vector section from a restart file, when that
626  * section may have used a different name and been non-interleaved
627  * in a previous version.
628  *
629  * This file assumes a mesh-base location (i.e. location_id > 0)
630  *
631  * parameters:
632  * restart <-- associated restart file pointer
633  * sec_name <-- section name
634  * old_name_xx <-- old name, xx component
635  * old_name_yy <-- old name, yy component
636  * old_name_zz <-- old name, zz component
637  * old_name_xy <-- old name, xy component
638  * old_name_yz <-- old name, xy component
639  * old_name_xz <-- old name, xy component
640  * location_id <-- id of corresponding location (> 0)
641  * val --> array of values
642  *
643  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
644  * or error code (CS_RESTART_ERR_xxx) in case of error
645  *----------------------------------------------------------------------------*/
646 
647 int
649  const char *sec_name,
650  const char *old_name_xx,
651  const char *old_name_yy,
652  const char *old_name_zz,
653  const char *old_name_xy,
654  const char *old_name_yz,
655  const char *old_name_xz,
656  int location_id,
657  cs_real_6_t *val);
658 
659 /*----------------------------------------------------------------------------
660  * Read a cs_real_66_t vector section from a restart file, when that
661  * section may have used a different name and been non-interleaved
662  * in a previous version.
663  *
664  * This file assumes a mesh-base location (i.e. location_id > 0)
665  *
666  * parameters:
667  * restart <-- associated restart file pointer
668  * sec_name <-- section name
669  * old_name_xx <-- old name, xx component
670  * old_name_yy <-- old name, yy component
671  * old_name_zz <-- old name, zz component
672  * old_name_xy <-- old name, xy component
673  * old_name_yz <-- old name, xy component
674  * old_name_xz <-- old name, xy component
675  * location_id <-- id of corresponding location (> 0)
676  * val --> array of values
677  *
678  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
679  * or error code (CS_RESTART_ERR_xxx) in case of error
680  *----------------------------------------------------------------------------*/
681 
682 int
684  const char *sec_name,
685  const char *old_name_xx,
686  const char *old_name_yy,
687  const char *old_name_zz,
688  const char *old_name_xy,
689  const char *old_name_yz,
690  const char *old_name_xz,
691  int location_id,
692  cs_real_66_t *val);
693 
694 /*----------------------------------------------------------------------------
695  * Print statistics associated with restart files
696  *----------------------------------------------------------------------------*/
697 
698 void
700 
701 /*----------------------------------------------------------------------------*/
702 
704 
705 #endif /* __CS_RESTART_H__ */
Definition: cs_restart.h:78
int cs_restart_read_section(cs_restart_t *restart, const char *sec_name, int location_id, int n_location_vals, cs_restart_val_type_t val_type, void *val)
Definition: cs_restart.c:1736
time step descriptor
Definition: cs_time_step.h:51
unsigned long cs_gnum_t
global mesh entity number
Definition: cs_defs.h:280
int cs_restart_write_particles(cs_restart_t *restart, const char *name, bool number_by_coords, cs_lnum_t n_particles, const cs_lnum_t *particle_cell_num, const cs_real_t *particle_coords)
Definition: cs_restart.c:2389
cs_real_t cs_real_6_t[6]
vector of 6 floating-point values
Definition: cs_defs.h:309
void cs_restart_dump_index(const cs_restart_t *restart)
Definition: cs_restart.c:1579
void cs_restart_checkpoint_done(const cs_time_step_t *ts)
Definition: cs_restart.c:1185
void cs_restart_checkpoint_set_defaults(int nt_interval, double t_interval, double wt_interval)
Definition: cs_restart.c:1064
void cs_restart_print_stats(void)
Definition: cs_restart.c:3174
cs_restart_t * cs_restart_create(const char *name, const char *path, cs_restart_mode_t mode)
Definition: cs_restart.c:1246
integer, save ntsuit
saving period of the restart filesy5
Definition: entsor.f90:78
cs_real_t cs_real_66_t[6][6]
6x6 matrix of floating-point values
Definition: cs_defs.h:312
Definition: cs_restart.h:76
#define BEGIN_C_DECLS
Definition: cs_defs.h:429
int cs_int_t
Fortran-compatible integer.
Definition: cs_defs.h:295
void indsui(cs_int_t *isuite)
Definition: cs_restart.c:1040
void cs_restart_write_section(cs_restart_t *restart, const char *sec_name, int location_id, int n_location_vals, cs_restart_val_type_t val_type, const void *val)
Definition: cs_restart.c:1959
cs_restart_mode_t
Definition: cs_restart.h:65
int cs_restart_read_real_t_compat(cs_restart_t *restart, const char *sec_name, const char *old_name, int location_id, int n_location_vals, cs_real_t *val)
const char * cs_restart_get_name(const cs_restart_t *restart)
Definition: cs_restart.c:1564
Definition: cs_restart.h:75
void reqsui(cs_int_t *iisuit)
Definition: cs_restart.c:981
int cs_restart_read_section_compat(cs_restart_t *restart, const char *sec_name, const char *old_name, int location_id, int n_location_vals, cs_restart_val_type_t val_type, void *val)
Definition: cs_restart.c:2724
integer, save isuite
Definition: optcal.f90:371
int cs_restart_read_real_3_t_compat(cs_restart_t *restart, const char *sec_name, const char *old_name_x, const char *old_name_y, const char *old_name_z, int location_id, cs_real_3_t *val)
Definition: cs_restart.c:2800
int cs_restart_read_real_66_t_compat(cs_restart_t *restart, const char *sec_name, const char *old_name_xx, const char *old_name_yy, const char *old_name_zz, const char *old_name_xy, const char *old_name_yz, const char *old_name_xz, int location_id, cs_real_66_t *val)
Definition: cs_restart.c:3054
bool cs_restart_checkpoint_required(const cs_time_step_t *ts)
Definition: cs_restart.c:1123
int cs_restart_present(void)
Definition: cs_restart.c:1222
Definition: cs_restart.h:77
struct _cs_restart_t cs_restart_t
Definition: cs_restart.h:86
void stusui(void)
Definition: cs_restart.c:1004
void cs_restart_checkpoint_set_next_ts(int nt_next)
Definition: cs_restart.c:1081
int cs_restart_read_particles_info(cs_restart_t *restart, const char *name, cs_lnum_t *n_particles)
Definition: cs_restart.c:2093
int cs_restart_read_ids(cs_restart_t *restart, const char *sec_name, int location_id, int ref_location_id, cs_lnum_t ref_id_base, cs_lnum_t *ref_id)
Definition: cs_restart.c:2522
int cs_restart_read_real_6_t_compat(cs_restart_t *restart, const char *sec_name, const char *old_name_xx, const char *old_name_yy, const char *old_name_zz, const char *old_name_xy, const char *old_name_yz, const char *old_name_xz, int location_id, cs_real_6_t *val)
Definition: cs_restart.c:2913
cs_real_t cs_real_3_t[3]
vector of 3 floating-point values
Definition: cs_defs.h:307
int cs_restart_check_section(cs_restart_t *restart, const char *sec_name, int location_id, int n_location_vals, cs_restart_val_type_t val_type)
Definition: cs_restart.c:1617
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:292
Definition: cs_restart.h:68
void cs_restart_checkpoint_set_next_wt(double wt_next)
Definition: cs_restart.c:1107
void dflsui(cs_int_t *ntsuit, cs_real_t *ttsuit, cs_real_t *wtsuit)
Definition: cs_restart.c:960
cs_restart_val_type_t
Definition: cs_restart.h:74
#define END_C_DECLS
Definition: cs_defs.h:430
double cs_real_t
Definition: cs_defs.h:296
void cs_restart_checkpoint_set_next_tv(double t_next)
Definition: cs_restart.c:1094
int cs_restart_read_particles(cs_restart_t *restart, int particles_location_id, cs_lnum_t *particle_cell_id, cs_real_t *particle_coords)
Definition: cs_restart.c:2276
void trbsui(void)
Definition: cs_restart.c:1021
#define CS_PROCF(x, y)
Definition: cs_defs.h:453
void cs_restart_destroy(cs_restart_t **restart)
Definition: cs_restart.c:1359
void cs_restart_check_base_location(const cs_restart_t *restart, bool *match_cell, bool *match_i_face, bool *match_b_face, bool *match_vertex)
Definition: cs_restart.c:1414
Definition: cs_restart.h:67
int cs_restart_add_location(cs_restart_t *restart, const char *location_name, cs_gnum_t n_glob_ents, cs_lnum_t n_ents, const cs_gnum_t *ent_global_num)
Definition: cs_restart.c:1472
void cs_restart_write_ids(cs_restart_t *restart, const char *sec_name, int location_id, int ref_location_id, cs_lnum_t ref_id_base, const cs_lnum_t *ref_id)
Definition: cs_restart.c:2623