FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
hecmw_restart.c
Go to the documentation of this file.
1/*****************************************************************************
2 * Copyright (c) 2019 FrontISTR Commons
3 * This software is released under the MIT License, see LICENSE.txt
4 *****************************************************************************/
5
6#include <stdio.h>
7#include <stdlib.h>
8#include <stddef.h>
9#include <errno.h>
10#include "hecmw_util.h"
11#include "hecmw_config.h"
12#include "hecmw_restart.h"
13
15 void *data;
16 size_t size;
18};
19
20static struct restart_list *first_list = NULL;
21static struct restart_list *previ_list = NULL;
22static FILE *restart_fp;
23
24static void clear(void) {
25 struct restart_list *p, *q;
26
27 for (p = first_list; p; p = q) {
28 q = p->next;
29 HECMW_free(p->data);
30 HECMW_free(p);
31 }
32 first_list = NULL;
33 previ_list = NULL;
34}
35
36int HECMW_restart_open_by_name(char *name_ID) {
37 char *filename;
38
39 if (name_ID) {
40 if ((filename = HECMW_ctrl_get_restart_file(name_ID)) == NULL) return -1;
41 } else {
42 /* io is bitmap */
44 if ((filename = HECMW_ctrl_get_restart_file_by_io(io)) == NULL) return -1;
45 }
46
47 if ((restart_fp = fopen(filename, "rb")) == NULL) {
48 HECMW_set_error(HECMW_UTIL_E0101, "File: %s, %s", filename,
49 HECMW_strmsg(errno));
50 HECMW_free(filename);
51 return -1;
52 }
53 HECMW_free(filename);
54 return 0;
55}
56
58
60 if (restart_fp == NULL) return 0;
61 if (fclose(restart_fp)) {
63 return -1;
64 }
65 restart_fp = NULL;
66 return 0;
67}
68
69static int restart_read(void *ptr, size_t size, size_t nmemb, FILE *stream) {
70 int rc, msgno;
71
72 rc = fread(ptr, size, nmemb, stream);
73 if (rc != nmemb) {
74 if (feof(stream)) {
75 msgno = HECMW_UTIL_E0104;
76 } else if (ferror(stream)) {
77 msgno = HECMW_UTIL_E0105;
78 }
79 return msgno;
80 }
81 return 0;
82}
83
84void *HECMW_restart_read(void *addr) {
85 int rc;
86 size_t size;
87 void *data;
88
89 if (restart_fp == NULL) {
91 return NULL;
92 }
93
94 /* read size */
95 rc = restart_read(&size, sizeof(size), 1, restart_fp);
96 if (rc) {
97 HECMW_set_error(rc, "");
98 return NULL;
99 }
100
101 /* read data */
102 if (addr == NULL) {
104 if (data == NULL) {
105 HECMW_set_error(errno, "");
106 return NULL;
107 }
108 } else {
109 data = addr;
110 }
111 rc = restart_read(data, size, 1, restart_fp);
112 if (rc) {
113 HECMW_set_error(rc, "");
114 return NULL;
115 }
116
117 return data;
118}
119
120int HECMW_restart_add(void *data, size_t size) {
121 struct restart_list *rst;
122
123 rst = HECMW_malloc(sizeof(*rst));
124 if (rst == NULL) {
125 HECMW_set_error(errno, "");
126 return -1;
127 }
128
129 rst->data = data;
130 rst->size = size;
131 rst->next = NULL;
132
133 if (previ_list != NULL) previ_list->next = rst;
134 previ_list = rst;
135 if (first_list == NULL) first_list = rst;
136
137 return 0;
138}
139
140int HECMW_restart_add_int(int *data, int n_data) {
141 return HECMW_restart_add(data, sizeof(int) * n_data);
142}
143
144int HECMW_restart_add_double(double *data, int n_data) {
145 return HECMW_restart_add(data, sizeof(double) * n_data);
146}
147
148static int restart_write(const void *ptr, size_t size, size_t nmemb,
149 FILE *stream) {
150 int rc, msgno;
151
152 rc = fwrite(ptr, size, nmemb, stream);
153 if (rc != nmemb) {
154 if (feof(stream)) {
155 msgno = HECMW_UTIL_E0104;
156 } else if (ferror(stream)) {
157 msgno = HECMW_UTIL_E0105;
158 }
159 return msgno;
160 }
161 return 0;
162}
163
164int HECMW_restart_write_by_name(char *name_ID) {
165 FILE *fp;
166 struct restart_list *p;
167 char *filename;
168 int rc;
169
170 if (previ_list == NULL) return 0;
171
172 if (name_ID) {
173 if ((filename = HECMW_ctrl_get_restart_file(name_ID)) == NULL) return -1;
174 } else {
175 /* io is bitmap */
177 if ((filename = HECMW_ctrl_get_restart_file_by_io(io)) == NULL) return -1;
178 }
179
180 if (HECMW_ctrl_is_subdir()) {
181 if (HECMW_ctrl_make_subdir(filename)) {
182 HECMW_free(filename);
183 return -1;
184 }
185 }
186
187 if ((fp = fopen(filename, "w")) == NULL) {
188 HECMW_set_error(HECMW_UTIL_E0101, "File: %s, %s", filename,
189 HECMW_strmsg(errno));
190 HECMW_free(filename);
191 return -1;
192 }
193 HECMW_free(filename);
194
195 for (p = first_list; p; p = p->next) {
196 /* write size */
197 rc = restart_write(&p->size, sizeof(p->size), 1, fp);
198 if (rc) {
199 HECMW_set_error(rc, "");
200 return -1;
201 }
202 /* write data */
203 rc = restart_write(p->data, p->size, 1, fp);
204 if (rc) {
205 HECMW_set_error(rc, "");
206 return -1;
207 }
208 }
209
210 if (fclose(fp)) {
211 HECMW_set_error(errno, "");
212 return -1;
213 }
214
215 clear();
216
217 return 0;
218}
219
221
222/*----------------------------------------------------------------------------*/
223
224void hecmw_restart_open_by_name_if(char *name_ID, int *err, int len) {
225 char *name = NULL;
226 char cname[HECMW_NAME_LEN + 1];
227
228 *err = 1;
229
230 if (name_ID) {
231 if (HECMW_strcpy_f2c_r(name_ID, len, cname, sizeof(cname)) == NULL) return;
232 name = cname;
233 }
234
235 if (HECMW_restart_open_by_name(name)) return;
236
237 *err = 0;
238}
239
240void hecmw_restart_open_by_name_if_(char *name_ID, int *err, int len) {
241 hecmw_restart_open_by_name_if(name_ID, err, len);
242}
243
244void hecmw_restart_open_by_name_if__(char *name_ID, int *err, int len) {
245 hecmw_restart_open_by_name_if(name_ID, err, len);
246}
247
248void HECMW_RESTART_OPEN_BY_NAME_IF(char *name_ID, int *err, int len) {
249 hecmw_restart_open_by_name_if(name_ID, err, len);
250}
251
252/*----------------------------------------------------------------------------*/
253
254void hecmw_restart_open_if(int *err) {
256}
257
259
261
263
264/*----------------------------------------------------------------------------*/
265
266void hecmw_restart_close_if(int *err) { *err = HECMW_restart_close() ? 1 : 0; }
267
269
271
273
274/*----------------------------------------------------------------------------*/
275
276void hecmw_restart_read_int_if(int *dst, int *err) {
277 *err = 1;
278
279 if (dst == NULL) {
281 return;
282 }
283 if (HECMW_restart_read(dst) == NULL) return;
284
285 *err = 0;
286}
287
288void hecmw_restart_read_int_if_(int *dst, int *err) {
290}
291
292void hecmw_restart_read_int_if__(int *dst, int *err) {
294}
295
296void HECMW_RESTART_READ_INT_IF(int *dst, int *err) {
298}
299
300/*----------------------------------------------------------------------------*/
301
302void hecmw_restart_read_real_if(double *dst, int *err) {
303 *err = 1;
304
305 if (dst == NULL) {
307 return;
308 }
309 if (HECMW_restart_read(dst) == NULL) return;
310
311 *err = 0;
312}
313
314void hecmw_restart_read_real_if_(double *dst, int *err) {
316}
317
318void hecmw_restart_read_real_if__(double *dst, int *err) {
320}
321
322void HECMW_RESTART_READ_REAL_IF(double *dst, int *err) {
324}
325
326/*----------------------------------------------------------------------------*/
327
328static void *restart_add_alloc(void *data, int byte, int n_data) {
329 int size;
330 void *cdata;
331
332 size = byte * n_data;
333 cdata = HECMW_malloc(size);
334 if (cdata == NULL) {
335 HECMW_set_error(errno, "");
336 return NULL;
337 }
338 memcpy(cdata, data, size);
339
340 return cdata;
341}
342
343void hecmw_restart_add_int_if(int *data, int *n_data, int *err) {
344 int *cdata;
345
346 cdata = restart_add_alloc(data, sizeof(int), *n_data);
347 if (cdata == NULL) {
348 *err = 1;
349 return;
350 }
351
352 *err = HECMW_restart_add_int(cdata, *n_data);
353}
354
355void hecmw_restart_add_int_if_(int *data, int *n_data, int *err) {
356 hecmw_restart_add_int_if(data, n_data, err);
357}
358
359void hecmw_restart_add_int_if__(int *data, int *n_data, int *err) {
360 hecmw_restart_add_int_if(data, n_data, err);
361}
362
363void HECMW_RESTART_ADD_INT_IF(int *data, int *n_data, int *err) {
364 hecmw_restart_add_int_if(data, n_data, err);
365}
366
367/*----------------------------------------------------------------------------*/
368
369void hecmw_restart_add_real_if(double *data, int *n_data, int *err) {
370 void *cdata;
371
372 cdata = restart_add_alloc(data, sizeof(double), *n_data);
373 if (cdata == NULL) {
374 *err = 1;
375 return;
376 }
377 *err = HECMW_restart_add_double(cdata, *n_data);
378}
379
380void hecmw_restart_add_real_if_(double *data, int *n_data, int *err) {
381 hecmw_restart_add_real_if(data, n_data, err);
382}
383
384void hecmw_restart_add_real_if__(double *data, int *n_data, int *err) {
385 hecmw_restart_add_real_if(data, n_data, err);
386}
387
388void HECMW_RESTART_ADD_REAL_IF(double *data, int *n_data, int *err) {
389 hecmw_restart_add_real_if(data, n_data, err);
390}
391
392/*----------------------------------------------------------------------------*/
393
394void hecmw_restart_write_by_name_if(char *name_ID, int *err, int len) {
395 char *name = NULL;
396 char cname[HECMW_NAME_LEN + 1];
397
398 *err = 1;
399
400 if (name_ID) {
401 if (HECMW_strcpy_f2c_r(name_ID, len, cname, sizeof(cname)) == NULL) return;
402 name = cname;
403 }
404
405 if (HECMW_restart_write_by_name(name)) return;
406
407 *err = 0;
408}
409
410void hecmw_restart_write_by_name_if_(char *name_ID, int *err, int len) {
411 hecmw_restart_write_by_name_if(name_ID, err, len);
412}
413
414void hecmw_restart_write_by_name_if__(char *name_ID, int *err, int len) {
415 hecmw_restart_write_by_name_if(name_ID, err, len);
416}
417
418void HECMW_RESTART_WRITE_BY_NAME_IF(char *name_ID, int *err, int len) {
419 hecmw_restart_write_by_name_if(name_ID, err, len);
420}
421
422/*----------------------------------------------------------------------------*/
423
426}
427
429
431
#define HECMW_NAME_LEN
Definition: hecmw_config.h:70
char * HECMW_ctrl_get_restart_file_by_io(int io)
char * HECMW_ctrl_get_restart_file(char *name_ID)
int HECMW_ctrl_is_subdir(void)
int HECMW_ctrl_make_subdir(char *filename)
#define HECMW_CTRL_FILE_IO_OUT
Definition: hecmw_control.h:30
#define HECMW_CTRL_FILE_IO_IN
Definition: hecmw_control.h:28
#define HECMW_CTRL_FILE_IO_INOUT
Definition: hecmw_control.h:37
int HECMW_set_error(int errorno, const char *fmt,...)
Definition: hecmw_error.c:37
#define NULL
char * HECMW_strcpy_f2c_r(const char *fstr, int flen, char *buf, int bufsize)
Definition: hecmw_lib_fc.c:45
#define HECMW_free(ptr)
Definition: hecmw_malloc.h:24
#define HECMW_malloc(size)
Definition: hecmw_malloc.h:20
char * HECMW_strmsg(int msgno)
Definition: hecmw_msg.c:31
#define HECMW_UTIL_E0104
Definition: hecmw_msgno.h:361
#define HECMW_UTIL_E0102
Definition: hecmw_msgno.h:359
#define HECMW_UTIL_E0101
Definition: hecmw_msgno.h:358
#define HECMW_UTIL_E0105
Definition: hecmw_msgno.h:362
#define HECMW_ALL_E0101
Definition: hecmw_msgno.h:12
#define HECMW_UTIL_E0103
Definition: hecmw_msgno.h:360
void hecmw_restart_write_if(int *err)
int HECMW_restart_close(void)
Definition: hecmw_restart.c:59
void hecmw_restart_write_if_(int *err)
void hecmw_restart_add_real_if__(double *data, int *n_data, int *err)
void hecmw_restart_read_int_if(int *dst, int *err)
void hecmw_restart_read_int_if__(int *dst, int *err)
void hecmw_restart_write_by_name_if__(char *name_ID, int *err, int len)
void HECMW_RESTART_ADD_REAL_IF(double *data, int *n_data, int *err)
int HECMW_restart_add(void *data, size_t size)
void hecmw_restart_open_by_name_if_(char *name_ID, int *err, int len)
void HECMW_RESTART_WRITE_IF(int *err)
void HECMW_RESTART_ADD_INT_IF(int *data, int *n_data, int *err)
void HECMW_RESTART_READ_INT_IF(int *dst, int *err)
void hecmw_restart_close_if__(int *err)
void hecmw_restart_open_if__(int *err)
void hecmw_restart_add_int_if(int *data, int *n_data, int *err)
void hecmw_restart_write_if__(int *err)
void hecmw_restart_add_int_if_(int *data, int *n_data, int *err)
void hecmw_restart_read_real_if(double *dst, int *err)
int HECMW_restart_add_double(double *data, int n_data)
int HECMW_restart_write(void)
void * HECMW_restart_read(void *addr)
Definition: hecmw_restart.c:84
void hecmw_restart_add_int_if__(int *data, int *n_data, int *err)
int HECMW_restart_add_int(int *data, int n_data)
void hecmw_restart_open_by_name_if__(char *name_ID, int *err, int len)
void hecmw_restart_close_if(int *err)
void hecmw_restart_read_real_if_(double *dst, int *err)
void hecmw_restart_add_real_if_(double *data, int *n_data, int *err)
void hecmw_restart_add_real_if(double *data, int *n_data, int *err)
void hecmw_restart_open_by_name_if(char *name_ID, int *err, int len)
int HECMW_restart_open_by_name(char *name_ID)
Definition: hecmw_restart.c:36
void hecmw_restart_write_by_name_if_(char *name_ID, int *err, int len)
void HECMW_RESTART_OPEN_IF(int *err)
void hecmw_restart_read_real_if__(double *dst, int *err)
void HECMW_RESTART_OPEN_BY_NAME_IF(char *name_ID, int *err, int len)
void HECMW_RESTART_READ_REAL_IF(double *dst, int *err)
void hecmw_restart_open_if(int *err)
void hecmw_restart_open_if_(int *err)
void hecmw_restart_write_by_name_if(char *name_ID, int *err, int len)
void HECMW_RESTART_CLOSE_IF(int *err)
int HECMW_restart_write_by_name(char *name_ID)
void hecmw_restart_read_int_if_(int *dst, int *err)
int HECMW_restart_open(void)
Definition: hecmw_restart.c:57
void HECMW_RESTART_WRITE_BY_NAME_IF(char *name_ID, int *err, int len)
void hecmw_restart_close_if_(int *err)
CNFData data
struct restart_list * next
Definition: hecmw_restart.c:17