FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
hecmw_result.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 <string.h>
10#include <errno.h>
11#include <ctype.h>
12#include "hecmw_util.h"
13#include "hecmw_config.h"
14#include "hecmw_bin_io.h"
15#include "hecmw_result.h"
16#include "hecmw_result_io.h"
17
19 double *ptr;
21};
22
23static struct fortran_remainder *remainder; /* for Fortran */
24
26 int i;
27
28 if (result == NULL) return;
29
30 if (result->ng_component > 0) {
31 HECMW_free(result->ng_dof);
33 for (i = 0; i < result->ng_component; i++) {
34 HECMW_free(result->global_label[i]);
35 }
36 HECMW_free(result->global_label);
37 }
38
39 if (result->nn_component > 0) {
40 HECMW_free(result->nn_dof);
42 for (i = 0; i < result->nn_component; i++) {
43 HECMW_free(result->node_label[i]);
44 }
45 HECMW_free(result->node_label);
46 }
47
48 if (result->ne_component > 0) {
49 HECMW_free(result->ne_dof);
51 for (i = 0; i < result->ne_component; i++) {
52 HECMW_free(result->elem_label[i]);
53 }
54 HECMW_free(result->elem_label);
55 }
56
57 HECMW_free(result);
58}
59
61 int i_step, char *header, char *comment) {
63 hecMESH->n_node, hecMESH->n_elem, hecMESH->global_node_ID,
64 hecMESH->global_elem_ID, i_step, header, comment);
65}
66
69 return 0;
70}
71
72
73/*---------------------------------------------------------------------------*/
74/* UNIVERSAL I/O */
75/*---------------------------------------------------------------------------*/
76
77int HECMW_result_write_by_name(char *name_ID) {
78 char *basename, filename[HECMW_FILENAME_LEN + 1];
79 int fg_text, ret;
80
81 if ((basename =
82 HECMW_ctrl_get_result_file(name_ID, istep, &fg_text)) == NULL)
83 return -1;
84
85 ret = snprintf(filename, HECMW_FILENAME_LEN + 1, "%s.%d", basename, istep);
86 HECMW_free(basename);
87 if (ret > HECMW_FILENAME_LEN) return -1;
88
89 if (fg_text) {
90 if (HECMW_result_write_txt_by_fname(filename)) return -1;
91 } else {
92 if (HECMW_result_write_bin_by_fname(filename)) return -1;
93 }
94
95 return 0;
96}
97
99 struct hecmwST_result_data *result,
100 int n_node, int n_elem, char *header, char *comment) {
101 char *basename, filename[HECMW_FILENAME_LEN + 1];
102 int fg_text, ret;
103
104 if ((basename =
105 HECMW_ctrl_get_result_file(name_ID, istep, &fg_text)) == NULL)
106 return -1;
107
108 ret = snprintf(filename, HECMW_FILENAME_LEN + 1, "%s.%d", basename, istep);
109 HECMW_free(basename);
110 if (ret > HECMW_FILENAME_LEN) return -1;
111
112 if (fg_text) {
113 if (HECMW_result_write_txt_ST_by_fname(filename, result, n_node, n_elem,
114 header, comment))
115 return -1;
116 } else {
117 if (HECMW_result_write_bin_ST_by_fname(filename, result, n_node, n_elem,
118 header, comment))
119 return -1;
120 }
121
122 return 0;
123}
124
125int HECMW_result_write_by_addfname(char *name_ID, char *addfname) {
126 char *basename, filename[HECMW_FILENAME_LEN + 1];
127 int fg_text, myrank, ret;
128
129 if ((basename = HECMW_ctrl_get_result_fileheader(name_ID, istep,
130 &fg_text)) == NULL)
131 return -1;
132
133 myrank = HECMW_comm_get_rank();
134 ret = snprintf(filename, HECMW_FILENAME_LEN + 1, "%s%s.%d.%d", basename,
135 addfname, myrank, istep);
136 HECMW_free(basename);
137 if (ret > HECMW_FILENAME_LEN) return -1;
138
139 if (fg_text) {
140 if (HECMW_result_write_txt_by_fname(filename)) return -1;
141 } else {
142 if (HECMW_result_write_bin_by_fname(filename)) return -1;
143 }
144
145 return 0;
146}
147
148int HECMW_result_checkfile_by_name(char *name_ID, int i_step) {
149 char *basename, filename[HECMW_FILENAME_LEN + 1];
150 int fg_text, ret;
151 FILE *fp;
152
153 if ((basename = HECMW_ctrl_get_result_file(name_ID, i_step,
154 &fg_text)) == NULL)
155 return -1;
156
157 ret = snprintf(filename, HECMW_FILENAME_LEN + 1, "%s.%d", basename, i_step);
158 HECMW_free(basename);
159 if (ret > HECMW_FILENAME_LEN) return -1;
160
161 fp = fopen(filename, "r");
162 if (fp == NULL) return -1;
163 fclose(fp);
164
165 return 0;
166}
167
169 struct hecmwST_result_data *result;
170
171 if (HECMW_judge_result_bin_file(filename)) {
172 result = HECMW_result_read_bin_by_fname(filename);
173 } else {
174 result = HECMW_result_read_txt_by_fname(filename);
175 }
176
177 return result;
178}
179
181 int i_step) {
182 char *basename, filename[HECMW_FILENAME_LEN + 1];
183 struct hecmwST_result_data *result;
184 int fg_text, ret;
185
186 if ((basename = HECMW_ctrl_get_result_file(name_ID, i_step,
187 &fg_text)) == NULL)
188 return NULL;
189
190 ret = snprintf(filename, HECMW_FILENAME_LEN + 1, "%s.%d", basename, i_step);
191 HECMW_free(basename);
192 if (ret > HECMW_FILENAME_LEN) return NULL;
193
194 if ((result = HECMW_result_read_by_fname(filename)) == NULL) return NULL;
195
196 return result;
197}
198
199/*---------------------------------------------------------------------------*/
200/* etc. */
201/*---------------------------------------------------------------------------*/
202
203int HECMW_result_get_nnode(void) { return nnode; }
204
205int HECMW_result_get_nelem(void) { return nelem; }
206
207char *HECMW_result_get_header(char *buff) {
208 strcpy(buff, head);
209 return buff;
210}
211
212char *HECMW_result_get_comment(char *buff) {
213 strcpy(buff, comment_line);
214 return buff;
215}
216
217int *HECMW_result_get_nodeID(int *buff) {
218 int i;
219 for (i = 0; i < nnode; i++) {
220 buff[i] = node_global_ID[i];
221 }
222 return buff;
223}
224
225int *HECMW_result_get_elemID(int *buff) {
226 int i;
227 for (i = 0; i < nelem; i++) {
228 buff[i] = elem_global_ID[i];
229 }
230 return buff;
231}
232
236}
237
241}
242
243/*---------------------------------------------------------------------------*/
244/* FORTRAN INTERFACE */
245/*---------------------------------------------------------------------------*/
246
247void hecmw_result_init_if(int *n_node, int *n_elem, int *nodeID, int *elemID,
248 int *i_step, char *header, char *comment, int *err,
249 int len) {
250 char header_str[HECMW_HEADER_LEN + 1];
251 char comment_str[HECMW_MSG_LEN + 1];
252
253 *err = 1;
254 if (HECMW_strcpy_f2c_r(header, len, header_str, sizeof(header_str)) == NULL)
255 return;
256 if (HECMW_strcpy_f2c_r(comment, len, comment_str, sizeof(comment_str)) == NULL)
257 return;
258 if (HECMW_result_init_body(*n_node, *n_elem, nodeID, elemID, *i_step,
259 header_str, comment_str))
260 return;
261 *err = 0;
262}
263
264void hecmw_result_init_if_(int *n_node, int *n_elem, int *nodeID, int *elemID,
265 int *i_step, char *header, char *comment, int *err,
266 int len) {
267 hecmw_result_init_if(n_node, n_elem, nodeID, elemID, i_step, header, comment,
268 err, len);
269}
270
271void hecmw_result_init_if__(int *n_node, int *n_elem, int *nodeID, int *elemID,
272 int *i_step, char *header, char *comment, int *err,
273 int len) {
274 hecmw_result_init_if(n_node, n_elem, nodeID, elemID, i_step, header, comment,
275 err, len);
276}
277
278void HECMW_RESULT_INIT_IF(int *n_node, int *n_elem, int *nodeID, int *elemID,
279 int *i_step, char *header, char *comment, int *err,
280 int len) {
281 hecmw_result_init_if(n_node, n_elem, nodeID, elemID, i_step, header, comment,
282 err, len);
283}
284
285/*---------------------------------------------------------------------------*/
286
288 *err = 1;
289 if (HECMW_result_finalize()) return;
292 *err = 0;
293}
294
296
298
300
301/*---------------------------------------------------------------------------*/
302
303void hecmw_result_add_if(int *dtype, int *n_dof, char *label,
304 double *ptr, int *err, int len) {
305 char label_str[HECMW_NAME_LEN + 1];
306 int n, size;
307 double *data;
308 struct fortran_remainder *remain;
309
310 *err = 1;
311
312 if (HECMW_strcpy_f2c_r(label, len, label_str, sizeof(label_str)) == NULL)
313 return;
314
315 if (*dtype == 1) { //node
316 n = nnode;
317 } else if (*dtype == 2) { //element
318 n = nelem;
319 } else { // global
320 n = 1;
321 }
322 size = sizeof(double) * n * (*n_dof);
323 data = HECMW_malloc(size);
324 if (data == NULL) {
325 HECMW_set_error(errno, "");
326 return;
327 }
328 memcpy(data, ptr, size);
329
330 remain = HECMW_malloc(sizeof(*remain));
331 if (remain == NULL) {
332 HECMW_set_error(errno, "");
333 return;
334 }
335 remain->ptr = data;
336 remain->next = remainder;
337 remainder = remain;
338
339 if (HECMW_result_add(*dtype, *n_dof, label_str, data)) return;
340
341 *err = 0;
342}
343
344void hecmw_result_add_if_(int *dtype, int *n_dof, char *label,
345 double *ptr, int *err, int len) {
346 hecmw_result_add_if(dtype, n_dof, label, ptr, err, len);
347}
348
349void hecmw_result_add_if__(int *dtype, int *n_dof, char *label,
350 double *ptr, int *err, int len) {
351 hecmw_result_add_if(dtype, n_dof, label, ptr, err, len);
352}
353
354void HECMW_RESULT_ADD_IF(int *dtype, int *n_dof, char *label,
355 double *ptr, int *err, int len) {
356 hecmw_result_add_if(dtype, n_dof, label, ptr, err, len);
357}
358
359/*----------------------------------------------------------------------------*/
360
361void hecmw_result_write_by_name_if(char *name_ID, int *err, int len) {
362 char name_ID_str[HECMW_NAME_LEN + 1];
363 struct fortran_remainder *p, *q;
364
365 *err = 1;
366
367 if (HECMW_strcpy_f2c_r(name_ID, len, name_ID_str, sizeof(name_ID_str)) ==
368 NULL)
369 return;
370
371 if (HECMW_result_write_by_name(name_ID_str)) return;
372
373 for (p = remainder; p; p = q) {
374 q = p->next;
375 HECMW_free(p->ptr);
376 HECMW_free(p);
377 }
378 remainder = NULL;
379
380 *err = 0;
381}
382
383void hecmw_result_write_by_name_if_(char *name_ID, int *err, int len) {
384 hecmw_result_write_by_name_if(name_ID, err, len);
385}
386
387void hecmw_result_write_by_name_if__(char *name_ID, int *err, int len) {
388 hecmw_result_write_by_name_if(name_ID, err, len);
389}
390
391void HECMW_RESULT_WRITE_BY_NAME_IF(char *name_ID, int *err, int len) {
392 hecmw_result_write_by_name_if(name_ID, err, len);
393}
394
395/*---------------------------------------------------------------------------*/
396
397void hecmw_result_write_by_addfname_if(char *name_ID, char *addfname, int *err,
398 int len1, int len2) {
399 char name_ID_str[HECMW_NAME_LEN + 1];
400 char addfname_str[HECMW_NAME_LEN + 1];
401 struct fortran_remainder *p, *q;
402
403 *err = 1;
404
405 if (HECMW_strcpy_f2c_r(name_ID, len1, name_ID_str, sizeof(name_ID_str)) ==
406 NULL)
407 return;
408 if (HECMW_strcpy_f2c_r(addfname, len2, addfname_str, sizeof(name_ID_str)) ==
409 NULL)
410 return;
411
412 if (HECMW_result_write_by_addfname(name_ID_str, addfname_str)) return;
413
414 for (p = remainder; p; p = q) {
415 q = p->next;
416 HECMW_free(p->ptr);
417 HECMW_free(p);
418 }
419 remainder = NULL;
420
421 *err = 0;
422}
423
424void hecmw_result_write_by_addfname_if_(char *name_ID, char *addfname, int *err,
425 int len1, int len2) {
426 hecmw_result_write_by_addfname_if(name_ID, addfname, err, len1, len2);
427}
428
429void hecmw_result_write_by_addfname_if__(char *name_ID, char *addfname,
430 int *err, int len1, int len2) {
431 hecmw_result_write_by_addfname_if(name_ID, addfname, err, len1, len2);
432}
433
434void HECMW_RESULT_WRITE_BY_ADDFNAME_IF(char *name_ID, char *addfname, int *err,
435 int len1, int len2) {
436 hecmw_result_write_by_addfname_if(name_ID, addfname, err, len1, len2);
437}
438
439/*----------------------------------------------------------------------------*/
440
441void hecmw_result_checkfile_by_name_if(char *name_ID, int *i_step, int *err, int len) {
442 char name_ID_str[HECMW_NAME_LEN + 1];
443
444 *err = 1;
445
446 if (HECMW_strcpy_f2c_r(name_ID, len, name_ID_str, sizeof(name_ID_str)) ==
447 NULL)
448 return;
449
450 if (HECMW_result_checkfile_by_name(name_ID_str, *i_step)) return;
451
452 *err = 0;
453}
454
455void hecmw_result_checkfile_by_name_if_(char *name_ID, int *i_step, int *err, int len) {
456 hecmw_result_checkfile_by_name_if(name_ID, i_step, err, len);
457}
458
459void hecmw_result_checkfile_by_name_if__(char *name_ID, int *i_step, int *err, int len) {
460 hecmw_result_checkfile_by_name_if(name_ID, i_step, err, len);
461}
462
463void HECMW_RESULT_CHECKFILE_BY_NAME_IF(char *name_ID, int *i_step, int *err, int len) {
464 hecmw_result_checkfile_by_name_if(name_ID, i_step, err, len);
465}
int HECMW_comm_get_rank(void)
Definition: hecmw_comm.c:707
#define HECMW_FILENAME_LEN
Definition: hecmw_config.h:72
#define HECMW_MSG_LEN
Definition: hecmw_config.h:74
#define HECMW_HEADER_LEN
Definition: hecmw_config.h:68
#define HECMW_NAME_LEN
Definition: hecmw_config.h:70
char * HECMW_ctrl_get_result_fileheader(char *name_ID, int istep, int *fg_text)
char * HECMW_ctrl_get_result_file(char *name_ID, int istep, int *fg_text)
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
void hecmw_result_checkfile_by_name_if_(char *name_ID, int *i_step, int *err, int len)
Definition: hecmw_result.c:455
char * HECMW_result_get_header(char *buff)
Definition: hecmw_result.c:207
void hecmw_result_write_by_name_if__(char *name_ID, int *err, int len)
Definition: hecmw_result.c:387
void hecmw_result_write_by_addfname_if(char *name_ID, char *addfname, int *err, int len1, int len2)
Definition: hecmw_result.c:397
int HECMW_result_get_nnode(void)
Definition: hecmw_result.c:203
void HECMW_result_free_nodeID(void)
Definition: hecmw_result.c:233
int * HECMW_result_get_elemID(int *buff)
Definition: hecmw_result.c:225
void HECMW_RESULT_INIT_IF(int *n_node, int *n_elem, int *nodeID, int *elemID, int *i_step, char *header, char *comment, int *err, int len)
Definition: hecmw_result.c:278
void hecmw_result_write_by_addfname_if__(char *name_ID, char *addfname, int *err, int len1, int len2)
Definition: hecmw_result.c:429
int HECMW_result_get_nelem(void)
Definition: hecmw_result.c:205
int HECMW_result_init(struct hecmwST_local_mesh *hecMESH, int i_step, char *header, char *comment)
Definition: hecmw_result.c:60
void hecmw_result_init_if(int *n_node, int *n_elem, int *nodeID, int *elemID, int *i_step, char *header, char *comment, int *err, int len)
Definition: hecmw_result.c:247
void HECMW_RESULT_WRITE_BY_NAME_IF(char *name_ID, int *err, int len)
Definition: hecmw_result.c:391
void HECMW_RESULT_WRITE_BY_ADDFNAME_IF(char *name_ID, char *addfname, int *err, int len1, int len2)
Definition: hecmw_result.c:434
struct hecmwST_result_data * HECMW_result_read_by_fname(char *filename)
Definition: hecmw_result.c:168
int HECMW_result_write_by_name(char *name_ID)
Definition: hecmw_result.c:77
int HECMW_result_checkfile_by_name(char *name_ID, int i_step)
Definition: hecmw_result.c:148
void HECMW_RESULT_FINALIZE_IF(int *err)
Definition: hecmw_result.c:299
char * HECMW_result_get_comment(char *buff)
Definition: hecmw_result.c:212
void HECMW_result_free(struct hecmwST_result_data *result)
Definition: hecmw_result.c:25
void hecmw_result_init_if_(int *n_node, int *n_elem, int *nodeID, int *elemID, int *i_step, char *header, char *comment, int *err, int len)
Definition: hecmw_result.c:264
void hecmw_result_write_by_name_if(char *name_ID, int *err, int len)
Definition: hecmw_result.c:361
void hecmw_result_add_if__(int *dtype, int *n_dof, char *label, double *ptr, int *err, int len)
Definition: hecmw_result.c:349
int * HECMW_result_get_nodeID(int *buff)
Definition: hecmw_result.c:217
void hecmw_result_checkfile_by_name_if__(char *name_ID, int *i_step, int *err, int len)
Definition: hecmw_result.c:459
void hecmw_result_write_by_name_if_(char *name_ID, int *err, int len)
Definition: hecmw_result.c:383
void HECMW_RESULT_CHECKFILE_BY_NAME_IF(char *name_ID, int *i_step, int *err, int len)
Definition: hecmw_result.c:463
void hecmw_result_finalize_if_(int *err)
Definition: hecmw_result.c:295
void HECMW_RESULT_ADD_IF(int *dtype, int *n_dof, char *label, double *ptr, int *err, int len)
Definition: hecmw_result.c:354
void hecmw_result_write_by_addfname_if_(char *name_ID, char *addfname, int *err, int len1, int len2)
Definition: hecmw_result.c:424
void hecmw_result_finalize_if__(int *err)
Definition: hecmw_result.c:297
void hecmw_result_checkfile_by_name_if(char *name_ID, int *i_step, int *err, int len)
Definition: hecmw_result.c:441
void hecmw_result_init_if__(int *n_node, int *n_elem, int *nodeID, int *elemID, int *i_step, char *header, char *comment, int *err, int len)
Definition: hecmw_result.c:271
void hecmw_result_finalize_if(int *err)
Definition: hecmw_result.c:287
void hecmw_result_add_if_(int *dtype, int *n_dof, char *label, double *ptr, int *err, int len)
Definition: hecmw_result.c:344
struct hecmwST_result_data * HECMW_result_read_by_name(char *name_ID, int i_step)
Definition: hecmw_result.c:180
void HECMW_result_free_elemID(void)
Definition: hecmw_result.c:238
int HECMW_result_finalize(void)
Definition: hecmw_result.c:67
int HECMW_result_write_ST_by_name(char *name_ID, struct hecmwST_result_data *result, int n_node, int n_elem, char *header, char *comment)
Definition: hecmw_result.c:98
void hecmw_result_add_if(int *dtype, int *n_dof, char *label, double *ptr, int *err, int len)
Definition: hecmw_result.c:303
int HECMW_result_write_by_addfname(char *name_ID, char *addfname)
Definition: hecmw_result.c:125
int HECMW_result_write_bin_by_fname(char *filename)
int HECMW_result_write_txt_by_fname(char *filename)
struct hecmwST_result_data * HECMW_result_read_bin_by_fname(char *filename)
struct hecmwST_result_data * HECMW_result_read_txt_by_fname(char *filename)
int HECMW_judge_result_bin_file(char *filename)
int HECMW_result_write_bin_ST_by_fname(char *filename, struct hecmwST_result_data *result, int n_node, int n_elem, char *header, char *comment)
int HECMW_result_write_txt_ST_by_fname(char *filename, struct hecmwST_result_data *result, int n_node, int n_elem, char *header, char *comment)
int HECMW_result_init_body(int n_node, int n_elem, int *nodeID, int *elemID, int i_step, char *header, char *comment)
int * node_global_ID
int HECMW_result_add(int dtype, int n_dof, char *label, double *ptr)
int * elem_global_ID
int nelem
int istep
void HECMW_result_clear()
int nnode
char comment_line[HECMW_MSG_LEN+1]
char head[HECMW_HEADER_LEN+1]
CNFData data
struct fortran_remainder * next
Definition: hecmw_result.c:20
double * elem_val_item
Definition: hecmw_result.h:23
double * global_val_item
Definition: hecmw_result.h:21
double * node_val_item
Definition: hecmw_result.h:22