FrontISTR  5.2.0
Large-scale structural analysis program with finit element method
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 
23 static struct fortran_remainder *remainder; /* for Fortran */
24 
25 void HECMW_result_free(struct hecmwST_result_data *result) {
26  int i;
27 
28  if (result == NULL) return;
29 
30  if (result->ng_component > 0) {
31  HECMW_free(result->ng_dof);
32  HECMW_free(result->global_val_item);
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);
41  HECMW_free(result->node_val_item);
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);
50  HECMW_free(result->elem_val_item);
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 
77 int 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 
125 int 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 
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 
148 int 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 
203 int HECMW_result_get_nnode(void) { return nnode; }
204 
205 int HECMW_result_get_nelem(void) { return nelem; }
206 
207 char *HECMW_result_get_header(char *buff) {
208  strcpy(buff, head);
209  return buff;
210 }
211 
212 char *HECMW_result_get_comment(char *buff) {
213  strcpy(buff, comment_line);
214  return buff;
215 }
216 
217 int *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 
225 int *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 
247 void 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 
264 void 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 
271 void 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 
278 void 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 
287 void hecmw_result_finalize_if(int *err) {
288  *err = 1;
289  if (HECMW_result_finalize()) return;
292  *err = 0;
293 }
294 
296 
298 
300 
301 /*---------------------------------------------------------------------------*/
302 
303 void 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 
344 void 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 
349 void 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 
354 void 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 
361 void 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 
383 void 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 
387 void 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 
391 void 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 
397 void 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 
424 void 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 
429 void 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 
434 void 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 
441 void 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 
455 void 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 
459 void 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 
463 void 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_file(char *name_ID, int istep, int *fg_text)
char * HECMW_ctrl_get_result_fileheader(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
int * HECMW_result_get_nodeID(int *buff)
Definition: hecmw_result.c:217
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
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
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
void HECMW_result_free(struct hecmwST_result_data *result)
Definition: hecmw_result.c:25
struct hecmwST_result_data * HECMW_result_read_by_fname(char *filename)
Definition: hecmw_result.c:168
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
char * HECMW_result_get_comment(char *buff)
Definition: hecmw_result.c:212
struct hecmwST_result_data * HECMW_result_read_by_name(char *name_ID, int i_step)
Definition: hecmw_result.c:180
void hecmw_result_add_if__(int *dtype, int *n_dof, char *label, double *ptr, int *err, int len)
Definition: hecmw_result.c:349
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
int * HECMW_result_get_elemID(int *buff)
Definition: hecmw_result.c:225
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
char * HECMW_result_get_header(char *buff)
Definition: hecmw_result.c:207
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
struct hecmwST_result_data * HECMW_result_read_bin_by_fname(char *filename)
int HECMW_result_write_bin_by_fname(char *filename)
struct hecmwST_result_data * HECMW_result_read_txt_by_fname(char *filename)
int HECMW_result_write_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]
integer(kind=kint) myrank
PARALLEL EXECUTION.
Definition: m_fstr.f90:80
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