FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
hecmw_dist_print.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_dist_print.h"
10
11void HECMW_dist_print_flags(const struct hecmwST_local_mesh *mesh, FILE *fp) {
12 if (mesh == NULL) return;
13 if (fp == NULL) return;
14
15 fprintf(fp, "FLAGS:\n");
16 fprintf(fp, "hecmw_flag_adapt: %d\n", mesh->hecmw_flag_adapt);
17 fprintf(fp, "hecmw_flag_initcon: %d\n", mesh->hecmw_flag_initcon);
18 fprintf(fp, "hecmw_flag_parttype: %d\n", mesh->hecmw_flag_parttype);
19 fprintf(fp, "hecmw_flag_version: %d\n", mesh->hecmw_flag_version);
20 fprintf(fp, "hecmw_flag_partcontact: %d\n", mesh->hecmw_flag_partcontact);
21 fprintf(fp, "END of FLAGS\n");
22}
23
24void HECMW_dist_print_header(const struct hecmwST_local_mesh *mesh, FILE *fp) {
25 if (mesh == NULL) return;
26 if (fp == NULL) return;
27
28 fprintf(fp, "HEADER:\n");
29 fprintf(fp, "%s\n", mesh->header);
30 fprintf(fp, "END of HEADER\n");
31}
32
34 FILE *fp) {
35 if (mesh == NULL) return;
36 if (fp == NULL) return;
37
38 fprintf(fp, "GRIDFILE:\n");
39 fprintf(fp, "%s\n", mesh->gridfile);
40 fprintf(fp, "END of GRIDFILE\n");
41}
42
43void HECMW_dist_print_files(const struct hecmwST_local_mesh *mesh, FILE *fp) {
44 int i;
45
46 if (mesh == NULL) return;
47 if (fp == NULL) return;
48
49 fprintf(fp, "FILES:\n");
50 fprintf(fp, "hecmw_n_file: %d\n", mesh->hecmw_n_file);
51 for (i = 0; mesh->files && i < mesh->hecmw_n_file; i++) {
52 fprintf(fp, "%s\n", mesh->files[i]);
53 }
54 fprintf(fp, "END of FILES\n");
55}
56
58 FILE *fp) {
59 if (mesh == NULL) return;
60 if (fp == NULL) return;
61
62 fprintf(fp, "ZERO:\n");
63 fprintf(fp, "%E\n", mesh->zero_temp);
64 fprintf(fp, "END of ZERO\n");
65}
66
67void HECMW_dist_print_node(const struct hecmwST_local_mesh *mesh, FILE *fp) {
68 int i;
69 const int NITEM = 10;
70
71 if (mesh == NULL) return;
72 if (fp == NULL) return;
73
74 fprintf(fp, "NODE:\n");
75 fprintf(fp, "n_node: %d\n", mesh->n_node);
76 fprintf(fp, "n_node_gross: %d\n", mesh->n_node_gross);
77 fprintf(fp, "nn_middle: %d\n", mesh->nn_middle);
78 fprintf(fp, "nn_internal: %d\n", mesh->nn_internal);
79
80 fprintf(fp, "node_internal_list:%s\n",
81 mesh->node_internal_list ? "" : " NULL");
82 for (i = 0; mesh->node_internal_list && i < mesh->nn_internal; i++) {
83 if (i != 0 && i % NITEM == 0) {
84 fprintf(fp, "\n");
85 }
86 fprintf(fp, "%d ", mesh->node_internal_list[i]);
87 }
88 fprintf(fp, "\n");
89
90 fprintf(fp, "node_ID:%s\n", mesh->node_ID ? "" : " NULL");
91 for (i = 0; mesh->node_ID && i < mesh->n_node; i++) {
92 if (i != 0 && i % NITEM == 0) {
93 fprintf(fp, "\n");
94 }
95 fprintf(fp, "%d %d ", mesh->node_ID[i * 2], mesh->node_ID[i * 2 + 1]);
96 }
97 fprintf(fp, "\n");
98
99 fprintf(fp, "global_node_ID:%s\n", mesh->global_node_ID ? "" : " NULL");
100 for (i = 0; mesh->global_node_ID && i < mesh->n_node; i++) {
101 if (i != 0 && i % NITEM == 0) {
102 fprintf(fp, "\n");
103 }
104 fprintf(fp, "%d ", mesh->global_node_ID[i]);
105 }
106 fprintf(fp, "\n");
107
108 fprintf(fp, "node:%s\n", mesh->node ? "" : " NULL");
109 for (i = 0; mesh->node && i < mesh->n_node; i++) {
110 fprintf(fp, "%E %E %E\n", mesh->node[i * 3], mesh->node[i * 3 + 1],
111 mesh->node[i * 3 + 2]);
112 }
113
114 fprintf(fp, "n_dof: %d\n", mesh->n_dof);
115 fprintf(fp, "n_dof_grp: %d\n", mesh->n_dof_grp);
116 fprintf(fp, "n_dof_tot: %d\n", mesh->n_dof_tot);
117
118 fprintf(fp, "node_dof_index:%s\n", mesh->node_dof_index ? "" : " NULL");
119 for (i = 0; mesh->node_dof_index && i <= mesh->n_dof_grp; i++) {
120 if (i != 0 && i % NITEM == 0) {
121 fprintf(fp, "\n");
122 }
123 fprintf(fp, "%d ", mesh->node_dof_index[i]);
124 }
125 fprintf(fp, "\n");
126
127 fprintf(fp, "node_dof_item:%s\n", mesh->node_dof_item ? "" : " NULL");
128 for (i = 0;
130 i++) {
131 if (i != 0 && i % NITEM == 0) {
132 fprintf(fp, "\n");
133 }
134 fprintf(fp, "%d ", mesh->node_dof_item[i]);
135 }
136 fprintf(fp, "\n");
137
138 fprintf(fp, "node_val_index:%s\n", mesh->node_val_index ? "" : " NULL");
139 for (i = 0; mesh->node_val_index && i <= mesh->n_node; i++) {
140 if (i != 0 && i % NITEM == 0) {
141 fprintf(fp, "\n");
142 }
143 fprintf(fp, "%d ", mesh->node_val_index[i]);
144 }
145 fprintf(fp, "\n");
146
147 fprintf(fp, "node_val_item:%s\n", mesh->node_val_item ? "" : " NULL");
148 for (i = 0; mesh->node_val_index && mesh->node_val_item &&
150 i++) {
151 if (i != 0 && i % (NITEM / 2) == 0) {
152 fprintf(fp, "\n");
153 }
154 fprintf(fp, "%E ", mesh->node_val_item[i]);
155 }
156 fprintf(fp, "\n");
157
158 fprintf(fp, "node_init_val_index:%s\n",
159 mesh->node_init_val_index ? "" : " NULL");
160 for (i = 0; mesh->node_init_val_index && i <= mesh->n_node; i++) {
161 if (i != 0 && i % NITEM == 0) {
162 fprintf(fp, "\n");
163 }
164 fprintf(fp, "%d ", mesh->node_init_val_index[i]);
165 }
166 fprintf(fp, "\n");
167
168 fprintf(fp, "node_init_val_item:%s\n",
169 mesh->node_init_val_item ? "" : " NULL");
172 i++) {
173 if (i != 0 && i % (NITEM / 2) == 0) {
174 fprintf(fp, "\n");
175 }
176 fprintf(fp, "%E ", mesh->node_init_val_item[i]);
177 }
178 fprintf(fp, "\n");
179
180 fprintf(fp, "END of NODE\n");
181}
182
183void HECMW_dist_print_elem(const struct hecmwST_local_mesh *mesh, FILE *fp) {
184 int i;
185 const int NITEM = 10;
186
187 if (mesh == NULL) return;
188 if (fp == NULL) return;
189
190 fprintf(fp, "ELEMENT:\n");
191
192 fprintf(fp, "n_elem: %d\n", mesh->n_elem);
193 fprintf(fp, "ne_internal: %d\n", mesh->ne_internal);
194
195 fprintf(fp, "elem_internal_list:%s\n",
196 mesh->elem_internal_list ? "" : " NULL");
197 for (i = 0; mesh->elem_internal_list && i < mesh->ne_internal; i++) {
198 if (i != 0 && i % NITEM == 0) {
199 fprintf(fp, "\n");
200 }
201 fprintf(fp, "%d ", mesh->elem_internal_list[i]);
202 }
203 fprintf(fp, "\n");
204
205 fprintf(fp, "elem_ID:%s\n", mesh->elem_ID ? "" : " NULL");
206 for (i = 0; mesh->elem_ID && i < mesh->n_elem; i++) {
207 if (i != 0 && i % NITEM == 0) {
208 fprintf(fp, "\n");
209 }
210 fprintf(fp, "%d %d ", mesh->elem_ID[2 * i], mesh->elem_ID[2 * i + 1]);
211 }
212 fprintf(fp, "\n");
213
214 fprintf(fp, "global_elem_ID:%s\n", mesh->global_elem_ID ? "" : " NULL");
215 for (i = 0; mesh->global_elem_ID && i < mesh->n_elem; i++) {
216 if (i != 0 && i % NITEM == 0) {
217 fprintf(fp, "\n");
218 }
219 fprintf(fp, "%d ", mesh->global_elem_ID[i]);
220 }
221 fprintf(fp, "\n");
222
223 fprintf(fp, "elem_type:%s\n", mesh->elem_type ? "" : " NULL");
224 for (i = 0; mesh->elem_type && i < mesh->n_elem; i++) {
225 if (i != 0 && i % NITEM == 0) {
226 fprintf(fp, "\n");
227 }
228 fprintf(fp, "%d ", mesh->elem_type[i]);
229 }
230 fprintf(fp, "\n");
231
232 fprintf(fp, "n_elem_type: %d\n", mesh->n_elem_type);
233
234 fprintf(fp, "elem_type_index:%s\n", mesh->elem_type_index ? "" : " NULL");
235 for (i = 0; mesh->elem_type_index && i <= mesh->n_elem_type; i++) {
236 if (i != 0 && i % NITEM == 0) {
237 fprintf(fp, "\n");
238 }
239 fprintf(fp, "%d ", mesh->elem_type_index[i]);
240 }
241 fprintf(fp, "\n");
242
243 fprintf(fp, "elem_type_item:%s\n", mesh->elem_type_item ? "" : " NULL");
244 for (i = 0;
246 i++) {
247 if (i != 0 && i % NITEM == 0) {
248 fprintf(fp, "\n");
249 }
250 fprintf(fp, "%d ", mesh->elem_type_item[i]);
251 }
252 fprintf(fp, "\n");
253
254 fprintf(fp, "elem_node_index:%s\n", mesh->elem_node_index ? "" : " NULL");
255 for (i = 0; mesh->elem_node_index && i <= mesh->n_elem; i++) {
256 if (i != 0 && i % NITEM == 0) {
257 fprintf(fp, "\n");
258 }
259 fprintf(fp, "%d ", mesh->elem_node_index[i]);
260 }
261 fprintf(fp, "\n");
262
263 fprintf(fp, "elem_node_item:%s\n", mesh->elem_node_item ? "" : " NULL");
264 for (i = 0; mesh->elem_node_index && mesh->elem_node_item &&
266 i++) {
267 if (i != 0 && i % NITEM == 0) {
268 fprintf(fp, "\n");
269 }
270 fprintf(fp, "%d ", mesh->elem_node_item[i]);
271 }
272 fprintf(fp, "\n");
273
274 fprintf(fp, "section_ID:%s\n", mesh->section_ID ? "" : " NULL");
275 for (i = 0; mesh->section_ID && i < mesh->n_elem; i++) {
276 if (i != 0 && i % NITEM == 0) {
277 fprintf(fp, "\n");
278 }
279 fprintf(fp, "%d ", mesh->section_ID[i]);
280 }
281 fprintf(fp, "\n");
282
283 fprintf(fp, "n_elem_mat_ID:%d\n", mesh->n_elem_mat_ID);
284
285 fprintf(fp, "elem_mat_ID_index:%s\n", mesh->elem_mat_ID_index ? "" : " NULL");
286 for (i = 0; mesh->elem_mat_ID_index && i <= mesh->n_elem; i++) {
287 if (i != 0 && i % NITEM == 0) {
288 fprintf(fp, "\n");
289 }
290 fprintf(fp, "%d ", mesh->elem_mat_ID_index[i]);
291 }
292 fprintf(fp, "\n");
293
294 fprintf(fp, "elem_mat_ID_item:%s\n", mesh->elem_mat_ID_item ? "" : " NULL");
295 for (i = 0; mesh->elem_mat_ID_index && mesh->elem_mat_ID_item &&
297 i++) {
298 if (i != 0 && i % NITEM == 0) {
299 fprintf(fp, "\n");
300 }
301 fprintf(fp, "%d ", mesh->elem_mat_ID_item[i]);
302 }
303 fprintf(fp, "\n");
304
305 fprintf(fp, "elem_mat_int_index:%s\n",
306 mesh->elem_mat_int_index ? "" : " NULL");
307 for (i = 0; mesh->elem_mat_int_index && i <= mesh->n_elem; i++) {
308 if (i != 0 && i % NITEM == 0) {
309 fprintf(fp, "\n");
310 }
311 fprintf(fp, "%d ", mesh->elem_mat_int_index[i]);
312 }
313 fprintf(fp, "\n");
314
315 fprintf(fp, "elem_mat_int_val:%s\n", mesh->elem_mat_int_val ? "" : " NULL");
316 for (i = 0; mesh->elem_mat_int_index && mesh->elem_mat_int_val &&
318 i++) {
319 if (i != 0 && i % (NITEM / 2) == 0) {
320 fprintf(fp, "\n");
321 }
322 fprintf(fp, "%E ", mesh->elem_mat_int_val[i]);
323 }
324 fprintf(fp, "\n");
325
326 fprintf(fp, "elem_val_index:%s\n", mesh->elem_val_index ? "" : " NULL");
327 for (i = 0; mesh->elem_val_index && i <= mesh->n_elem; i++) {
328 if (i != 0 && i % NITEM == 0) {
329 fprintf(fp, "\n");
330 }
331 fprintf(fp, "%d ", mesh->elem_val_index[i]);
332 }
333 fprintf(fp, "\n");
334
335 fprintf(fp, "elem_val_item:%s\n", mesh->elem_val_item ? "" : " NULL");
336 for (i = 0; mesh->elem_val_index && mesh->elem_val_item &&
338 i++) {
339 if (i != 0 && i % (NITEM / 2) == 0) {
340 fprintf(fp, "\n");
341 }
342 fprintf(fp, "%E ", mesh->elem_val_item[i]);
343 }
344 fprintf(fp, "\n");
345
346 fprintf(fp, "END of ELEMENT\n");
347}
348
349void HECMW_dist_print_pe(const struct hecmwST_local_mesh *mesh, FILE *fp) {
350 int i;
351 const int NITEM = 10;
352
353 if (mesh == NULL) return;
354 if (fp == NULL) return;
355
356 fprintf(fp, "PE:\n");
357
358 fprintf(fp, "zero: %d\n", mesh->zero);
359 fprintf(fp, "HECMW_COMM: %ld\n", (long)mesh->HECMW_COMM);
360 fprintf(fp, "PETOT: %d\n", mesh->PETOT);
361 fprintf(fp, "PEsmpTOT: %d\n", mesh->PEsmpTOT);
362 fprintf(fp, "my_rank: %d\n", mesh->my_rank);
363 fprintf(fp, "errnof: %d\n", mesh->errnof);
364 fprintf(fp, "n_subdomain: %d\n", mesh->n_subdomain);
365 fprintf(fp, "n_neighbor_pe: %d\n", mesh->n_neighbor_pe);
366
367 fprintf(fp, "neighbor_pe:%s\n", mesh->neighbor_pe ? "" : " NULL");
368 for (i = 0; mesh->neighbor_pe && i < mesh->n_neighbor_pe; i++) {
369 if (i != 0 && i % NITEM == 0) {
370 fprintf(fp, "\n");
371 }
372 fprintf(fp, "%d ", mesh->neighbor_pe[i]);
373 }
374 fprintf(fp, "\n");
375
376 fprintf(fp, "import_index:%s\n", mesh->import_index ? "" : " NULL");
377 for (i = 0; mesh->import_index && i <= mesh->n_neighbor_pe; i++) {
378 if (i != 0 && i % NITEM == 0) {
379 fprintf(fp, "\n");
380 }
381 fprintf(fp, "%d ", mesh->import_index[i]);
382 }
383 fprintf(fp, "\n");
384
385 fprintf(fp, "import_item:%s\n", mesh->import_item ? "" : " NULL");
386 for (i = 0; mesh->import_index && mesh->import_item &&
388 i++) {
389 if (i != 0 && i % NITEM == 0) {
390 fprintf(fp, "\n");
391 }
392 fprintf(fp, "%d ", mesh->import_item[i]);
393 }
394 fprintf(fp, "\n");
395
396 fprintf(fp, "export_index:%s\n", mesh->export_index ? "" : " NULL");
397 for (i = 0; mesh->export_index && i <= mesh->n_neighbor_pe; i++) {
398 if (i != 0 && i % NITEM == 0) {
399 fprintf(fp, "\n");
400 }
401 fprintf(fp, "%d ", mesh->export_index[i]);
402 }
403 fprintf(fp, "\n");
404
405 fprintf(fp, "export_item:%s\n", mesh->export_item ? "" : " NULL");
406 for (i = 0; mesh->export_index && mesh->export_item &&
408 i++) {
409 if (i != 0 && i % NITEM == 0) {
410 fprintf(fp, "\n");
411 }
412 fprintf(fp, "%d ", mesh->export_item[i]);
413 }
414 fprintf(fp, "\n");
415
416 fprintf(fp, "shared_index:%s\n", mesh->shared_index ? "" : " NULL");
417 for (i = 0; mesh->shared_index && i <= mesh->n_neighbor_pe; i++) {
418 if (i != 0 && i % NITEM == 0) {
419 fprintf(fp, "\n");
420 }
421 fprintf(fp, "%d ", mesh->shared_index[i]);
422 }
423 fprintf(fp, "\n");
424
425 fprintf(fp, "shared_item:%s\n", mesh->shared_item ? "" : " NULL");
426 for (i = 0; mesh->shared_index && mesh->shared_item &&
428 i++) {
429 if (i != 0 && i % NITEM == 0) {
430 fprintf(fp, "\n");
431 }
432 fprintf(fp, "%d ", mesh->shared_item[i]);
433 }
434 fprintf(fp, "\n");
435
436 fprintf(fp, "END of PE\n");
437}
438
439void HECMW_dist_print_adapt(const struct hecmwST_local_mesh *mesh, FILE *fp) {
440 int i;
441 const int NITEM = 10;
442
443 if (mesh == NULL) return;
444 if (fp == NULL) return;
445
446 fprintf(fp, "ADAPTATION:\n");
447
448 fprintf(fp, "coarse_grid_level: %d\n", mesh->coarse_grid_level);
449 fprintf(fp, "n_adapt: %d\n", mesh->n_adapt);
450
451 fprintf(fp, "when_i_was_refined_node:%s\n",
452 mesh->when_i_was_refined_node ? "" : " NULL");
453 for (i = 0; mesh->when_i_was_refined_node && i < mesh->n_node; i++) {
454 if (i != 0 && i % NITEM == 0) {
455 fprintf(fp, "\n");
456 }
457 fprintf(fp, "%d ", mesh->when_i_was_refined_node[i]);
458 }
459 fprintf(fp, "\n");
460
461 fprintf(fp, "when_i_was_refined_elem:%s\n",
462 mesh->when_i_was_refined_elem ? "" : " NULL");
463 for (i = 0; mesh->when_i_was_refined_elem && i < mesh->n_elem; i++) {
464 if (i != 0 && i % NITEM == 0) {
465 fprintf(fp, "\n");
466 }
467 fprintf(fp, "%d ", mesh->when_i_was_refined_elem[i]);
468 }
469 fprintf(fp, "\n");
470
471 fprintf(fp, "adapt_parent_type:%s\n", mesh->adapt_parent_type ? "" : " NULL");
472 for (i = 0; mesh->adapt_parent_type && i < mesh->n_elem; i++) {
473 if (i != 0 && i % NITEM == 0) {
474 fprintf(fp, "\n");
475 }
476 fprintf(fp, "%d ", mesh->adapt_parent_type[i]);
477 }
478 fprintf(fp, "\n");
479
480 fprintf(fp, "adapt_type:%s\n", mesh->adapt_type ? "" : " NULL");
481 for (i = 0; mesh->adapt_type && i < mesh->n_elem; i++) {
482 if (i != 0 && i % NITEM == 0) {
483 fprintf(fp, "\n");
484 }
485 fprintf(fp, "%d ", mesh->adapt_type[i]);
486 }
487 fprintf(fp, "\n");
488
489 fprintf(fp, "adapt_level:%s\n", mesh->adapt_level ? "" : " NULL");
490 for (i = 0; mesh->adapt_level && i < mesh->n_elem; i++) {
491 if (i != 0 && i % NITEM == 0) {
492 fprintf(fp, "\n");
493 }
494 fprintf(fp, "%d ", mesh->adapt_level[i]);
495 }
496 fprintf(fp, "\n");
497
498 fprintf(fp, "adapt_parent:%s\n", mesh->adapt_parent ? "" : " NULL");
499 for (i = 0; mesh->adapt_parent && i < mesh->n_elem; i++) {
500 if (i != 0 && i % NITEM == 0) {
501 fprintf(fp, "\n");
502 }
503 fprintf(fp, "%d %d ", mesh->adapt_parent[2 * i],
504 mesh->adapt_parent[2 * i + 1]);
505 }
506 fprintf(fp, "\n");
507
508 fprintf(fp, "adapt_children_index:%s\n",
509 mesh->adapt_children_index ? "" : " NULL");
510 for (i = 0; mesh->adapt_children_index && i <= mesh->n_elem; i++) {
511 if (i != 0 && i % NITEM == 0) {
512 fprintf(fp, "\n");
513 }
514 fprintf(fp, "%d ", mesh->adapt_children_index[i]);
515 }
516 fprintf(fp, "\n");
517
518 fprintf(fp, "adapt_children_item:%s\n",
519 mesh->adapt_children_index ? "" : " NULL");
522 i++) {
523 if (i != 0 && i % NITEM == 0) {
524 fprintf(fp, "\n");
525 }
526 fprintf(fp, "%d %d ", mesh->adapt_children_item[2 * i],
527 mesh->adapt_children_item[2 * i + 1]);
528 }
529 fprintf(fp, "\n");
530
531 fprintf(fp, "END of ADAPTATION:\n");
532}
533
534void HECMW_dist_print_section(const struct hecmwST_section *sect, FILE *fp) {
535 int i;
536 const int NITEM = 10;
537
538 if (fp == NULL) return;
539
540 fprintf(fp, "SECTION:%s\n", sect ? "" : " NULL");
541 if (sect == NULL) return;
542
543 fprintf(fp, "n_sect: %d\n", sect->n_sect);
544
545 fprintf(fp, "sect_type:%s\n", sect->sect_type ? "" : " NULL");
546 for (i = 0; sect->sect_type && i < sect->n_sect; i++) {
547 if (i != 0 && i % NITEM == 0) {
548 fprintf(fp, "\n");
549 }
550 fprintf(fp, "%d ", sect->sect_type[i]);
551 }
552 fprintf(fp, "\n");
553
554 fprintf(fp, "sect_opt:%s\n", sect->sect_opt ? "" : " NULL");
555 for (i = 0; sect->sect_opt && i < sect->n_sect; i++) {
556 if (i != 0 && i % NITEM == 0) {
557 fprintf(fp, "\n");
558 }
559 fprintf(fp, "%d ", sect->sect_opt[i]);
560 }
561 fprintf(fp, "\n");
562
563 fprintf(fp, "sect_mat_ID_index:%s\n", sect->sect_mat_ID_index ? "" : " NULL");
564 for (i = 0; sect->sect_mat_ID_index && i <= sect->n_sect; i++) {
565 if (i != 0 && i % NITEM == 0) {
566 fprintf(fp, "\n");
567 }
568 fprintf(fp, "%d ", sect->sect_mat_ID_index[i]);
569 }
570 fprintf(fp, "\n");
571
572 fprintf(fp, "sect_mat_ID_item:%s\n", sect->sect_mat_ID_item ? "" : " NULL");
573 for (i = 0; sect->sect_mat_ID_index && sect->sect_mat_ID_item &&
574 i < sect->sect_mat_ID_index[sect->n_sect];
575 i++) {
576 if (i != 0 && i % NITEM == 0) {
577 fprintf(fp, "\n");
578 }
579 fprintf(fp, "%d ", sect->sect_mat_ID_item[i]);
580 }
581 fprintf(fp, "\n");
582
583 fprintf(fp, "sect_I_index:%s\n", sect->sect_I_index ? "" : " NULL");
584 for (i = 0; sect->sect_I_index && i <= sect->n_sect; i++) {
585 if (i != 0 && i % NITEM == 0) {
586 fprintf(fp, "\n");
587 }
588 fprintf(fp, "%d ", sect->sect_I_index[i]);
589 }
590 fprintf(fp, "\n");
591
592 fprintf(fp, "sect_I_item:%s\n", sect->sect_I_item ? "" : " NULL");
593 for (i = 0; sect->sect_I_index && sect->sect_I_item &&
594 i < sect->sect_I_index[sect->n_sect];
595 i++) {
596 if (i != 0 && i % NITEM == 0) {
597 fprintf(fp, "\n");
598 }
599 fprintf(fp, "%d ", sect->sect_I_item[i]);
600 }
601 fprintf(fp, "\n");
602
603 fprintf(fp, "sect_R_index:%s\n", sect->sect_R_index ? "" : " NULL");
604 for (i = 0; sect->sect_R_index && i <= sect->n_sect; i++) {
605 if (i != 0 && i % NITEM == 0) {
606 fprintf(fp, "\n");
607 }
608 fprintf(fp, "%d ", sect->sect_R_index[i]);
609 }
610 fprintf(fp, "\n");
611
612 fprintf(fp, "sect_R_item:%s\n", sect->sect_R_item ? "" : " NULL");
613 for (i = 0; sect->sect_R_index && sect->sect_R_item &&
614 i < sect->sect_R_index[sect->n_sect];
615 i++) {
616 if (i != 0 && i % (NITEM / 2) == 0) {
617 fprintf(fp, "\n");
618 }
619 fprintf(fp, "%E ", sect->sect_R_item[i]);
620 }
621 fprintf(fp, "\n");
622
623 fprintf(fp, "END of SECTION\n");
624}
625
626void HECMW_dist_print_material(const struct hecmwST_material *material,
627 FILE *fp) {
628 int i;
629 const int NITEM = 10;
630
631 if (fp == NULL) return;
632
633 fprintf(fp, "MATERIAL:%s\n", material ? "" : " NULL");
634 if (material == NULL) return;
635
636 fprintf(fp, "n_mat: %d\n", material->n_mat);
637
638 fprintf(fp, "mat_name:%s\n", material->mat_name ? "" : " NULL");
639 for (i = 0; material->mat_name && i < material->n_mat; i++) {
640 fprintf(fp, "%s\n", material->mat_name[i]);
641 }
642
643 fprintf(fp, "n_mat_item: %d\n", material->n_mat_item);
644
645 fprintf(fp, "mat_item_index:%s\n", material->mat_item_index ? "" : " NULL");
646 for (i = 0; material->mat_item_index && i <= material->n_mat; i++) {
647 if (i != 0 && i % NITEM == 0) {
648 fprintf(fp, "\n");
649 }
650 fprintf(fp, "%d ", material->mat_item_index[i]);
651 }
652 fprintf(fp, "\n");
653
654 fprintf(fp, "n_mat_subitem: %d\n", material->n_mat_subitem);
655
656 fprintf(fp, "mat_subitem_index:%s\n",
657 material->mat_subitem_index ? "" : " NULL");
658 for (i = 0; material->mat_subitem_index && i <= material->n_mat_item; i++) {
659 if (i != 0 && i % NITEM == 0) {
660 fprintf(fp, "\n");
661 }
662 fprintf(fp, "%d ", material->mat_subitem_index[i]);
663 }
664 fprintf(fp, "\n");
665
666 fprintf(fp, "n_mat_table: %d\n", material->n_mat_table);
667
668 fprintf(fp, "mat_table_index:%s\n", material->mat_table_index ? "" : " NULL");
669 for (i = 0; material->mat_table_index && i <= material->n_mat_subitem; i++) {
670 if (i != 0 && i % NITEM == 0) {
671 fprintf(fp, "\n");
672 }
673 fprintf(fp, "%d ", material->mat_table_index[i]);
674 }
675 fprintf(fp, "\n");
676
677 fprintf(fp, "mat_val:%s\n", material->mat_val ? "" : " NULL");
678 for (i = 0; material->mat_table_index && material->mat_val &&
679 i < material->mat_table_index[material->n_mat_subitem];
680 i++) {
681 if (i != 0 && i % (NITEM / 2) == 0) {
682 fprintf(fp, "\n");
683 }
684 fprintf(fp, "%E ", material->mat_val[i]);
685 }
686 fprintf(fp, "\n");
687
688 fprintf(fp, "mat_temp:%s\n", material->mat_temp ? "" : " NULL");
689 for (i = 0; material->mat_temp && i < material->n_mat_table; i++) {
690 if (i != 0 && i % (NITEM / 2) == 0) {
691 fprintf(fp, "\n");
692 }
693 fprintf(fp, "%E ", material->mat_temp[i]);
694 }
695 fprintf(fp, "\n");
696
697 fprintf(fp, "END of MATERIAL\n");
698}
699
700void HECMW_dist_print_mpc(const struct hecmwST_mpc *mpc, FILE *fp) {
701 int i;
702 const int NITEM = 10;
703
704 if (fp == NULL) return;
705
706 fprintf(fp, "MPC:%s\n", mpc ? "" : " NULL");
707 if (mpc == NULL) return;
708
709 fprintf(fp, "n_mpc: %d\n", mpc->n_mpc);
710
711 fprintf(fp, "mpc_index:%s\n", mpc->mpc_index ? "" : " NULL");
712 for (i = 0; mpc->mpc_index && i <= mpc->n_mpc; i++) {
713 if (i != 0 && i % NITEM == 0) {
714 fprintf(fp, "\n");
715 }
716 fprintf(fp, "%d ", mpc->mpc_index[i]);
717 }
718 fprintf(fp, "\n");
719
720 fprintf(fp, "mpc_item:%s\n", mpc->mpc_item ? "" : " NULL");
721 for (i = 0; mpc->mpc_index && mpc->mpc_item && i < mpc->mpc_index[mpc->n_mpc];
722 i++) {
723 if (i != 0 && i % NITEM == 0) {
724 fprintf(fp, "\n");
725 }
726 fprintf(fp, "%d ", mpc->mpc_item[i]);
727 }
728 fprintf(fp, "\n");
729
730 fprintf(fp, "mpc_dof:%s\n", mpc->mpc_dof ? "" : " NULL");
731 for (i = 0; mpc->mpc_index && mpc->mpc_dof && i < mpc->mpc_index[mpc->n_mpc];
732 i++) {
733 if (i != 0 && i % NITEM == 0) {
734 fprintf(fp, "\n");
735 }
736 fprintf(fp, "%d ", mpc->mpc_dof[i]);
737 }
738 fprintf(fp, "\n");
739
740 fprintf(fp, "mpc_val:%s\n", mpc->mpc_val ? "" : " NULL");
741 for (i = 0; mpc->mpc_index && mpc->mpc_val && i < mpc->mpc_index[mpc->n_mpc];
742 i++) {
743 if (i != 0 && i % (NITEM / 2) == 0) {
744 fprintf(fp, "\n");
745 }
746 fprintf(fp, "%E ", mpc->mpc_val[i]);
747 }
748 fprintf(fp, "\n");
749
750 fprintf(fp, "END of MPC\n");
751}
752
753void HECMW_dist_print_amp(const struct hecmwST_amplitude *amp, FILE *fp) {
754 int i;
755 const int NITEM = 10;
756
757 if (fp == NULL) return;
758
759 fprintf(fp, "AMPLITUDE:%s\n", amp ? "" : " NULL");
760 if (amp == NULL) return;
761
762 fprintf(fp, "n_amp: %d\n", amp->n_amp);
763
764 fprintf(fp, "amp_name:%s\n", amp->amp_name ? "" : "NULL");
765 for (i = 0; amp->amp_name && i < amp->n_amp; i++) {
766 fprintf(fp, "%s\n", amp->amp_name[i]);
767 }
768
769 fprintf(fp, "amp_type_definition:%s\n",
770 amp->amp_type_definition ? "" : " NULL");
771 for (i = 0; amp->amp_type_definition && i < amp->n_amp; i++) {
772 if (i != 0 && i % NITEM == 0) {
773 fprintf(fp, "\n");
774 }
775 fprintf(fp, "%d ", amp->amp_type_definition[i]);
776 }
777 fprintf(fp, "\n");
778
779 fprintf(fp, "amp_type_time:%s\n", amp->amp_type_time ? "" : " NULL");
780 for (i = 0; amp->amp_type_time && i < amp->n_amp; i++) {
781 if (i != 0 && i % NITEM == 0) {
782 fprintf(fp, "\n");
783 }
784 fprintf(fp, "%d ", amp->amp_type_time[i]);
785 }
786 fprintf(fp, "\n");
787
788 fprintf(fp, "amp_type_value:%s\n", amp->amp_type_value ? "" : " NULL");
789 for (i = 0; amp->amp_type_value && i < amp->n_amp; i++) {
790 if (i != 0 && i % NITEM == 0) {
791 fprintf(fp, "\n");
792 }
793 fprintf(fp, "%d ", amp->amp_type_value[i]);
794 }
795 fprintf(fp, "\n");
796
797 fprintf(fp, "amp_index:%s\n", amp->amp_index ? "" : " NULL");
798 for (i = 0; amp->amp_index && i <= amp->n_amp; i++) {
799 if (i != 0 && i % NITEM == 0) {
800 fprintf(fp, "\n");
801 }
802 fprintf(fp, "%d ", amp->amp_index[i]);
803 }
804 fprintf(fp, "\n");
805
806 fprintf(fp, "amp_val:%s\n", amp->amp_val ? "" : " NULL");
807 for (i = 0; amp->amp_index && amp->amp_val && i < amp->amp_index[amp->n_amp];
808 i++) {
809 if (i != 0 && i % (NITEM / 2) == 0) {
810 fprintf(fp, "\n");
811 }
812 fprintf(fp, "%E ", amp->amp_val[i]);
813 }
814 fprintf(fp, "\n");
815
816 fprintf(fp, "amp_table:%s\n", amp->amp_table ? "" : " NULL");
817 for (i = 0;
818 amp->amp_index && amp->amp_table && i < amp->amp_index[amp->n_amp];
819 i++) {
820 if (i != 0 && i % (NITEM / 2) == 0) {
821 fprintf(fp, "\n");
822 }
823 fprintf(fp, "%E ", amp->amp_table[i]);
824 }
825 fprintf(fp, "\n");
826}
827
828void HECMW_dist_print_ngrp(const struct hecmwST_node_grp *ngrp, FILE *fp) {
829 int i;
830 const int NITEM = 10;
831
832 if (fp == NULL) return;
833
834 fprintf(fp, "NGROUP:%s\n", ngrp ? "" : " NULL");
835 if (ngrp == NULL) return;
836
837 fprintf(fp, "n_grp: %d\n", ngrp->n_grp);
838
839 fprintf(fp, "grp_name:%s\n", ngrp->grp_name ? "" : "NULL");
840 for (i = 0; i < ngrp->n_grp; i++) {
841 fprintf(fp, "%s\n", ngrp->grp_name[i]);
842 }
843
844 fprintf(fp, "grp_index:%s\n", ngrp->grp_index ? "" : " NULL");
845 for (i = 0; ngrp->grp_index && i <= ngrp->n_grp; i++) {
846 if (i != 0 && i % NITEM == 0) {
847 fprintf(fp, "\n");
848 }
849 fprintf(fp, "%d ", ngrp->grp_index[i]);
850 }
851 fprintf(fp, "\n");
852
853 fprintf(fp, "grp_item:%s\n", ngrp->grp_item ? "" : " NULL");
854 for (i = 0;
855 ngrp->grp_index && ngrp->grp_item && i < ngrp->grp_index[ngrp->n_grp];
856 i++) {
857 if (i != 0 && i % NITEM == 0) {
858 fprintf(fp, "\n");
859 }
860 fprintf(fp, "%d ", ngrp->grp_item[i]);
861 }
862 fprintf(fp, "\n");
863
864 fprintf(fp, "n_bc: %d\n", ngrp->n_bc);
865
866 fprintf(fp, "bc_grp_ID:%s\n", ngrp->bc_grp_ID ? "" : " NULL");
867 for (i = 0; ngrp->bc_grp_ID && i < ngrp->n_bc; i++) {
868 if (i != 0 && i % NITEM == 0) {
869 fprintf(fp, "\n");
870 }
871 fprintf(fp, "%d ", ngrp->bc_grp_ID[i]);
872 }
873 fprintf(fp, "\n");
874
875 fprintf(fp, "bc_grp_type:%s\n", ngrp->bc_grp_type ? "" : " NULL");
876 for (i = 0; ngrp->bc_grp_type && i < ngrp->n_bc; i++) {
877 if (i != 0 && i % NITEM == 0) {
878 fprintf(fp, "\n");
879 }
880 fprintf(fp, "%d ", ngrp->bc_grp_type[i]);
881 }
882 fprintf(fp, "\n");
883
884 fprintf(fp, "bc_grp_index:%s\n", ngrp->bc_grp_index ? "" : " NULL");
885 for (i = 0; ngrp->bc_grp_index && i <= ngrp->n_bc; i++) {
886 if (i != 0 && i % NITEM == 0) {
887 fprintf(fp, "\n");
888 }
889 fprintf(fp, "%d ", ngrp->bc_grp_index[i]);
890 }
891 fprintf(fp, "\n");
892
893 fprintf(fp, "bc_grp_dof:%s\n", ngrp->bc_grp_dof ? "" : " NULL");
894 for (i = 0; ngrp->bc_grp_index && ngrp->bc_grp_dof &&
895 i < ngrp->bc_grp_index[ngrp->n_bc];
896 i++) {
897 if (i != 0 && i % NITEM == 0) {
898 fprintf(fp, "\n");
899 }
900 fprintf(fp, "%d ", ngrp->bc_grp_dof[i]);
901 }
902 fprintf(fp, "\n");
903
904 fprintf(fp, "bc_grp_val:%s\n", ngrp->bc_grp_val ? "" : " NULL");
905 for (i = 0; ngrp->bc_grp_index && ngrp->bc_grp_val &&
906 i < ngrp->bc_grp_index[ngrp->n_bc];
907 i++) {
908 if (i != 0 && i % (NITEM / 2) == 0) {
909 fprintf(fp, "\n");
910 }
911 fprintf(fp, "%E ", ngrp->bc_grp_val[i]);
912 }
913 fprintf(fp, "\n");
914
915 fprintf(fp, "END of NGROUP\n");
916}
917
918void HECMW_dist_print_egrp(const struct hecmwST_elem_grp *egrp, FILE *fp) {
919 int i;
920 const int NITEM = 10;
921
922 if (fp == NULL) return;
923
924 fprintf(fp, "EGROUP:%s\n", egrp ? "" : " NULL");
925 if (egrp == NULL) return;
926
927 fprintf(fp, "n_grp: %d\n", egrp->n_grp);
928
929 fprintf(fp, "grp_name:%s\n", egrp->grp_name ? "" : "NULL");
930 for (i = 0; i < egrp->n_grp; i++) {
931 fprintf(fp, "%s\n", egrp->grp_name[i]);
932 }
933
934 fprintf(fp, "grp_index:%s\n", egrp->grp_index ? "" : " NULL");
935 for (i = 0; egrp->grp_index && i <= egrp->n_grp; i++) {
936 if (i != 0 && i % NITEM == 0) {
937 fprintf(fp, "\n");
938 }
939 fprintf(fp, "%d ", egrp->grp_index[i]);
940 }
941 fprintf(fp, "\n");
942
943 fprintf(fp, "grp_item:%s\n", egrp->grp_item ? "" : " NULL");
944 for (i = 0;
945 egrp->grp_index && egrp->grp_item && i < egrp->grp_index[egrp->n_grp];
946 i++) {
947 if (i != 0 && i % NITEM == 0) {
948 fprintf(fp, "\n");
949 }
950 fprintf(fp, "%d ", egrp->grp_item[i]);
951 }
952 fprintf(fp, "\n");
953
954 fprintf(fp, "n_bc: %d\n", egrp->n_bc);
955
956 fprintf(fp, "bc_grp_ID:%s\n", egrp->bc_grp_ID ? "" : " NULL");
957 for (i = 0; egrp->bc_grp_ID && i < egrp->n_bc; i++) {
958 if (i != 0 && i % NITEM == 0) {
959 fprintf(fp, "\n");
960 }
961 fprintf(fp, "%d ", egrp->bc_grp_ID[i]);
962 }
963 fprintf(fp, "\n");
964
965 fprintf(fp, "bc_grp_type:%s\n", egrp->bc_grp_type ? "" : " NULL");
966 for (i = 0; egrp->bc_grp_type && i < egrp->n_bc; i++) {
967 if (i != 0 && i % NITEM == 0) {
968 fprintf(fp, "\n");
969 }
970 fprintf(fp, "%d ", egrp->bc_grp_type[i]);
971 }
972 fprintf(fp, "\n");
973
974 fprintf(fp, "bc_grp_index:%s\n", egrp->bc_grp_index ? "" : " NULL");
975 for (i = 0; egrp->bc_grp_index && i <= egrp->n_bc; i++) {
976 if (i != 0 && i % NITEM == 0) {
977 fprintf(fp, "\n");
978 }
979 fprintf(fp, "%d ", egrp->bc_grp_index[i]);
980 }
981 fprintf(fp, "\n");
982
983 fprintf(fp, "bc_grp_val:%s\n", egrp->bc_grp_val ? "" : " NULL");
984 for (i = 0; egrp->bc_grp_index && egrp->bc_grp_val &&
985 i < egrp->bc_grp_index[egrp->n_bc];
986 i++) {
987 if (i != 0 && i % (NITEM / 2) == 0) {
988 fprintf(fp, "\n");
989 }
990 fprintf(fp, "%E ", egrp->bc_grp_val[i]);
991 }
992 fprintf(fp, "\n");
993
994 fprintf(fp, "END of EGROUP\n");
995}
996
997void HECMW_dist_print_sgrp(const struct hecmwST_surf_grp *sgrp, FILE *fp) {
998 int i;
999 const int NITEM = 10;
1000
1001 if (fp == NULL) return;
1002
1003 fprintf(fp, "SGROUP:%s\n", sgrp ? "" : " NULL");
1004 if (sgrp == NULL) return;
1005
1006 fprintf(fp, "n_grp: %d\n", sgrp->n_grp);
1007
1008 fprintf(fp, "grp_name:%s\n", sgrp->grp_name ? "" : "NULL");
1009 for (i = 0; i < sgrp->n_grp; i++) {
1010 fprintf(fp, "%s\n", sgrp->grp_name[i]);
1011 }
1012
1013 fprintf(fp, "grp_index:%s\n", sgrp->grp_index ? "" : " NULL");
1014 for (i = 0; sgrp->grp_index && i <= sgrp->n_grp; i++) {
1015 if (i != 0 && i % NITEM == 0) {
1016 fprintf(fp, "\n");
1017 }
1018 fprintf(fp, "%d ", sgrp->grp_index[i]);
1019 }
1020 fprintf(fp, "\n");
1021
1022 fprintf(fp, "grp_item:%s\n", sgrp->grp_item ? "" : " NULL");
1023 for (i = 0; sgrp->grp_index && sgrp->grp_item &&
1024 i < sgrp->grp_index[sgrp->n_grp] * 2;
1025 i++) {
1026 if (i != 0 && i % NITEM == 0) {
1027 fprintf(fp, "\n");
1028 }
1029 fprintf(fp, "%d ", sgrp->grp_item[i]);
1030 }
1031 fprintf(fp, "\n");
1032
1033 fprintf(fp, "n_bc: %d\n", sgrp->n_bc);
1034
1035 fprintf(fp, "bc_grp_ID:%s\n", sgrp->bc_grp_ID ? "" : " NULL");
1036 for (i = 0; sgrp->bc_grp_ID && i < sgrp->n_bc; i++) {
1037 if (i != 0 && i % NITEM == 0) {
1038 fprintf(fp, "\n");
1039 }
1040 fprintf(fp, "%d ", sgrp->bc_grp_ID[i]);
1041 }
1042 fprintf(fp, "\n");
1043
1044 fprintf(fp, "bc_grp_type:%s\n", sgrp->bc_grp_type ? "" : " NULL");
1045 for (i = 0; sgrp->bc_grp_type && i < sgrp->n_bc; i++) {
1046 if (i != 0 && i % NITEM == 0) {
1047 fprintf(fp, "\n");
1048 }
1049 fprintf(fp, "%d ", sgrp->bc_grp_type[i]);
1050 }
1051 fprintf(fp, "\n");
1052
1053 fprintf(fp, "bc_grp_index:%s\n", sgrp->bc_grp_index ? "" : " NULL");
1054 for (i = 0; sgrp->bc_grp_index && i <= sgrp->n_bc; i++) {
1055 if (i != 0 && i % NITEM == 0) {
1056 fprintf(fp, "\n");
1057 }
1058 fprintf(fp, "%d ", sgrp->bc_grp_index[i]);
1059 }
1060 fprintf(fp, "\n");
1061
1062 fprintf(fp, "bc_grp_val:%s\n", sgrp->bc_grp_val ? "" : " NULL");
1063 for (i = 0; sgrp->bc_grp_index && sgrp->bc_grp_val &&
1064 i < sgrp->bc_grp_index[sgrp->n_bc];
1065 i++) {
1066 if (i != 0 && i % (NITEM / 2) == 0) {
1067 fprintf(fp, "\n");
1068 }
1069 fprintf(fp, "%E ", sgrp->bc_grp_val[i]);
1070 }
1071 fprintf(fp, "\n");
1072
1073 fprintf(fp, "END of SGROUP\n");
1074}
1075
1076void HECMW_dist_print(const struct hecmwST_local_mesh *mesh, FILE *fp) {
1078 fprintf(fp, "\n");
1080 fprintf(fp, "\n");
1082 fprintf(fp, "\n");
1084 fprintf(fp, "\n");
1086 fprintf(fp, "\n");
1088 fprintf(fp, "\n");
1090 fprintf(fp, "\n");
1092 fprintf(fp, "\n");
1094 fprintf(fp, "\n");
1096 fprintf(fp, "\n");
1098 fprintf(fp, "\n");
1100 fprintf(fp, "\n");
1102 fprintf(fp, "\n");
1104 fprintf(fp, "\n");
1106 fprintf(fp, "\n");
1108 fprintf(fp, "\n");
1109}
void HECMW_dist_print_gridfile(const struct hecmwST_local_mesh *mesh, FILE *fp)
void HECMW_dist_print(const struct hecmwST_local_mesh *mesh, FILE *fp)
void HECMW_dist_print_material(const struct hecmwST_material *material, FILE *fp)
void HECMW_dist_print_zero_temp(const struct hecmwST_local_mesh *mesh, FILE *fp)
void HECMW_dist_print_header(const struct hecmwST_local_mesh *mesh, FILE *fp)
void HECMW_dist_print_section(const struct hecmwST_section *sect, FILE *fp)
void HECMW_dist_print_node(const struct hecmwST_local_mesh *mesh, FILE *fp)
void HECMW_dist_print_elem(const struct hecmwST_local_mesh *mesh, FILE *fp)
void HECMW_dist_print_ngrp(const struct hecmwST_node_grp *ngrp, FILE *fp)
void HECMW_dist_print_files(const struct hecmwST_local_mesh *mesh, FILE *fp)
void HECMW_dist_print_amp(const struct hecmwST_amplitude *amp, FILE *fp)
void HECMW_dist_print_flags(const struct hecmwST_local_mesh *mesh, FILE *fp)
void HECMW_dist_print_mpc(const struct hecmwST_mpc *mpc, FILE *fp)
void HECMW_dist_print_egrp(const struct hecmwST_elem_grp *egrp, FILE *fp)
void HECMW_dist_print_pe(const struct hecmwST_local_mesh *mesh, FILE *fp)
void HECMW_dist_print_sgrp(const struct hecmwST_surf_grp *sgrp, FILE *fp)
void HECMW_dist_print_adapt(const struct hecmwST_local_mesh *mesh, FILE *fp)
struct hecmwST_local_mesh * mesh
Definition: hecmw_repart.h:71
#define NULL
int * amp_type_definition
Definition: hecmw_struct.h:61
double * amp_table
Definition: hecmw_struct.h:72
double * bc_grp_val
Definition: hecmw_struct.h:103
struct hecmwST_section * section
Definition: hecmw_struct.h:244
double * elem_val_item
Definition: hecmw_struct.h:204
double * elem_mat_int_val
Definition: hecmw_struct.h:202
struct hecmwST_amplitude * amp
Definition: hecmw_struct.h:247
struct hecmwST_material * material
Definition: hecmw_struct.h:245
double * node_val_item
Definition: hecmw_struct.h:177
struct hecmwST_mpc * mpc
Definition: hecmw_struct.h:246
struct hecmwST_node_grp * node_group
Definition: hecmw_struct.h:248
double * node_init_val_item
Definition: hecmw_struct.h:180
struct hecmwST_surf_grp * surf_group
Definition: hecmw_struct.h:250
char gridfile[HECMW_FILENAME_LEN+1]
Definition: hecmw_struct.h:153
char header[HECMW_HEADER_LEN+1]
Definition: hecmw_struct.h:156
HECMW_Comm HECMW_COMM
Definition: hecmw_struct.h:208
struct hecmwST_elem_grp * elem_group
Definition: hecmw_struct.h:249
int * when_i_was_refined_node
Definition: hecmw_struct.h:226
int * when_i_was_refined_elem
Definition: hecmw_struct.h:227
int * mat_subitem_index
Definition: hecmw_struct.h:42
double * mat_val
Definition: hecmw_struct.h:44
double * mat_temp
Definition: hecmw_struct.h:45
int * mpc_dof
Definition: hecmw_struct.h:52
double * mpc_val
Definition: hecmw_struct.h:53
int * mpc_index
Definition: hecmw_struct.h:50
int * mpc_item
Definition: hecmw_struct.h:51
double * bc_grp_val
Definition: hecmw_struct.h:89
double * sect_R_item
Definition: hecmw_struct.h:32
int * sect_mat_ID_index
Definition: hecmw_struct.h:27
int * sect_mat_ID_item
Definition: hecmw_struct.h:28
double * bc_grp_val
Definition: hecmw_struct.h:118