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-2015 EDF S.A.
12 
13  This program is free software; you can redistribute it and/or modify it under
14  the terms of the GNU General Public License as published by the Free Software
15  Foundation; either version 2 of the License, or (at your option) any later
16  version.
17 
18  This program is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20  FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
21  details.
22 
23  You should have received a copy of the GNU General Public License along with
24  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
25  Street, Fifth Floor, Boston, MA 02110-1301, USA.
26 */
27 
28 /*----------------------------------------------------------------------------*/
29 
30 /*----------------------------------------------------------------------------
31  * 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  * Indicate if a restart directory is present.
154  *
155  * Fortran interface
156  *
157  * subroutine indsui (isuite)
158  * *****************
159  *
160  * integer isuite : --> : 1 for restart, 0 otherwise
161  *----------------------------------------------------------------------------*/
162 
163 void CS_PROCF (indsui, INDSUI)
164 (
166 );
167 
168 /*============================================================================
169  * Public function prototypes
170  *============================================================================*/
171 
172 /*----------------------------------------------------------------------------
173  * Define default checkpoint interval.
174  *
175  * parameters
176  * nt_interval <-- if > 0 time step interval for checkpoint
177  * if 0, default of 4 checkpoints per run
178  * if -1, checkpoint at end
179  * if -2, no checkpointing
180  * t_interval <-- if > 0, time value interval for checkpoint
181  * wt_interval <-- if > 0, wall-clock interval for checkpoints
182  *----------------------------------------------------------------------------*/
183 
184 void
185 cs_restart_checkpoint_set_defaults(int nt_interval,
186  double t_interval,
187  double wt_interval);
188 
189 /*----------------------------------------------------------------------------
190  * Define next forced checkpoint time step
191  *
192  * parameters
193  * nt_next <-- next time step for forced checkpoint
194  *----------------------------------------------------------------------------*/
195 
196 void
198 
199 /*----------------------------------------------------------------------------
200  * Define next forced checkpoint time value
201  *
202  * parameters
203  * t_next <-- next time value for forced checkpoint
204  *----------------------------------------------------------------------------*/
205 
206 void
207 cs_restart_checkpoint_set_next_tv(double t_next);
208 
209 /*----------------------------------------------------------------------------
210  * Define next forced checkpoint wall-clock time value
211  *
212  * parameters
213  * wt_next <-- next wall-clock time value for forced checkpoint
214  *----------------------------------------------------------------------------*/
215 
216 void
217 cs_restart_checkpoint_set_next_wt(double wt_next);
218 
219 /*----------------------------------------------------------------------------
220  * Check if checkpointing is recommended at a given time.
221  *
222  * parameters
223  * ts <-- time step status structure
224  *
225  * returns:
226  * true if checkpointing is recommended, 0 otherwise
227  *----------------------------------------------------------------------------*/
228 
229 bool
231 
232 /*----------------------------------------------------------------------------
233  * Indicate checkpointing has been done at a given time.
234  *
235  * This updates the status for future checks to determine
236  * if checkpointing is recommended at a given time.
237  *
238  * parameters
239  * ts <-- time step status structure
240  *----------------------------------------------------------------------------*/
241 
242 void
244 
245 /*----------------------------------------------------------------------------
246  * Check if we have a restart directory.
247  *
248  * returns:
249  * 1 if a restart directory is present, 0 otherwise.
250  *----------------------------------------------------------------------------*/
251 
252 int
253 cs_restart_present(void);
254 
255 /*----------------------------------------------------------------------------
256  * Initialize a restart file
257  *
258  * parameters:
259  * name <-- file name
260  * path <-- optional directory name for output
261  * (directory automatically created if necessary)
262  * mode <-- read or write
263  *
264  * returns:
265  * pointer to initialized restart file structure
266  *----------------------------------------------------------------------------*/
267 
268 cs_restart_t *
269 cs_restart_create(const char *name,
270  const char *path,
271  cs_restart_mode_t mode);
272 
273 /*----------------------------------------------------------------------------
274  * Destroy structure associated with a restart file (and close the file).
275  *
276  * parameters:
277  * restart <-- pointer to restart file structure pointer
278  *----------------------------------------------------------------------------*/
279 
280 void
282 
283 /*----------------------------------------------------------------------------
284  * Check the locations associated with a restart file.
285  *
286  * For each type of entity, the corresponding flag is set to true if the
287  * associated number of entities matches the current value (and so that we
288  * consider the mesh locations are the same), false otherwise.
289  *
290  * parameters:
291  * restart <-- associated restart file pointer
292  * match_cell <-- matching cells flag
293  * match_i_face <-- matching interior faces flag
294  * match_b_face <-- matching boundary faces flag
295  * match_vertex <-- matching vertices flag
296  *----------------------------------------------------------------------------*/
297 
298 void
300  bool *match_cell,
301  bool *match_i_face,
302  bool *match_b_face,
303  bool *match_vertex);
304 
305 /*----------------------------------------------------------------------------
306  * Add a location definition.
307  *
308  * parameters:
309  * restart <-- associated restart file pointer
310  * location_name <-- name associated with the location
311  * n_glob_ents <-- global number of entities
312  * n_ents <-- local number of entities
313  * ent_global_num <-- global entity numbers, or NULL
314  *
315  * returns:
316  * the location id assigned, or -1 in case of error
317  *----------------------------------------------------------------------------*/
318 
319 int
321  const char *location_name,
322  cs_gnum_t n_glob_ents,
323  cs_lnum_t n_ents,
324  const cs_gnum_t *ent_global_num);
325 
326 /*----------------------------------------------------------------------------
327  * Return name of restart file
328  *
329  * parameters:
330  * restart <-- associated restart file pointer
331  *
332  * returns:
333  * base name of restart file
334  *----------------------------------------------------------------------------*/
335 
336 const char *
337 cs_restart_get_name(const cs_restart_t *restart);
338 
339 /*----------------------------------------------------------------------------
340  * Print the index associated with a restart file in read mode
341  *
342  * parameters:
343  * restart <-- associated restart file pointer
344  *----------------------------------------------------------------------------*/
345 
346 void
347 cs_restart_dump_index(const cs_restart_t *restart);
348 
349 /*----------------------------------------------------------------------------
350  * Check the presence of a given section in a restart file.
351  *
352  * parameters:
353  * restart <-- associated restart file pointer
354  * sec_name <-- section name
355  * location_id <-- id of corresponding location
356  * n_location_vals <-- number of values per location (interlaced)
357  * val_type <-- value type
358  *
359  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
360  * or error code (CS_RESTART_ERR_xxx) in case of error
361  *----------------------------------------------------------------------------*/
362 
363 int
365  const char *sec_name,
366  int location_id,
367  int n_location_vals,
368  cs_restart_val_type_t val_type);
369 
370 /*----------------------------------------------------------------------------
371  * Read a section from a restart file.
372  *
373  * parameters:
374  * restart <-- associated restart file pointer
375  * sec_name <-- section name
376  * location_id <-- id of corresponding location
377  * n_location_vals <-- number of values per location (interlaced)
378  * val_type <-- value type
379  * val --> array of values
380  *
381  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
382  * or error code (CS_RESTART_ERR_xxx) in case of error
383  *----------------------------------------------------------------------------*/
384 
385 int
387  const char *sec_name,
388  int location_id,
389  int n_location_vals,
390  cs_restart_val_type_t val_type,
391  void *val);
392 
393 /*----------------------------------------------------------------------------
394  * Write a section to a restart file.
395  *
396  * parameters:
397  * restart <-- associated restart file pointer
398  * sec_name <-- section name
399  * location_id <-- id of corresponding location
400  * n_location_vals <-- number of values per location (interlaced)
401  * val_type <-- value type
402  * val <-- array of values
403  *----------------------------------------------------------------------------*/
404 
405 void
407  const char *sec_name,
408  int location_id,
409  int n_location_vals,
410  cs_restart_val_type_t val_type,
411  const void *val);
412 
413 /*----------------------------------------------------------------------------
414  * Read basic particles information from a restart file.
415  *
416  * This includes building a matching location and associated global numbering.
417  *
418  * parameters:
419  * restart <-- associated restart file pointer
420  * name <-- name of particles set
421  * n_particles --> number of particles, or NULL
422  *
423  * returns:
424  * the location id assigned to the particles, or -1 in case of error
425  *----------------------------------------------------------------------------*/
426 
427 int
429  const char *name,
430  cs_lnum_t *n_particles);
431 
432 /*----------------------------------------------------------------------------
433  * Read basic particles information from a restart file.
434  *
435  * parameters:
436  * restart <-- associated restart file pointer
437  * particles_location_id <-- location id of particles set
438  * particle_cell_id --> local cell id to which particles belong
439  * particle_coords --> local particle coordinates (interleaved)
440  *
441  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
442  * or error code (CS_RESTART_ERR_xxx) in case of error
443  *----------------------------------------------------------------------------*/
444 
445 int
447  int particles_location_id,
448  cs_lnum_t *particle_cell_id,
449  cs_real_t *particle_coords);
450 
451 /*----------------------------------------------------------------------------
452  * Write basic particles information to a restart file.
453  *
454  * This includes defining a matching location and associated global numbering,
455  * then writing particle coordinates and cell ids.
456  *
457  * parameters:
458  * restart <-- associated restart file pointer
459  * name <-- name of particles set
460  * number_by_coords <-- if true, numbering is based on current coordinates;
461  * otherwise, it is simply based on local numbers,
462  * plus the sum of particles on lower MPI ranks
463  * n_particles <-- local number of particles
464  * particle_cell_num <-- local cell number (1 to n) to which particles
465  * belong; 0 for untracked particles
466  * particle_coords <-- local particle coordinates (interleaved)
467  *
468  * returns:
469  * the location id assigned to the particles
470  *----------------------------------------------------------------------------*/
471 
472 int
474  const char *name,
475  bool number_by_coords,
476  cs_lnum_t n_particles,
477  const cs_lnum_t *particle_cell_num,
478  const cs_real_t *particle_coords);
479 
480 /*----------------------------------------------------------------------------
481  * Read a referenced location id section from a restart file.
482  *
483  * The section read from file contains the global ids matching the local
484  * element ids of a given location. Global id's are transformed to local
485  * ids by this function.
486  *
487  * In case global referenced ids read do not match those of local elements,
488  * id_base - 1 is assigned to the corresponding local ids.
489  *
490  * parameters:
491  * restart <-- associated restart file pointer
492  * sec_name <-- section name
493  * location_id <-- id of location on which id_ref is defined
494  * ref_location_id <-- id of referenced location
495  * ref_id_base <-- base of location entity id numbers (usually 0 or 1)
496  * ref_id --> array of location entity ids
497  *
498  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
499  * or error code (CS_RESTART_ERR_xxx) in case of error
500  *----------------------------------------------------------------------------*/
501 
502 int
504  const char *sec_name,
505  int location_id,
506  int ref_location_id,
507  cs_lnum_t ref_id_base,
508  cs_lnum_t *ref_id);
509 
510 /*----------------------------------------------------------------------------
511  * Write a referenced location id section to a restart file.
512  *
513  * The section written to file contains the global ids matching the
514  * local element ids of a given location.
515  *
516  * parameters:
517  * restart <-- associated restart file pointer
518  * sec_name <-- section name
519  * location_id <-- id of location on which id_ref is defined
520  * ref_location_id <-- id of referenced location
521  * ref_id_base <-- base of location entity id numbers (usually 0 or 1)
522  * ref_id <-- array of location entity ids
523  *----------------------------------------------------------------------------*/
524 
525 void
527  const char *sec_name,
528  int location_id,
529  int ref_location_id,
530  cs_lnum_t ref_id_base,
531  const cs_lnum_t *ref_id);
532 
533 /*----------------------------------------------------------------------------
534  * Read a section from a restart file, when that section may have used a
535  * different name in a previous version.
536  *
537  * parameters:
538  * restart <-- associated restart file pointer
539  * sec_name <-- section name
540  * location_id <-- id of corresponding location
541  * n_location_vals <-- number of values per location (interlaced)
542  * val_type <-- value type
543  * val --> array of values
544  *
545  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
546  * or error code (CS_RESTART_ERR_xxx) in case of error
547  *----------------------------------------------------------------------------*/
548 
549 int
551  const char *sec_name,
552  const char *old_name,
553  int location_id,
554  int n_location_vals,
555  cs_restart_val_type_t val_type,
556  void *val);
557 
558 /*----------------------------------------------------------------------------
559  * Read a cs_real_t section from a restart file, when that section may
560  * have used a different name in a previous version.
561  *
562  * parameters:
563  * restart <-- associated restart file pointer
564  * sec_name <-- section name
565  * location_id <-- id of corresponding location
566  * n_location_vals <-- number of values per location (interlaced)
567  * val --> array of values
568  *
569  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
570  * or error code (CS_RESTART_ERR_xxx) in case of error
571  *----------------------------------------------------------------------------*/
572 
573 int
575  const char *sec_name,
576  const char *old_name,
577  int location_id,
578  int n_location_vals,
579  cs_real_t *val);
580 
581 /*----------------------------------------------------------------------------
582  * Read a cs_real_3_t vector section from a restart file, when that
583  * section may have used a different name and been non-interleaved
584  * in a previous version.
585  *
586  * This file assumes a mesh-base location (i.e. location_id > 0)
587  *
588  * parameters:
589  * restart <-- associated restart file pointer
590  * sec_name <-- section name
591  * old_name_x <-- old name, x component
592  * old_name_y <-- old name, y component
593  * old_name_y <-- old name, z component
594  * location_id <-- id of corresponding location
595  * val --> array of values
596  *
597  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
598  * or error code (CS_RESTART_ERR_xxx) in case of error
599  *----------------------------------------------------------------------------*/
600 
601 int
603  const char *sec_name,
604  const char *old_name_x,
605  const char *old_name_y,
606  const char *old_name_z,
607  int location_id,
608  cs_real_3_t *val);
609 
610 /*----------------------------------------------------------------------------
611  * Read a cs_real_6_t vector section from a restart file, when that
612  * section may have used a different name and been non-interleaved
613  * in a previous version.
614  *
615  * This file assumes a mesh-base location (i.e. location_id > 0)
616  *
617  * parameters:
618  * restart <-- associated restart file pointer
619  * sec_name <-- section name
620  * old_name_xx <-- old name, xx component
621  * old_name_yy <-- old name, yy component
622  * old_name_zz <-- old name, zz component
623  * old_name_xy <-- old name, xy component
624  * old_name_yz <-- old name, xy component
625  * old_name_xz <-- old name, xy component
626  * location_id <-- id of corresponding location (> 0)
627  * val --> array of values
628  *
629  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
630  * or error code (CS_RESTART_ERR_xxx) in case of error
631  *----------------------------------------------------------------------------*/
632 
633 int
635  const char *sec_name,
636  const char *old_name_xx,
637  const char *old_name_yy,
638  const char *old_name_zz,
639  const char *old_name_xy,
640  const char *old_name_yz,
641  const char *old_name_xz,
642  int location_id,
643  cs_real_6_t *val);
644 
645 /*----------------------------------------------------------------------------
646  * Read a cs_real_66_t vector section from a restart file, when that
647  * section may have used a different name and been non-interleaved
648  * in a previous version.
649  *
650  * This file assumes a mesh-base location (i.e. location_id > 0)
651  *
652  * parameters:
653  * restart <-- associated restart file pointer
654  * sec_name <-- section name
655  * old_name_xx <-- old name, xx component
656  * old_name_yy <-- old name, yy component
657  * old_name_zz <-- old name, zz component
658  * old_name_xy <-- old name, xy component
659  * old_name_yz <-- old name, xy component
660  * old_name_xz <-- old name, xy component
661  * location_id <-- id of corresponding location (> 0)
662  * val --> array of values
663  *
664  * returns: 0 (CS_RESTART_SUCCESS) in case of success,
665  * or error code (CS_RESTART_ERR_xxx) in case of error
666  *----------------------------------------------------------------------------*/
667 
668 int
670  const char *sec_name,
671  const char *old_name_xx,
672  const char *old_name_yy,
673  const char *old_name_zz,
674  const char *old_name_xy,
675  const char *old_name_yz,
676  const char *old_name_xz,
677  int location_id,
678  cs_real_66_t *val);
679 
680 /*----------------------------------------------------------------------------
681  * Print statistics associated with restart files
682  *----------------------------------------------------------------------------*/
683 
684 void
686 
687 /*----------------------------------------------------------------------------*/
688 
690 
691 #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:1718
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:2371
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:1561
void cs_restart_checkpoint_done(const cs_time_step_t *ts)
Definition: cs_restart.c:1167
void cs_restart_checkpoint_set_defaults(int nt_interval, double t_interval, double wt_interval)
Definition: cs_restart.c:1046
void cs_restart_print_stats(void)
Definition: cs_restart.c:3156
cs_restart_t * cs_restart_create(const char *name, const char *path, cs_restart_mode_t mode)
Definition: cs_restart.c:1228
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:1022
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:1941
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:1546
Definition: cs_restart.h:75
void reqsui(cs_int_t *iisuit)
Definition: cs_restart.c:980
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:2706
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:2782
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:3036
bool cs_restart_checkpoint_required(const cs_time_step_t *ts)
Definition: cs_restart.c:1105
int cs_restart_present(void)
Definition: cs_restart.c:1204
Definition: cs_restart.h:77
struct _cs_restart_t cs_restart_t
Definition: cs_restart.h:86
void stusui(void)
Definition: cs_restart.c:1003
void cs_restart_checkpoint_set_next_ts(int nt_next)
Definition: cs_restart.c:1063
int cs_restart_read_particles_info(cs_restart_t *restart, const char *name, cs_lnum_t *n_particles)
Definition: cs_restart.c:2075
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:2504
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:2895
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:1599
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:1089
void dflsui(cs_int_t *ntsuit, cs_real_t *ttsuit, cs_real_t *wtsuit)
Definition: cs_restart.c:959
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:1076
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:2258
#define CS_PROCF(x, y)
Definition: cs_defs.h:453
void cs_restart_destroy(cs_restart_t **restart)
Definition: cs_restart.c:1341
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:1396
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:1454
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:2605