FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
hecmw_io_geofem.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 <string.h>
9#include <errno.h>
10#include "hecmw_util.h"
11#include "hecmw_common.h"
12#include "hecmw_gflex.h"
13#include "hecmw_io_mesh.h"
14
15static char grid_filename[HECMW_FILENAME_LEN + 1] = "Unknown";
16
17/*----------------------------------------------------------------------------*/
18
19static void do_logging(int loglv, int msgno, int add_location, const char *fmt,
20 va_list ap) {
21 char line[100] = "";
22 char msg[HECMW_MSG_LEN + 1];
23
24 HECMW_vsnprintf(msg, sizeof(msg), fmt, ap);
25 if (add_location) {
26 char *s = "";
27 if (strlen(msg) > 0) s = ": ";
28 HECMW_snprintf(line, sizeof(line), "%s:%d%s", grid_filename,
30 }
31 if (loglv == HECMW_LOG_ERROR) {
32 HECMW_set_error(msgno, "%s%s", line, msg);
33 } else {
34 HECMW_print_msg(loglv, msgno, "%s%s", line, msg);
35 }
36}
37
38static void set_err(int msgno, const char *fmt, ...) {
39 va_list ap;
40
41 va_start(ap, fmt);
42 do_logging(HECMW_LOG_ERROR, msgno, 1, fmt, ap);
43 va_end(ap);
44}
45
46static void set_err_token(int token, int msgno, const char *fmt, ...) {
47 int msg_no;
48 va_list ap;
49
50 if (!token) {
51 msg_no = HECMW_IO_GEOFEM_E0003;
52 } else {
53 msg_no = msgno;
54 }
55 va_start(ap, fmt);
56 do_logging(HECMW_LOG_ERROR, msg_no, 1, fmt, ap);
57 va_end(ap);
58}
59
60/*-----------------------------------------------------------------------------
61 * read functions
62 */
63
64static int read_pe(void) {
65 int token, n_neighbor_pe;
66
67 /* PE-ID */
69 if (token != HECMW_GFLEX_INT) {
70 set_err_token(token, HECMW_IO_GEOFEM_E0004, "PE-ID required");
71 return -1;
72 }
73
74 /* NEIBPEtot */
76 if (token != HECMW_GFLEX_INT) {
77 set_err_token(token, HECMW_IO_GEOFEM_E0004, "NEIBOEtot required");
78 return -1;
79 }
80 n_neighbor_pe = HECMW_gflex_get_number();
81 if (n_neighbor_pe < 0) {
82 set_err(HECMW_IO_GEOFEM_E0301, "");
83 return -1;
84 }
85 if (n_neighbor_pe != 0) {
86 set_err(HECMW_IO_GEOFEM_E0301, "");
87 return -1;
88 }
89
90 token = HECMW_gflex_next_token();
91 if (token != HECMW_GFLEX_NL) {
92 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
93 return -1;
94 }
95
96 /* ESSENTIAL BLANK LINE */
97 token = HECMW_gflex_next_token();
98 if (token != HECMW_GFLEX_NL) {
99 set_err_token(token, HECMW_IO_GEOFEM_E0004, "Needs ESSENTIAL BLANK LINE");
100 return -1;
101 }
102
103 return 0;
104}
105
106static int read_node(void) {
107 int nnode, nninternal, i, token;
108
109 /* NODtot */
111 if (token != HECMW_GFLEX_INT) {
112 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
113 return -1;
114 }
116 if (nnode <= 0) {
117 set_err(HECMW_IO_GEOFEM_E0311, "");
118 return -1;
119 }
120
121 /* intNODtot */
123 if (token != HECMW_GFLEX_INT) {
124 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
125 return -1;
126 }
127 nninternal = HECMW_gflex_get_number();
128 if (nninternal <= 0) {
129 set_err(HECMW_IO_GEOFEM_E0312, "");
130 return -1;
131 }
132 if (nnode != nninternal) {
133 set_err(HECMW_IO_GEOFEM_E0313, "");
134 return -1;
135 }
136
137 for (i = 0; i < nnode; i++) {
138 int id;
139 double x, y, z;
140
141 /* nGlobalID */
143 if (token != HECMW_GFLEX_INT) {
144 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
145 return -1;
146 }
148 if (id <= 0) {
149 set_err(HECMW_IO_GEOFEM_E0314, "");
150 return -1;
151 }
152
153 /* X */
155 if (token != HECMW_GFLEX_DOUBLE && token != HECMW_GFLEX_INT) {
156 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
157 return -1;
158 }
160
161 /* Y */
163 if (token != HECMW_GFLEX_DOUBLE && token != HECMW_GFLEX_INT) {
164 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
165 return -1;
166 }
168
169 /* Z */
171 if (token != HECMW_GFLEX_DOUBLE && token != HECMW_GFLEX_INT) {
172 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
173 return -1;
174 }
176
177 /* add node */
178 if (HECMW_io_add_node(id, x, y, z) == NULL) {
179 return -1;
180 }
181
182 /* add node to group */
183 if (HECMW_io_add_ngrp("ALL", 1, &id) < 0) { /* always add to 'ALL' */
184 return -1;
185 }
186 }
187
188 /* end of NODE */
189 token = HECMW_gflex_next_token();
190 if (token != HECMW_GFLEX_NL) {
191 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
192 return -1;
193 }
194
195 return 0;
196}
197
198static int read_elem(void) {
199 int i, j, n, token, nelem;
200 int *elem_type;
201
202 /* ELMtot */
204 if (token != HECMW_GFLEX_INT) {
205 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
206 return -1;
207 }
209 if (nelem <= 0) {
210 set_err(HECMW_IO_GEOFEM_E0321, "");
211 return -1;
212 }
213
214 /* ELMtype */
215 elem_type = HECMW_malloc(sizeof(*elem_type) * nelem);
216 if (elem_type == NULL) {
217 HECMW_set_error(errno, "");
218 return -1;
219 }
220 for (i = 0; i < nelem; i++) {
222 if (token != HECMW_GFLEX_INT) {
223 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
224 return -1;
225 }
226 elem_type[i] = HECMW_gflex_get_number();
228 if (n == -1) {
229 set_err(HECMW_IO_GEOFEM_E0322, "");
230 return -1;
231 }
232 }
233
234 /* eGlobalID, connectivity */
235 for (i = 0; i < nelem; i++) {
236 int id, hecmw_type;
237 int node[HECMW_MAX_NODE_MAX];
238
239 /* eGlobalID */
241 if (token != HECMW_GFLEX_INT) {
242 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
243 return -1;
244 }
246 if (id <= 0) {
247 set_err(HECMW_IO_GEOFEM_E0324, "Invalid Element ID");
248 return -1;
249 }
250
251 hecmw_type = HECMW_get_etype_GeoFEM2HECMW(elem_type[i]);
252 n = HECMW_get_max_node(hecmw_type);
253 for (j = 0; j < n; j++) {
254 /* connectivity */
256 if (token != HECMW_GFLEX_INT) {
257 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
258 return -1;
259 }
260 node[j] = HECMW_gflex_get_number();
261 if (node[j] <= 0) {
262 set_err(HECMW_IO_GEOFEM_E0323, "");
263 return -1;
264 }
265 }
266
267 /* add element */
268 if (HECMW_io_add_elem(id, hecmw_type, node, 0, NULL) == NULL) {
269 return -1;
270 }
271
272 /* add element to eroup */
273 if (HECMW_io_add_egrp("ALL", 1, &id) < 0) { /* always add to 'ALL' */
274 return -1;
275 }
276 }
277
278 /* end of ELEMENT */
279 token = HECMW_gflex_next_token();
280 if (token != HECMW_GFLEX_NL) {
281 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
282 return -1;
283 }
284
285 HECMW_free(elem_type);
286
287 return 0;
288}
289
290static int read_import(void) {
291 int token;
292
293 /* ESSENTIAL BLANK LINE */
294 token = HECMW_gflex_next_token();
295 if (token != HECMW_GFLEX_NL) {
296 set_err_token(token, HECMW_IO_GEOFEM_E0004, "Needs ESSENTIAL BLANK LINE");
297 return -1;
298 }
299 return 0;
300}
301
302static int read_export(void) {
303 int token;
304
305 /* ESSENTIAL BLANK LINE */
306 token = HECMW_gflex_next_token();
307 if (token != HECMW_GFLEX_NL) {
308 set_err_token(token, HECMW_IO_GEOFEM_E0004, "Needs ESSENTIAL BLANK LINE");
309 return -1;
310 }
311 return 0;
312}
313
314static int read_ngrp(void) {
315 int i, j, n, token, ngrp;
316 int *grp_index;
317
318 /* NODgrpTOT */
320 if (token != HECMW_GFLEX_INT) {
321 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
322 return -1;
323 }
324 ngrp = HECMW_gflex_get_number();
325 if (ngrp < 0) {
326 set_err(HECMW_IO_GEOFEM_E0341, "");
327 return -1;
328 }
329 if (ngrp == 0) {
330 token = HECMW_gflex_next_token();
331 if (token != HECMW_GFLEX_NL) {
332 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
333 return -1;
334 }
335 /* ESSENTIAL BLANK LINE */
336 token = HECMW_gflex_next_token();
337 if (token != HECMW_GFLEX_NL) {
338 set_err_token(token, HECMW_IO_GEOFEM_E0004, "Needs ESSENTIAL BLANK LINE");
339 return -1;
340 }
341 return 0;
342 }
343
344 /* NODgrpINDEX */
345 grp_index = HECMW_malloc(sizeof(*grp_index) * (ngrp + 1));
346 if (grp_index == NULL) {
347 HECMW_set_error(errno, "");
348 return -1;
349 }
350 grp_index[0] = 0;
351 for (i = 0; i < ngrp; i++) {
353 if (token != HECMW_GFLEX_INT) {
354 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
355 return -1;
356 }
357 grp_index[i + 1] = HECMW_gflex_get_number();
358 if (grp_index[i + 1] <= 0) {
359 set_err(HECMW_IO_GEOFEM_E0342, "");
360 return -1;
361 }
362 }
363
364 for (i = 0; i < ngrp; i++) {
365 char *p, name[HECMW_NAME_LEN + 1];
366 int *node;
367
368 /* NODgrpNAME */
370 if (token != HECMW_GFLEX_NAME) {
371 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
372 return -1;
373 }
375 if (strlen(p) > HECMW_NAME_LEN) {
376 set_err(HECMW_IO_E0001, "");
377 return -1;
378 }
379 strcpy(name, p);
380
381 /* NODgrpITEM */
382 n = grp_index[i + 1] - grp_index[i];
383 node = HECMW_malloc(sizeof(*node) * n);
384 if (node == NULL) {
385 HECMW_set_error(errno, "");
386 return -1;
387 }
388 for (j = 0; j < n; j++) {
390 if (token != HECMW_GFLEX_INT) {
391 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
392 return -1;
393 }
394 node[j] = HECMW_gflex_get_number();
395 if (node[j] <= 0) {
396 set_err(HECMW_IO_GEOFEM_E0343, "");
397 return -1;
398 }
399 }
400
401 /* add node to node group */
402 if (HECMW_io_add_ngrp(name, n, node) < 0) {
403 return -1;
404 }
405
406 HECMW_free(node);
407 }
408
409 /* end of NGRP */
410 token = HECMW_gflex_next_token();
411 if (token != HECMW_GFLEX_NL) {
412 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
413 return -1;
414 }
415
416 HECMW_free(grp_index);
417
418 return 0;
419}
420
421static int read_egrp(void) {
422 int i, j, n, token, ngrp;
423 int *grp_index;
424
425 /* ELMgrpTOT */
427 if (token != HECMW_GFLEX_INT) {
428 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
429 return -1;
430 }
431 ngrp = HECMW_gflex_get_number();
432 if (ngrp < 0) {
433 set_err(HECMW_IO_GEOFEM_E0351, "");
434 return -1;
435 }
436 if (ngrp == 0) {
437 token = HECMW_gflex_next_token();
438 if (token != HECMW_GFLEX_NL) {
439 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
440 return -1;
441 }
442 /* ESSENTIAL BLANK LINE */
443 token = HECMW_gflex_next_token();
444 if (token != HECMW_GFLEX_NL) {
445 set_err_token(token, HECMW_IO_GEOFEM_E0004, "Needs ESSENTIAL BLANK LINE");
446 return -1;
447 }
448 return 0;
449 }
450
451 /* ELMgrpINDEX */
452 grp_index = HECMW_malloc(sizeof(*grp_index) * (ngrp + 1));
453 if (grp_index == NULL) {
454 HECMW_set_error(errno, "");
455 return -1;
456 }
457 grp_index[0] = 0;
458 for (i = 0; i < ngrp; i++) {
460 if (token != HECMW_GFLEX_INT) {
461 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
462 return -1;
463 }
464 grp_index[i + 1] = HECMW_gflex_get_number();
465 if (grp_index[i + 1] <= 0) {
466 set_err(HECMW_IO_GEOFEM_E0352, "");
467 return -1;
468 }
469 }
470
471 for (i = 0; i < ngrp; i++) {
472 char *p, name[HECMW_NAME_LEN + 1];
473 int *elem;
474
475 /* ELMgrpNAME */
477 if (token != HECMW_GFLEX_NAME) {
478 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
479 return -1;
480 }
482 if (strlen(p) > HECMW_NAME_LEN) {
483 set_err(HECMW_IO_E0001, "");
484 return -1;
485 }
486 strcpy(name, p);
487
488 /* ELMgrpITEM */
489 n = grp_index[i + 1] - grp_index[i];
490 elem = HECMW_malloc(sizeof(*elem) * n);
491 if (elem == NULL) {
492 HECMW_set_error(errno, "");
493 return -1;
494 }
495 for (j = 0; j < n; j++) {
497 if (token != HECMW_GFLEX_INT) {
498 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
499 return -1;
500 }
501 elem[j] = HECMW_gflex_get_number();
502 if (elem[j] <= 0) {
503 set_err(HECMW_IO_GEOFEM_E0353, "");
504 return -1;
505 }
506 }
507
508 /* add node to node group */
509 if (HECMW_io_add_egrp(name, n, elem) < 0) {
510 return -1;
511 }
512
513 HECMW_free(elem);
514 }
515
516 /* end of EGRP */
517 token = HECMW_gflex_next_token();
518 if (token != HECMW_GFLEX_NL) {
519 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
520 return -1;
521 }
522
523 HECMW_free(grp_index);
524
525 return 0;
526}
527
528static int read_sgrp(void) {
529 int i, j, n, token, ngrp;
530 int *grp_index;
531
532 /* SUFgrpTOT */
534 if (token != HECMW_GFLEX_INT) {
535 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
536 return -1;
537 }
538 ngrp = HECMW_gflex_get_number();
539 if (ngrp < 0) {
540 set_err(HECMW_IO_GEOFEM_E0361, "");
541 return -1;
542 }
543 if (ngrp == 0) {
544 token = HECMW_gflex_next_token();
545 if (token != HECMW_GFLEX_NL) {
546 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
547 return -1;
548 }
549 /* ESSENTIAL BLANK LINE */
550 token = HECMW_gflex_next_token();
551 if (token != HECMW_GFLEX_NL) {
552 set_err_token(token, HECMW_IO_GEOFEM_E0004, "Needs ESSENTIAL BLANK LINE");
553 return -1;
554 }
555 return 0;
556 }
557
558 /* SUFgrpINDEX */
559 grp_index = HECMW_malloc(sizeof(*grp_index) * (ngrp + 1));
560 if (grp_index == NULL) {
561 HECMW_set_error(errno, "");
562 return -1;
563 }
564 grp_index[0] = 0;
565 for (i = 0; i < ngrp; i++) {
567 if (token != HECMW_GFLEX_INT) {
568 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
569 return -1;
570 }
571 grp_index[i + 1] = HECMW_gflex_get_number();
572 if (grp_index[i + 1] <= 0) {
573 set_err(HECMW_IO_GEOFEM_E0362, "");
574 return -1;
575 }
576 }
577
578 for (i = 0; i < ngrp; i++) {
579 char *p, name[HECMW_NAME_LEN + 1];
580 int *elem, *surf;
581
582 /* SUFgrpNAME */
584 if (token != HECMW_GFLEX_NAME) {
585 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
586 return -1;
587 }
589 if (strlen(p) > HECMW_NAME_LEN) {
590 set_err(HECMW_IO_E0001, "");
591 return -1;
592 }
593 strcpy(name, p);
594
595 /* SUFgrpITEM */
596 n = grp_index[i + 1] - grp_index[i];
597 elem = HECMW_malloc(sizeof(*elem) * n);
598 if (elem == NULL) {
599 HECMW_set_error(errno, "");
600 return -1;
601 }
602 surf = HECMW_malloc(sizeof(*surf) * n);
603 if (surf == NULL) {
604 HECMW_set_error(errno, "");
605 return -1;
606 }
607 for (j = 0; j < n; j++) {
609 if (token != HECMW_GFLEX_INT) {
610 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
611 return -1;
612 }
613 elem[j] = HECMW_gflex_get_number();
614 if (elem[j] <= 0) {
615 set_err(HECMW_IO_GEOFEM_E0363, "");
616 return -1;
617 }
618 }
619 for (j = 0; j < n; j++) {
621 if (token != HECMW_GFLEX_INT) {
622 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
623 return -1;
624 }
625 surf[j] = HECMW_gflex_get_number();
626 if (surf[j] <= 0) {
627 set_err(HECMW_IO_GEOFEM_E0363, "");
628 return -1;
629 }
630 }
631
632 /* add to surf group */
633 if (HECMW_io_add_sgrp(name, n, elem, surf) < 0) {
634 return -1;
635 }
636
637 HECMW_free(elem);
638 HECMW_free(surf);
639 }
640
641 /* end of SGRP */
642 token = HECMW_gflex_next_token();
643 if (token != HECMW_GFLEX_NL) {
644 set_err_token(token, HECMW_IO_GEOFEM_E0004, "");
645 return -1;
646 }
647
648 HECMW_free(grp_index);
649
650 return 0;
651}
652
653static int parse(void) {
654 if (read_pe()) return -1;
655 if (read_node()) return -1;
656 if (read_elem()) return -1;
657 if (read_import()) return -1;
658 if (read_export()) return -1;
659 if (read_ngrp()) return -1;
660 if (read_egrp()) return -1;
661 if (read_sgrp()) return -1;
662
663 return 0;
664}
665
666/* read only. Not make hecmwST_local_mesh */
667int HECMW_read_geofem_mesh(const char *filename) {
668 FILE *fp;
669
670 HECMW_log(HECMW_LOG_DEBUG, "Start to read GeoFEM mesh");
671
672 if (filename == NULL) {
674 "Not specified filename for GeoFEM mesh input routine");
675 return -1;
676 }
677 HECMW_log(HECMW_LOG_DEBUG, "GeoFEM mesh file is '%s'", filename);
678
679 if (strlen(filename) > HECMW_FILENAME_LEN) {
681 return -1;
682 }
683
684 strcpy(grid_filename, filename);
685 HECMW_io_set_gridfile(grid_filename);
686
687 if ((fp = fopen(filename, "r")) == NULL) {
688 HECMW_set_error(HECMW_IO_HEC_E0001, "File: %s, %s", filename,
689 strerror(errno));
690 return -1;
691 }
692
693 if (HECMW_gflex_set_input(fp)) return -1;
694
695 HECMW_log(HECMW_LOG_DEBUG, "Parsing...");
696 if (parse()) {
697 return -1;
698 }
699
700 if (fclose(fp)) {
701 HECMW_set_error(HECMW_IO_HEC_E0002, "File: %s, %s", filename,
702 strerror(errno));
703 return -1;
704 }
705
706 strcpy(grid_filename, "Unknown");
707
708 return 0;
709}
710
711struct hecmwST_local_mesh *HECMW_get_geofem_mesh(const char *filename) {
712 struct hecmwST_local_mesh *local_mesh;
713
714 if (HECMW_io_init()) return NULL;
715 if (HECMW_io_pre_process()) return NULL;
716 if (HECMW_read_geofem_mesh(filename)) return NULL;
717 if (HECMW_io_post_process()) return NULL;
718 local_mesh = HECMW_io_make_local_mesh();
719 if (local_mesh == NULL) return NULL;
720 if (HECMW_io_finalize()) return NULL;
721
722 strcpy(grid_filename, "Unknown");
723
724 return local_mesh;
725}
#define HECMW_MAX_NODE_MAX
#define HECMW_FILENAME_LEN
Definition: hecmw_config.h:72
#define HECMW_MSG_LEN
Definition: hecmw_config.h:74
#define HECMW_NAME_LEN
Definition: hecmw_config.h:70
int HECMW_set_error(int errorno, const char *fmt,...)
Definition: hecmw_error.c:37
int HECMW_get_max_node(int etype)
Definition: hecmw_etype.c:409
int HECMW_get_etype_GeoFEM2HECMW(int etype)
Definition: hecmw_etype.c:340
int HECMW_gflex_next_token_skip(int skip_token)
Definition: hecmw_gflex.c:1645
int HECMW_gflex_set_input(FILE *fp)
Definition: hecmw_gflex.c:1655
int HECMW_gflex_get_lineno(void)
Definition: hecmw_gflex.c:1637
double HECMW_gflex_get_number(void)
Definition: hecmw_gflex.c:1639
char * HECMW_gflex_get_text(void)
Definition: hecmw_gflex.c:1641
int HECMW_gflex_next_token(void)
Definition: hecmw_gflex.c:1643
@ HECMW_GFLEX_NAME
Definition: hecmw_gflex.h:15
@ HECMW_GFLEX_INT
Definition: hecmw_gflex.h:13
@ HECMW_GFLEX_NL
Definition: hecmw_gflex.h:12
@ HECMW_GFLEX_DOUBLE
Definition: hecmw_gflex.h:14
struct hecmwST_local_mesh * HECMW_get_geofem_mesh(const char *filename)
int HECMW_read_geofem_mesh(const char *filename)
int HECMW_io_add_ngrp(const char *name, int nnode, int *node)
struct hecmw_io_element * HECMW_io_add_elem(int id, int type, int *node, int nmatitem, double *matitem)
int HECMW_io_add_sgrp(const char *name, int n_item, int *elem, int *surf)
int HECMW_io_add_egrp(const char *name, int nelem, int *elem)
struct hecmwST_local_mesh * HECMW_io_make_local_mesh(void)
struct hecmw_io_node * HECMW_io_add_node(int id, double x, double y, double z)
int HECMW_io_init(void)
int HECMW_io_pre_process(void)
int HECMW_io_post_process(void)
int HECMW_io_set_gridfile(char *gridfile)
int HECMW_io_finalize(void)
#define NULL
int HECMW_log(int loglv, const char *fmt,...)
Definition: hecmw_log.c:260
#define HECMW_LOG_ERROR
Definition: hecmw_log.h:15
#define HECMW_LOG_DEBUG
Definition: hecmw_log.h:21
#define HECMW_free(ptr)
Definition: hecmw_malloc.h:24
#define HECMW_malloc(size)
Definition: hecmw_malloc.h:20
#define HECMW_IO_HEC_E0002
Definition: hecmw_msgno.h:195
#define HECMW_IO_GEOFEM_E0362
Definition: hecmw_msgno.h:192
#define HECMW_IO_GEOFEM_E0353
Definition: hecmw_msgno.h:190
#define HECMW_IO_GEOFEM_E0363
Definition: hecmw_msgno.h:193
#define HECMW_IO_GEOFEM_E0322
Definition: hecmw_msgno.h:180
#define HECMW_IO_GEOFEM_E0361
Definition: hecmw_msgno.h:191
#define HECMW_IO_GEOFEM_E0351
Definition: hecmw_msgno.h:188
#define HECMW_IO_HEC_E0001
Definition: hecmw_msgno.h:194
#define HECMW_IO_GEOFEM_E0004
Definition: hecmw_msgno.h:171
#define HECMW_IO_GEOFEM_E0312
Definition: hecmw_msgno.h:176
#define HECMW_IO_GEOFEM_E0341
Definition: hecmw_msgno.h:185
#define HECMW_IO_GEOFEM_E0301
Definition: hecmw_msgno.h:172
#define HECMW_IO_GEOFEM_E0324
Definition: hecmw_msgno.h:182
#define HECMW_IO_GEOFEM_E0323
Definition: hecmw_msgno.h:181
#define HECMW_IO_GEOFEM_E0343
Definition: hecmw_msgno.h:187
#define HECMW_IO_GEOFEM_E0321
Definition: hecmw_msgno.h:179
#define HECMW_IO_GEOFEM_E0313
Definition: hecmw_msgno.h:177
#define HECMW_IO_E0002
Definition: hecmw_msgno.h:142
#define HECMW_IO_GEOFEM_E0342
Definition: hecmw_msgno.h:186
#define HECMW_IO_E0001
Definition: hecmw_msgno.h:141
#define HECMW_IO_GEOFEM_E0314
Definition: hecmw_msgno.h:178
#define HECMW_IO_GEOFEM_E0311
Definition: hecmw_msgno.h:175
#define HECMW_IO_GEOFEM_E0352
Definition: hecmw_msgno.h:189
#define HECMW_IO_GEOFEM_E0003
Definition: hecmw_msgno.h:170
int nelem
int nnode
void HECMW_print_msg(int loglv, int msgno, const char *fmt,...)
Definition: hecmw_util.c:138
int HECMW_snprintf(char *str, size_t size, const char *format,...)
Definition: hecmw_util.c:153
int HECMW_vsnprintf(char *str, size_t size, const char *format, va_list ap)
Definition: hecmw_util.c:145