FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
hecmw_result_copy_c2f.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 "hecmw_struct.h"
9#include "hecmw_util.h"
10#include "hecmw_result.h"
11
12static struct hecmwST_result_data *result;
13static int nnode, nelem;
14
15/*-----------------------------------------------------------------------------
16 * SetFunc
17 */
18
19static int set_ng_component(void *dst) {
20 *((int *)dst) = result->ng_component;
21 return 0;
22}
23
24static int set_ng_dof(void *dst) {
25 void *src;
26 int size;
27
28 if (result->ng_component <= 0) return 0;
29
30 src = result->ng_dof;
31 size = sizeof(*result->ng_dof) * result->ng_component;
32 memcpy(dst, src, size);
33
34 return 0;
35}
36
37static int set_global_label(void *dst) {
38 int i;
39
40 if (result->ng_component <= 0) return 0;
41
42 for (i = 0; i < result->ng_component; i++) {
43 char *dst_point = (char *)dst + HECMW_NAME_LEN * i;
44 char *src = result->global_label[i];
45 HECMW_strcpy_c2f(src, dst_point, HECMW_NAME_LEN);
46 }
47
48 return 0;
49}
50
51static int set_global_val_item(void *dst) {
52 void *src;
53 int i, n, size;
54
55 if (result->ng_component <= 0) return 0;
56
57 n = 0;
58 for (i = 0; i < result->ng_component; i++) {
59 n += result->ng_dof[i];
60 }
61 src = result->global_val_item;
62 size = sizeof(*result->global_val_item) * n;
63 memcpy(dst, src, size);
64
65 return 0;
66}
67
68static int set_nn_component(void *dst) {
69 *((int *)dst) = result->nn_component;
70 return 0;
71}
72
73static int set_nn_dof(void *dst) {
74 void *src;
75 int size;
76
77 if (result->nn_component <= 0) return 0;
78
79 src = result->nn_dof;
80 size = sizeof(*result->nn_dof) * result->nn_component;
81 memcpy(dst, src, size);
82
83 return 0;
84}
85
86static int set_node_label(void *dst) {
87 int i;
88
89 if (result->nn_component <= 0) return 0;
90
91 for (i = 0; i < result->nn_component; i++) {
92 char *dst_point = (char *)dst + HECMW_NAME_LEN * i;
93 char *src = result->node_label[i];
94 HECMW_strcpy_c2f(src, dst_point, HECMW_NAME_LEN);
95 }
96
97 return 0;
98}
99
100static int set_node_val_item(void *dst) {
101 void *src;
102 int i, n, size;
103
104 if (result->nn_component <= 0) return 0;
105
106 n = 0;
107 for (i = 0; i < result->nn_component; i++) {
108 n += result->nn_dof[i];
109 }
110 src = result->node_val_item;
111 size = sizeof(*result->node_val_item) * n * nnode;
112 memcpy(dst, src, size);
113
114 return 0;
115}
116
117static int set_ne_component(void *dst) {
118 *((int *)dst) = result->ne_component;
119 return 0;
120}
121
122static int set_ne_dof(void *dst) {
123 void *src;
124 int size;
125
126 if (result->ne_component <= 0) return 0;
127
128 src = result->ne_dof;
129 size = sizeof(*result->ne_dof) * result->ne_component;
130 memcpy(dst, src, size);
131
132 return 0;
133}
134
135static int set_elem_label(void *dst) {
136 int i;
137
138 if (result->ne_component <= 0) return 0;
139
140 for (i = 0; i < result->ne_component; i++) {
141 char *dst_point = (char *)dst + HECMW_NAME_LEN * i;
142 char *src = result->elem_label[i];
143 HECMW_strcpy_c2f(src, dst_point, HECMW_NAME_LEN);
144 }
145
146 return 0;
147}
148
149static int set_elem_val_item(void *dst) {
150 void *src;
151 int i, n, size;
152
153 if (result->ne_component <= 0) return 0;
154
155 n = 0;
156 for (i = 0; i < result->ne_component; i++) {
157 n += result->ne_dof[i];
158 }
159 src = result->elem_val_item;
160 size = sizeof(*result->elem_val_item) * n * nelem;
161 memcpy(dst, src, size);
162
163 return 0;
164}
165
166/*-----------------------------------------------------------------------------
167 * SetFunc table
168 */
169
170typedef int (*SetFunc)(void *);
171
172static struct func_table {
173 char *struct_name;
174 char *var_name;
175 SetFunc set_func;
176} functions[] =
177 {
178 /* { Struct name, Variable name, memcpy function, check allocation
179 function }*/
180 {"hecmwST_result_data", "ng_component", set_ng_component},
181 {"hecmwST_result_data", "ng_dof", set_ng_dof},
182 {"hecmwST_result_data", "global_label", set_global_label},
183 {"hecmwST_result_data", "global_val_item", set_global_val_item},
184
185 {"hecmwST_result_data", "nn_component", set_nn_component},
186 {"hecmwST_result_data", "nn_dof", set_nn_dof},
187 {"hecmwST_result_data", "node_label", set_node_label},
188 {"hecmwST_result_data", "node_val_item", set_node_val_item},
189
190 {"hecmwST_result_data", "ne_component", set_ne_component},
191 {"hecmwST_result_data", "ne_dof", set_ne_dof},
192 {"hecmwST_result_data", "elem_label", set_elem_label},
193 {"hecmwST_result_data", "elem_val_item", set_elem_val_item},
194};
195
196static const int NFUNC = sizeof(functions) / sizeof(functions[0]);
197
198static SetFunc get_set_func(char *struct_name, char *var_name) {
199 int i;
200
201 for (i = 0; i < NFUNC; i++) {
202 if (strcmp(functions[i].struct_name, struct_name) == 0 &&
203 strcmp(functions[i].var_name, var_name) == 0) {
204 return functions[i].set_func;
205 }
206 }
207 return NULL;
208}
209
210/*----------------------------------------------------------------------------*/
211
213 int n_node, int n_elem) {
214 result = result_data;
215 nnode = n_node;
216 nelem = n_elem;
217 return 0;
218}
219
221 result = NULL;
222 return 0;
223}
224
225/*----------------------------------------------------------------------------*/
226
227void hecmw_result_copy_c2f_set_if(char *struct_name, char *var_name, void *dst,
228 int *err, int len_struct, int len_var) {
229 SetFunc func;
230 char sname[HECMW_NAME_LEN + 1];
231 char vname[HECMW_NAME_LEN + 1];
232
233 *err = 1;
234
235 if (result == NULL) {
238 "hecmw_result_copy_c2f_set_if(): 'result' has not initialized yet");
239 return;
240 }
241 if (struct_name == NULL) {
243 "hecmw_result_copy_c2f_set_if(): 'sname' is NULL");
244 return;
245 }
246 if (var_name == NULL) {
248 "hecmw_result_copy_c2f_set_if(): 'vname' is NULL");
249 return;
250 }
251 if (dst == NULL) {
253 "hecmw_result_copy_c2f_set_if(): 'dst' is NULL");
254 return;
255 }
256
257 if (HECMW_strcpy_f2c_r(struct_name, len_struct, sname, sizeof(sname)) ==
258 NULL) {
259 return;
260 }
261 if (HECMW_strcpy_f2c_r(var_name, len_var, vname, sizeof(vname)) == NULL) {
262 return;
263 }
264
265 func = get_set_func(sname, vname);
266 if (func == NULL) {
268 "hecmw_result_copy_c2f_set_if(): SetFunc not found");
269 return;
270 }
271
272 if ((*func)(dst)) {
273 return;
274 }
275
276 *err = 0;
277}
278
279void hecmw_result_copy_c2f_set_if_(char *struct_name, char *var_name, void *dst,
280 int *err, int len_struct, int len_var) {
281 hecmw_result_copy_c2f_set_if(struct_name, var_name, dst, err, len_struct,
282 len_var);
283}
284
285void hecmw_result_copy_c2f_set_if__(char *struct_name, char *var_name,
286 void *dst, int *err, int len_struct,
287 int len_var) {
288 hecmw_result_copy_c2f_set_if(struct_name, var_name, dst, err, len_struct,
289 len_var);
290}
291
292void HECMW_RESULT_COPY_C2F_SET_IF(char *struct_name, char *var_name, void *dst,
293 int *err, int len_struct, int len_var) {
294 hecmw_result_copy_c2f_set_if(struct_name, var_name, dst, err, len_struct,
295 len_var);
296}
297
298/*----------------------------------------------------------------------------*/
299
300void hecmw_result_read_by_name_if(char *name_ID, int *i_step,
301 int *n_node, int *n_elem, int *err, int len) {
302 char name_ID_str[HECMW_NAME_LEN + 1];
303
304 *err = 1;
305
306 if (HECMW_strcpy_f2c_r(name_ID, len, name_ID_str, sizeof(name_ID_str)) ==
307 NULL)
308 return;
309
310 result = HECMW_result_read_by_name(name_ID_str, *i_step);
311 if (result == NULL) return;
312
313 nnode = HECMW_result_get_nnode();
314 nelem = HECMW_result_get_nelem();
315 *n_node = nnode;
316 *n_elem = nelem;
317
318 *err = 0;
319}
320
321void hecmw_result_read_by_name_if_(char *name_ID, int *i_step,
322 int *n_node, int *n_elem, int *err,
323 int len) {
324 hecmw_result_read_by_name_if(name_ID, i_step, n_node, n_elem, err,
325 len);
326}
327
328void hecmw_result_read_by_name_if__(char *name_ID, int *i_step,
329 int *n_node, int *n_elem, int *err,
330 int len) {
331 hecmw_result_read_by_name_if(name_ID, i_step, n_node, n_elem, err,
332 len);
333}
334
335void HECMW_RESULT_READ_BY_NAME_IF(char *name_ID, int *i_step,
336 int *n_node, int *n_elem, int *err, int len) {
337 hecmw_result_read_by_name_if(name_ID, i_step, n_node, n_elem, err,
338 len);
339}
340
341/*----------------------------------------------------------------------------*/
342
344 *err = 1;
345 HECMW_result_free(result);
348 *err = 0;
349}
350
353}
354
357}
358
361}
#define HECMW_NAME_LEN
Definition: hecmw_config.h:70
int(* SetFunc)(void *)
int HECMW_set_error(int errorno, const char *fmt,...)
Definition: hecmw_error.c:37
#define NULL
int HECMW_strcpy_c2f(const char *cstr, char *fstr, int flen)
Definition: hecmw_lib_fc.c:72
char * HECMW_strcpy_f2c_r(const char *fstr, int flen, char *buf, int bufsize)
Definition: hecmw_lib_fc.c:45
#define HECMW_ALL_E0101
Definition: hecmw_msgno.h:12
#define HECMW_ALL_E0102
Definition: hecmw_msgno.h:13
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_nelem(void)
Definition: hecmw_result.c:205
void HECMW_result_free(struct hecmwST_result_data *result)
Definition: hecmw_result.c:25
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_copy_c2f_finalize(void)
void HECMW_RESULT_COPY_C2F_SET_IF(char *struct_name, char *var_name, void *dst, int *err, int len_struct, int len_var)
void hecmw_result_read_finalize_if__(int *err)
void hecmw_result_copy_c2f_set_if__(char *struct_name, char *var_name, void *dst, int *err, int len_struct, int len_var)
void HECMW_RESULT_READ_FINALIZE_IF(int *err)
void HECMW_RESULT_READ_BY_NAME_IF(char *name_ID, int *i_step, int *n_node, int *n_elem, int *err, int len)
void hecmw_result_read_finalize_if(int *err)
int HECMW_result_copy_c2f_init(struct hecmwST_result_data *result_data, int n_node, int n_elem)
void hecmw_result_read_finalize_if_(int *err)
void hecmw_result_copy_c2f_set_if(char *struct_name, char *var_name, void *dst, int *err, int len_struct, int len_var)
void hecmw_result_read_by_name_if_(char *name_ID, int *i_step, int *n_node, int *n_elem, int *err, int len)
int(* SetFunc)(void *)
void hecmw_result_read_by_name_if__(char *name_ID, int *i_step, int *n_node, int *n_elem, int *err, int len)
void hecmw_result_copy_c2f_set_if_(char *struct_name, char *var_name, void *dst, int *err, int len_struct, int len_var)
void hecmw_result_read_by_name_if(char *name_ID, int *i_step, int *n_node, int *n_elem, int *err, int len)
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