FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
hecmw_io_abaqus.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 <errno.h>
9#include "hecmw_util.h"
10#include "hecmw_ablex.h"
11#include "hecmw_io_abaqus.h"
12#include "hecmw_io_mesh.h"
13#include "hecmw_io_struct.h"
14#include "hecmw_struct.h"
15#include "hecmw_config.h"
16#include "hecmw_system.h"
17#include "hecmw_dist.h"
18#include "hecmw_dist_print.h"
19#include "hecmw_common.h"
20#include "hecmw_path.h"
21#include "hecmw_conn_conv.h"
22#include "hecmw_map_int.h"
23
24/*----------------------------------------------------------------------------*/
25
26static char grid_filename[HECMW_FILENAME_LEN + 1] = "Unknown";
27static char include_filename[HECMW_FILENAME_LEN + 1] = "Unknown";
28
29/*----------------------------------------------------------------------------*/
30
31static void do_logging(int loglv, int msgno, int add_location, const char *fmt,
32 va_list ap) {
33 char line[100] = "";
34 char msg[HECMW_MSG_LEN + 1];
35 char *p;
36
37 HECMW_vsnprintf(msg, sizeof(msg), fmt, ap);
38 if (add_location) {
39 char *s = "";
40 if (strlen(msg) > 0) s = ": ";
41 p = HECMW_ablex_is_including() ? include_filename : grid_filename;
42 HECMW_snprintf(line, sizeof(line), "%s:%d%s", p, HECMW_ablex_get_lineno(),
43 s);
44 }
45 if (loglv == HECMW_LOG_ERROR) {
46 HECMW_set_error(msgno, "%s%s", line, msg);
47 } else {
48 HECMW_print_msg(loglv, msgno, "%s%s", line, msg);
49 }
50}
51
52static void set_err_noloc(int msgno, const char *fmt, ...) {
53 va_list ap;
54
55 va_start(ap, fmt);
56 do_logging(HECMW_LOG_ERROR, msgno, 0, fmt, ap);
57 va_end(ap);
58}
59
60static void set_err(int msgno, const char *fmt, ...) {
61 va_list ap;
62
63 va_start(ap, fmt);
64 do_logging(HECMW_LOG_ERROR, msgno, 1, fmt, ap);
65 va_end(ap);
66}
67
68static void set_err_token(int token, int msgno, const char *fmt, ...) {
69 int msg_no;
70 va_list ap;
71
72 if (!token) {
73 msg_no = HECMW_IO_ABAQUS_E0003;
74 } else {
75 msg_no = msgno;
76 }
77 va_start(ap, fmt);
78 do_logging(HECMW_LOG_ERROR, msg_no, 1, fmt, ap);
79 va_end(ap);
80}
81
82static void log_warn(int msgno, const char *fmt, ...) {
83 va_list ap;
84
85 va_start(ap, fmt);
86 do_logging(HECMW_LOG_WARN, msgno, 1, fmt, ap);
87 va_end(ap);
88}
89
90/*----------------------------------------------------------------------------*/
91
92typedef struct { int i; } Integer;
93
94static struct hecmw_map_int *elem_secopt;
95
96static void free_Integer(void *v) {
97 Integer *i;
98 i = (Integer *)v;
99 /* do nothing on members */
100 HECMW_free(i);
101}
102
103/*----------------------------------------------------------------------------*/
104
105static struct material_keywords {
106 int keyword;
107 char *string;
108} material_keywords[] = {
109 {HECMW_ABLEX_H_CONDUCTIVITY, "*CONDUCTIVITY"},
110 {HECMW_ABLEX_H_DENSITY, "*DENSITY"},
111 {HECMW_ABLEX_H_ELASTIC, "*ELASTIC"},
112 {HECMW_ABLEX_H_SPECIFIC_HEAT, "*SPECIFIC HEAT"},
113};
114
115#define N_MAT_KEYS (sizeof(material_keywords) / sizeof(material_keywords[0]))
116
117static int is_material_keyword(int keyword) {
118 int i;
119
120 for (i = 0; i < N_MAT_KEYS; i++) {
121 if (keyword == material_keywords[i].keyword) return 1;
122 }
123 return 0;
124}
125
126static char *get_material_string(int keyword) {
127 int i;
128
129 for (i = 0; i < N_MAT_KEYS; i++) {
130 if (keyword == material_keywords[i].keyword) {
131 return material_keywords[i].string;
132 }
133 }
134 return NULL;
135}
136
137/*----------------------------------------------------------------------------*/
138
139static int flag_material_zone;
140/* true: in *MATERIAL to next *MATERIAL or not material keyword */
141static char matname[HECMW_NAME_LEN + 1] = "";
142static struct material_data {
143 int keyword;
144 struct hecmw_io_matitem *matitem;
145 struct material_data *next;
146} * matdata;
147
148static int is_material_zone(void) { return flag_material_zone; }
149
150static void set_material_zone(int flag) { flag_material_zone = flag ? 1 : 0; }
151
152static int add_mat_data(int keyword, struct hecmw_io_matitem *matitem) {
153 int i;
154 struct material_data *p, *q, *mdata;
155
156 for (p = matdata; p; p = p->next) {
157 if (p->keyword == keyword) break;
158 }
159 if (p) {
160 struct hecmw_io_matsubitem *sip, *siq;
161 struct hecmw_io_matitem *item = p->matitem;
162 p->matitem = matitem; /* update */
163 matitem->item = item->item;
164 for (sip = item->subitem; sip; sip = siq) {
165 siq = sip->next;
166 HECMW_free(sip->val);
167 HECMW_free(sip);
168 }
169 HECMW_free(item);
170 log_warn(HECMW_IO_ABAQUS_W0095, "%s updated for *MATERIAL %s",
171 get_material_string(keyword), matname);
172 return 0;
173 }
174
175 mdata = HECMW_malloc(sizeof(*mdata));
176 if (mdata == NULL) {
177 set_err(errno, "");
178 return -1;
179 }
180
181 mdata->keyword = keyword;
182 mdata->matitem = matitem;
183 mdata->next = NULL;
184
185 q = NULL;
186 for (i = 0, p = matdata; p; p = (q = p)->next, i++)
187 ;
188 matitem->item = i + 1;
189 if (q == NULL) {
190 matdata = mdata;
191 } else {
192 q->next = mdata;
193 }
194
195 return 0;
196}
197
198static int count_mat_item(void) {
199 int n;
200 struct material_data *p, *q;
201
202 for (n = 0, p = matdata; p; p = (q = p)->next, n++)
203 ;
204 return n;
205}
206
207static int regist_material(void) {
208 int i, n;
209 struct hecmw_io_material *mat = NULL;
210 struct material_data *p, *q;
211
212 n = count_mat_item();
213 if (n == 0) return 0;
214
215 mat = HECMW_calloc(1, sizeof(*mat) * n);
216 if (mat == NULL) {
217 set_err(errno, "");
218 goto error;
219 }
220
221 HECMW_assert(strlen(matname) > 0);
222
223 mat->nitem = n;
224 strcpy(mat->name, matname);
225
226 mat->item = HECMW_malloc(sizeof(*mat->item) * n);
227 if (mat->item == NULL) {
228 set_err(errno, "");
229 goto error;
230 }
231
232 for (i = 0, p = matdata; p; p = q, i++) {
233 q = p->next;
234 HECMW_assert(p->matitem->item == i + 1);
235 mat->item[i] = *p->matitem;
236 HECMW_free(p->matitem);
237 HECMW_free(p);
238 }
239
240 if (HECMW_io_add_mat(matname, mat) == NULL) goto error;
241
242 strcpy(matname, "");
243 matdata = NULL;
244
245 return 0;
246error:
247 if (mat) {
248 HECMW_free(mat->item);
249 HECMW_free(mat);
250 }
251 return -1;
252}
253
254static int read_mat_data_line_common(int nval, int nval_line, double *val,
255 int errmsgno) {
256 int i, token;
257
258 HECMW_assert(nval > 0);
259 HECMW_assert(nval_line > 0);
260 HECMW_assert(val);
261
262 for (i = 0; i < nval; i++) {
263 val[i] = 0.0;
264 }
265 i = 0;
266 while (1) {
267 token = HECMW_ablex_next_token();
268 if (token != HECMW_ABLEX_DOUBLE && token != HECMW_ABLEX_INT &&
269 token != ',' && token != HECMW_ABLEX_NL) {
270 set_err_token(token, errmsgno, "VAL or ',' or NL reuqired");
271 return -1;
272 }
273 if (token == HECMW_ABLEX_NL) {
275 } else if (token == ',') {
276 i++;
278 } else {
279 val[i++] = HECMW_ablex_get_number();
280 }
281
282 token = HECMW_ablex_next_token();
283 if (token != ',' && token != HECMW_ABLEX_NL) {
284 set_err_token(token, errmsgno, "',' or NL required after VAL");
285 return -1;
286 }
287
288 if (token == HECMW_ABLEX_NL) {
289 if (i % nval_line) {
290 i += nval_line - (i % nval_line);
291 }
292 }
293 if (i >= nval) {
294 if (token == ',') {
295 token = HECMW_ablex_next_token();
296 if (token != HECMW_ABLEX_NL) {
297 set_err_token(token, errmsgno, "NL required");
298 return -1;
299 }
300 }
301 break;
302 }
303 }
304 return 0;
305}
306
307static int read_mat_data_common(int nval, int nval_line, int temp_col,
308 struct hecmw_io_matitem **matitem, int msgno) {
309 int token;
310 struct hecmw_io_matitem *item = NULL;
311 struct hecmw_io_matsubitem *subitem = NULL;
312 struct hecmw_io_matsubitem *q, *p = NULL;
313
314 item = HECMW_malloc(sizeof(*item));
315 if (item == NULL) {
316 set_err(errno, "");
317 goto error;
318 }
319
320 item->item = -1; /* I don't know */
321 item->nval = nval;
322 item->subitem = NULL;
323
324 while (1) {
325 subitem = HECMW_calloc(1, sizeof(*subitem));
326 if (subitem == NULL) {
327 set_err(errno, "");
328 goto error;
329 }
330
331 subitem->val = HECMW_malloc(sizeof(*subitem->val) * nval);
332 if (subitem->val == NULL) {
333 set_err(errno, "");
334 goto error;
335 }
336
337 if (read_mat_data_line_common(nval, nval_line, subitem->val, msgno))
338 goto error;
339
340 subitem->temp = subitem->val[temp_col - 1];
341 subitem->next = NULL;
342
343 if (p == NULL) {
344 item->subitem = subitem;
345 } else {
346 p->next = subitem;
347 }
348 p = subitem;
349
350 token = HECMW_ablex_next_token();
352 if (token != HECMW_ABLEX_DOUBLE && token != HECMW_ABLEX_INT &&
353 token != ',') {
354 break;
355 }
356 }
357 *matitem = item;
358
359 return 0;
360error:
361 if (item) {
362 for (p = item->subitem; p; p = q) {
363 q = p->next;
364 HECMW_free(p->val);
365 HECMW_free(p);
366 }
367 HECMW_free(item);
368 }
369 return -1;
370}
371
372/*----------------------------------------------------------------------------*/
373
374static int read_param_dependencies(int *dependencies, int msgno) {
375 int token;
376
377 token = HECMW_ablex_next_token();
378 if (token != '=') {
379 set_err_token(token, msgno, "'=' required after DEPENDENCIES");
380 return -1;
381 }
382 token = HECMW_ablex_next_token();
383 if (token != HECMW_ABLEX_INT) {
384 set_err_token(token, msgno, "Invalid DEPENDENCIES");
385 return -1;
386 }
387 *dependencies = HECMW_ablex_get_number();
388 if (*dependencies <= 0) {
389 set_err_token(token, msgno, "DEPENDENCIES must be positive integer");
390 return -1;
391 }
392 return 0;
393}
394
395/*----------------------------------------------------------------------------*/
396
397static struct etype_conv {
398 int abaqus_etype;
399 int hecmw_etype;
400 int secopt;
401} etype_conv[] = {
402 {HECMW_ABLEX_E_B31, 611, 0}, {HECMW_ABLEX_E_B32, 612, 0},
403 {HECMW_ABLEX_E_C3D4, 341, 0}, {HECMW_ABLEX_E_C3D6, 351, 0},
404 {HECMW_ABLEX_E_C3D8, 361, 0}, {HECMW_ABLEX_E_C3D8I, 361, 0},
405 {HECMW_ABLEX_E_C3D10, 342, 0}, {HECMW_ABLEX_E_C3D15, 352, 0},
406 {HECMW_ABLEX_E_C3D20, 362, 0}, {HECMW_ABLEX_E_CAX3, 231, 2},
407 {HECMW_ABLEX_E_CAX4, 241, 2}, {HECMW_ABLEX_E_CAX4I, 241, 2},
408 {HECMW_ABLEX_E_CAX4R, 241, 12}, {HECMW_ABLEX_E_CAX6, 232, 2},
409 {HECMW_ABLEX_E_CAX8, 242, 2}, {HECMW_ABLEX_E_CAX8R, 242, 12},
410 {HECMW_ABLEX_E_CPE3, 231, 1}, {HECMW_ABLEX_E_CPE4, 241, 1},
411 {HECMW_ABLEX_E_CPE4I, 241, 1}, {HECMW_ABLEX_E_CPE4R, 241, 11},
412 {HECMW_ABLEX_E_CPE6, 232, 1}, {HECMW_ABLEX_E_CPE8, 242, 1},
413 {HECMW_ABLEX_E_CPE8R, 242, 11}, {HECMW_ABLEX_E_CPS3, 231, 0},
414 {HECMW_ABLEX_E_CPS4, 241, 0}, {HECMW_ABLEX_E_CPS4I, 241, 0},
415 {HECMW_ABLEX_E_CPS4R, 241, 10}, {HECMW_ABLEX_E_CPS6, 232, 0},
416 {HECMW_ABLEX_E_CPS8, 242, 0}, {HECMW_ABLEX_E_CPS8R, 242, 10},
417 {HECMW_ABLEX_E_DC1D2, 111, 0}, {HECMW_ABLEX_E_DC1D3, 112, 0},
418 {HECMW_ABLEX_E_DC2D3, 231, 0}, {HECMW_ABLEX_E_DC2D4, 241, 0},
419 {HECMW_ABLEX_E_DC2D6, 232, 0}, {HECMW_ABLEX_E_DC2D8, 242, 0},
420 {HECMW_ABLEX_E_DC3D4, 341, 0}, {HECMW_ABLEX_E_DC3D6, 351, 0},
421 {HECMW_ABLEX_E_DC3D8, 361, 0}, {HECMW_ABLEX_E_DC3D10, 342, 0},
422 {HECMW_ABLEX_E_DC3D15, 352, 0}, {HECMW_ABLEX_E_DC3D20, 362, 0},
423 {HECMW_ABLEX_E_DCAX3, 231, 2}, {HECMW_ABLEX_E_DCAX4, 241, 2},
424 {HECMW_ABLEX_E_DCAX6, 232, 0}, {HECMW_ABLEX_E_DCAX8, 242, 0},
425 {HECMW_ABLEX_E_DINTER4, 541, 0}, {HECMW_ABLEX_E_DINTER8, 542, 0},
426 {HECMW_ABLEX_E_DS4, 741, 0}, {HECMW_ABLEX_E_DS8, 742, 0},
427 {HECMW_ABLEX_E_INTER4, 541, 0}, {HECMW_ABLEX_E_INTER8, 542, 0},
428 {HECMW_ABLEX_E_S3R, 731, 0}, {HECMW_ABLEX_E_S4R, 741, 0},
429 {HECMW_ABLEX_E_S8R, 742, 0}, {HECMW_ABLEX_E_T3D2, 111, 0},
430 {HECMW_ABLEX_E_T3D3, 112, 0},
431};
432
433static int get_HECMW_etype(int abaqus_etype) {
434 int i;
435
436 for (i = 0; i < sizeof(etype_conv) / sizeof(etype_conv[0]); i++) {
437 if (etype_conv[i].abaqus_etype == abaqus_etype) {
438 return etype_conv[i].hecmw_etype;
439 }
440 }
441 return -1;
442}
443
444static int get_secopt_abaqus(int abaqus_etype) {
445 int i;
446
447 for (i = 0; i < sizeof(etype_conv) / sizeof(etype_conv[0]); i++) {
448 if (etype_conv[i].abaqus_etype == abaqus_etype) {
449 return etype_conv[i].secopt;
450 }
451 }
452 return -1;
453}
454
455static int get_secopt(char *elset, int msgno) {
456 int i, secopt_prev;
457 struct hecmw_io_id_array *elem = NULL;
458
459 elem = HECMW_io_get_elem_in_egrp(elset);
460 if (elem == NULL) return -1;
461
462 secopt_prev = -1;
463 for (i = 0; i < elem->n; i++) {
464 Integer *secopt = HECMW_map_int_get(elem_secopt, elem->id[i]);
465 if (secopt == NULL) {
466 set_err_noloc(msgno, "");
467 goto error;
468 }
469 if (i == 0) {
470 secopt_prev = secopt->i;
471 } else {
472 if (secopt_prev != secopt->i) goto error;
473 }
474 }
475 HECMW_free(elem->id);
476 HECMW_free(elem);
477 return secopt_prev;
478error:
479 if (elem) {
480 HECMW_free(elem->id);
481 HECMW_free(elem);
482 }
483 return -1;
484}
485
486/*------------------------------------------------------------------------------
487 ReadFunc
488*/
489
490static int read_input(int msgno_invalid_token) {
491 int token;
492 char *p;
493
494 token = HECMW_ablex_next_token();
495 if (token != '=') {
496 set_err_token(token, msgno_invalid_token, "'=' required after INPUT");
497 return -1;
498 }
499 token = HECMW_ablex_next_token();
500 if (token != HECMW_ABLEX_FILENAME && token != HECMW_ABLEX_NAME) {
501 set_err_token(token, msgno_invalid_token, "Invalid filename for INPUT");
502 return -1;
503 }
505 if (strlen(p) > HECMW_FILENAME_LEN) {
506 set_err(HECMW_IO_E0002, "");
507 return -1;
508 }
509 if (HECMW_is_absolute_path(p)) {
510 strcpy(include_filename, p);
511 } else {
512 char separator[10];
513 char *dname = HECMW_dirname(grid_filename);
514 sprintf(separator, "%c", HECMW_get_path_separator());
515 if (strlen(dname) + strlen(separator) + strlen(p) > HECMW_FILENAME_LEN) {
516 set_err(HECMW_IO_E0002, "");
517 return -1;
518 }
519 sprintf(include_filename, "%s%s%s", dname, separator, p);
520 }
521 return 0;
522}
523
524/*----------------------------------------------------------------------------*/
525
526static int read_amplitude_keyword(void) {
527 int token;
528
529 /* *AMPLITUDE */
530 token = HECMW_ablex_next_token();
531 if (token != HECMW_ABLEX_H_AMPLITUDE) {
532 set_err_token(token, HECMW_IO_ABAQUS_E0100, "*AMPLITUDE required");
533 return -1;
534 }
535
536 token = HECMW_ablex_next_token();
537 if (token != ',') {
538 set_err_token(token, HECMW_IO_ABAQUS_E0100,
539 "',' required after *AMPLITUDE");
540 return -1;
541 }
542 return 0;
543}
544
545static int read_amplitude_param_name(char *name) {
546 int token;
547 char *p;
548
549 token = HECMW_ablex_next_token();
550 if (token != '=') {
551 set_err_token(token, HECMW_IO_ABAQUS_E0100, "'=' required after NAME");
552 return -1;
553 }
554 token = HECMW_ablex_next_token();
555 if (token != HECMW_ABLEX_NAME) {
556 set_err_token(token, HECMW_IO_ABAQUS_E0100,
557 "NAME must begin with a letter");
558 return -1;
559 }
561 if (strlen(p) > HECMW_NAME_LEN) {
562 set_err(HECMW_IO_E0001, "");
563 return -1;
564 }
565 strcpy(name, p);
566 HECMW_toupper(name);
567 if (HECMW_io_is_reserved_name(name)) {
568 set_err(HECMW_IO_E0003, "");
569 return -1;
570 }
571 return 0;
572}
573
574static int read_amplitude_param_definition(int *definition) {
575 int token;
576
577 token = HECMW_ablex_next_token();
578 if (token != '=') {
579 set_err_token(token, HECMW_IO_ABAQUS_E0100,
580 "'=' required after DEFINITION");
581 return -1;
582 }
583 token = HECMW_ablex_next_token();
584 if (token != HECMW_ABLEX_K_TABULAR) {
585 set_err_token(token, HECMW_IO_ABAQUS_E0100, "Invalid DEFINITION");
586 return -1;
587 }
588 *definition = HECMW_AMP_TYPEDEF_TABULAR;
589 return 0;
590}
591
592static int read_amplitude_param_time(int *time) {
593 int token;
594
595 token = HECMW_ablex_next_token();
596 if (token != '=') {
597 set_err_token(token, HECMW_IO_ABAQUS_E0100, "'=' after TIME required");
598 return -1;
599 }
600 token = HECMW_ablex_next_token();
601 if (token != HECMW_ABLEX_K_STEP_TIME) {
602 set_err_token(token, HECMW_IO_ABAQUS_E0100, "Invalid TIME");
603 return -1;
604 }
606 return 0;
607}
608
609static int read_amplitude_param_value(int *value) {
610 int token;
611
612 token = HECMW_ablex_next_token();
613 if (token != '=') {
614 set_err_token(token, HECMW_IO_ABAQUS_E0100, "'=' required after VALUE");
615 return -1;
616 }
617 token = HECMW_ablex_next_token();
618 if (token == HECMW_ABLEX_K_RELATIVE) {
620 } else if (token == HECMW_ABLEX_K_ABSOLUTE) {
622 } else {
623 set_err_token(token, HECMW_IO_ABAQUS_E0100, "Invalid VALUE");
624 return -1;
625 }
626 return 0;
627}
628
629static int read_amplitude_data(char *name, int definition, int time,
630 int value) {
631 int i, token;
632 enum { NITEM = 4 };
633
634 i = 0;
635 while (1) {
636 double val, t;
637
638 token = HECMW_ablex_next_token();
639 if (i != 0 && token == HECMW_ABLEX_NL) break;
640 /* T */
641 if (token != HECMW_ABLEX_DOUBLE && token != HECMW_ABLEX_INT &&
642 token != ',') {
643 set_err_token(token, HECMW_IO_ABAQUS_E0100, "T required");
644 return -1;
645 }
646 if (token == ',') {
647 t = 0.0;
649 } else {
651 }
652
653 /* ',' */
654 token = HECMW_ablex_next_token();
655 if (token != ',') {
656 set_err_token(token, HECMW_IO_ABAQUS_E0100, "',' required after T");
657 return -1;
658 }
659
660 /* VAL */
661 token = HECMW_ablex_next_token();
662 if (token != HECMW_ABLEX_DOUBLE && token != HECMW_ABLEX_INT &&
663 token != ',' && token != HECMW_ABLEX_NL) {
664 set_err_token(token, HECMW_IO_ABAQUS_E0100, "VAL required");
665 return -1;
666 }
667 if (token == ',' || token == HECMW_ABLEX_NL) {
668 val = 0.0;
670 } else {
672 }
673
674 /* add */
675 if (HECMW_io_add_amp(name, definition, time, value, val, t) == NULL)
676 return -1;
677
678 i++;
679
680 /* ',' or NL */
681 token = HECMW_ablex_next_token();
682 if (token != ',' && token != HECMW_ABLEX_NL) {
683 set_err_token(token, HECMW_IO_ABAQUS_E0100, "',' or NL required");
684 return -1;
685 }
686 if (token == ',' && i == NITEM) {
687 token = HECMW_ablex_next_token();
688 if (token != HECMW_ABLEX_NL) {
689 set_err_token(token, HECMW_IO_ABAQUS_E0100,
690 "Only %d items allow per line", NITEM);
691 return -1;
692 }
693 break;
694 }
695 if (token == HECMW_ABLEX_NL) break;
696 }
697
698 return 0;
699}
700
701static int read_amplitude(void) {
702 int token, state;
703 int definition = HECMW_AMP_TYPEDEF_TABULAR;
704 int time = HECMW_AMP_TYPETIME_STEP;
705 int value = HECMW_AMP_TYPEVAL_RELATIVE;
706 int flag_name = 0; /* flag for NAME */
707 int flag_definition = 0; /* flag for DEFINITION */
708 int flag_time = 0; /* flag for TIME */
709 int flag_value = 0; /* flag for VALUE */
710 int flag_input = 0; /* flag for INPUT */
711 char name[HECMW_NAME_LEN + 1] = "";
712 enum {
713 ST_FINISHED,
714 ST_KEYWORD_LINE,
715 ST_KEYWORD_LINE_PARAM,
716 ST_DATA_INCLUDE,
717 ST_DATA_LINE
718 };
719
720 state = ST_KEYWORD_LINE;
721 while (state != ST_FINISHED) {
722 if (state == ST_KEYWORD_LINE) {
723 if (read_amplitude_keyword()) return -1;
724 state = ST_KEYWORD_LINE_PARAM;
725 } else if (state == ST_KEYWORD_LINE_PARAM) {
726 token = HECMW_ablex_next_token();
727 if (token == HECMW_ABLEX_K_NAME) {
728 /* must */
729 if (read_amplitude_param_name(name)) return -1;
730 flag_name = 1;
731 } else if (token == HECMW_ABLEX_K_DEFINITION) {
732 /* optional */
733 if (read_amplitude_param_definition(&definition)) return -1;
734 flag_definition = 1;
735 } else if (token == HECMW_ABLEX_K_TIME) {
736 /* optional */
737 if (read_amplitude_param_time(&time)) return -1;
738 flag_time = 1;
739 } else if (token == HECMW_ABLEX_K_VALUE) {
740 /* optional */
741 if (read_amplitude_param_value(&value)) return -1;
742 flag_value = 1;
743 } else if (token == HECMW_ABLEX_K_INPUT) {
744 /* optional */
745 if (read_input(HECMW_IO_ABAQUS_E0100)) return -1;
746 flag_input = 1;
747 } else {
748 set_err_token(token, HECMW_IO_ABAQUS_E0100, "Unknown paramter");
749 return -1;
750 }
751
752 /* check next state */
753 token = HECMW_ablex_next_token();
754 if (token == HECMW_ABLEX_NL) {
755 /* check NAME */
756 if (!flag_name) {
757 set_err(HECMW_IO_ABAQUS_E0101, "");
758 return -1;
759 }
760 state = flag_input ? ST_DATA_INCLUDE : ST_DATA_LINE;
761 } else if (token == ',') {
762 ; /* continue this state */
763 } else {
764 set_err_token(token, HECMW_IO_ABAQUS_E0100, "Unknown paramter");
765 return -1;
766 }
767 } else if (state == ST_DATA_INCLUDE) {
768 HECMW_assert(flag_input);
769 HECMW_assert(flag_name);
770 if (HECMW_ablex_switch_to_include(include_filename)) return -1;
771 state = ST_DATA_LINE;
772 } else if (state == ST_DATA_LINE) {
773 HECMW_assert(flag_name);
774
775 if (read_amplitude_data(name, definition, time, value)) return -1;
776
777 token = HECMW_ablex_next_token();
778 if (token != HECMW_ABLEX_DOUBLE && token != HECMW_ABLEX_INT &&
779 token != ',') {
780 state = ST_FINISHED;
781 }
783 } else {
784 HECMW_assert(0);
785 }
786 }
787 return 0;
788}
789
790/*----------------------------------------------------------------------------*/
791#if 0
792static int
793read_ecopy(void)
794{
795 fprintf(stderr, "*ECOPY has not implemented yet\n");
797 return 0;
798}
799
800
801/*----------------------------------------------------------------------------*/
802
803static int
804read_egen(void)
805{
806 fprintf(stderr, "*EGEN has not implemented yet\n");
808 return 0;
809}
810#endif
811
812/*----------------------------------------------------------------------------*/
813
814static int read_elset_keyword(void) {
815 int token;
816
817 /* *ELSET */
818 token = HECMW_ablex_next_token();
819 if (token != HECMW_ABLEX_H_ELSET) {
820 set_err_token(token, HECMW_IO_ABAQUS_E0500, "*ELSET required");
821 return -1;
822 }
823
824 token = HECMW_ablex_next_token();
825 if (token != ',') {
826 set_err_token(token, HECMW_IO_ABAQUS_E0500, "',' required after *ELSET");
827 return -1;
828 }
829 return 0;
830}
831
832static int read_elset_param_elset(char *elset, int *isAll) {
833 int token;
834 char *p;
835
836 token = HECMW_ablex_next_token();
837 if (token != '=') {
838 set_err_token(token, HECMW_IO_ABAQUS_E0500, "'=' required after ELSET");
839 return -1;
840 }
841 token = HECMW_ablex_next_token();
842 if (token != HECMW_ABLEX_NAME) {
843 set_err_token(token, HECMW_IO_ABAQUS_E0500,
844 "ELSET must begin with a letter");
845 return -1;
846 }
848 if (strlen(p) > HECMW_NAME_LEN) {
849 set_err(HECMW_IO_E0001, "");
850 return -1;
851 }
852 strcpy(elset, p);
853 HECMW_toupper(elset);
854 if (HECMW_io_is_reserved_name(elset)) {
855 set_err(HECMW_IO_E0003, "");
856 return -1;
857 }
858 if (strcmp(elset, "ALL") == 0) {
859 *isAll = 1;
861 // return -1;
862 }
863 return 0;
864}
865
866static int read_elset_data(int *nelem, int **elem_array) {
867 int token, i, n, *elem;
868 struct hecmw_io_id *head, *prev, *p, *q;
869
870 n = 0;
871 prev = NULL;
872 head = NULL;
873 elem = NULL;
874 while (1) {
875 struct hecmw_io_id *id;
876
877 token = HECMW_ablex_next_token();
878 if (n != 0 && token == HECMW_ABLEX_NL) break;
879
880 id = HECMW_malloc(sizeof(*id));
881 if (id == NULL) {
882 set_err(errno, "");
883 goto error;
884 }
885
886 /* elemX */
887 if (token != HECMW_ABLEX_INT) {
888 set_err_token(token, HECMW_IO_ABAQUS_E0500, "Element ID required");
889 goto error;
890 }
891 id->id = HECMW_ablex_get_number();
892 id->next = NULL;
893 if (head == NULL) {
894 head = id;
895 } else {
896 prev->next = id;
897 }
898 prev = id;
899 n++;
900
901 /* ',' or NL */
902 token = HECMW_ablex_next_token();
903 if (token != ',' && token != HECMW_ABLEX_NL) {
904 set_err_token(token, HECMW_IO_ABAQUS_E0500,
905 "',' or NL required after element ID");
906 goto error;
907 }
908 if (token == HECMW_ABLEX_NL) break;
909 }
911 HECMW_assert(n > 0);
912
913 /* add elem to group */
914 elem = HECMW_malloc(sizeof(*elem) * n);
915 if (elem == NULL) {
916 set_err(errno, "");
917 goto error;
918 }
919 i = 0;
920 for (p = head; p; p = q) {
921 q = p->next;
922 elem[i++] = p->id;
923 HECMW_free(p);
924 }
925 head = NULL;
926
927 *nelem = n;
928 *elem_array = elem;
929 return 0;
930error:
931 for (p = head; p; p = q) {
932 q = p->next;
933 HECMW_free(p);
934 }
935 HECMW_free(elem);
936 return -1;
937}
938
939static int read_elset_data_generate(int *nelem, int **elem_array) {
940 int token, i, n, id, *elem;
941 int elem1, elem2, elem3;
942
943 /* elem1 */
944 token = HECMW_ablex_next_token();
945 if (token != HECMW_ABLEX_INT) {
946 set_err_token(token, HECMW_IO_ABAQUS_E0500, "elem1 required");
947 return -1;
948 }
949 elem1 = HECMW_ablex_get_number();
950 if (elem1 <= 0) {
951 set_err(HECMW_IO_ABAQUS_E0502, "");
952 return -1;
953 }
954
955 /* ',' */
956 token = HECMW_ablex_next_token();
957 if (token != ',') {
958 set_err_token(token, HECMW_IO_ABAQUS_E0500, "',' required after elem1");
959 return -1;
960 }
961
962 /* elem2 */
963 token = HECMW_ablex_next_token();
964 if (token != HECMW_ABLEX_INT) {
965 set_err_token(token, HECMW_IO_ABAQUS_E0500, "elem2 required");
966 return -1;
967 }
968 elem2 = HECMW_ablex_get_number();
969 if (elem2 <= 0) {
970 set_err(HECMW_IO_ABAQUS_E0502, "");
971 return -1;
972 }
973
974 /* ',' or NL */
975 token = HECMW_ablex_next_token();
976 if (token == ',') {
977 /* elem3 */
978 token = HECMW_ablex_next_token();
979 if (token != HECMW_ABLEX_INT) {
980 set_err_token(token, HECMW_IO_ABAQUS_E0500, "Increment required");
981 return -1;
982 }
983 elem3 = HECMW_ablex_get_number();
984 if (elem3 <= 0) {
985 set_err(HECMW_IO_ABAQUS_E0502, "");
986 return -1;
987 }
988
989 /* NL */
990 token = HECMW_ablex_next_token();
991 if (token != HECMW_ABLEX_NL) {
992 set_err_token(token, HECMW_IO_ABAQUS_E0500,
993 "NL required after increment");
994 return -1;
995 }
996 } else if (token == HECMW_ABLEX_NL) {
997 elem3 = 1;
998 } else {
999 set_err_token(token, HECMW_IO_ABAQUS_E0500,
1000 "',' or NL required after elem2");
1001 return -1;
1002 }
1003 HECMW_assert(token == HECMW_ABLEX_NL);
1004
1005 /* make element */
1006 if (elem1 > elem2) {
1007 set_err(HECMW_IO_ABAQUS_E0503,
1008 "Cannot generate between %d and %d with an increment of %d", elem1,
1009 elem2, elem3);
1010 return -1;
1011 }
1012 if ((elem2 - elem1) % elem3) {
1013 set_err(HECMW_IO_ABAQUS_E0503,
1014 "Cannot generate between %d and %d with an increment of %d", elem1,
1015 elem2, elem3);
1016 return -1;
1017 }
1018
1019 n = (elem2 - elem1) / elem3 + 1;
1020 elem = HECMW_malloc(sizeof(*elem) * n);
1021 if (elem == NULL) {
1022 set_err(errno, "");
1023 return -1;
1024 }
1025
1026 i = 0;
1027 for (id = elem1; id <= elem2; id += elem3) {
1028 elem[i++] = id;
1029 }
1030 HECMW_assert(i == n);
1031
1032 *nelem = n;
1033 *elem_array = elem;
1034 return 0;
1035}
1036
1037static int read_elset(void) {
1038 int token, state;
1039 int flag_elset = 0; /* flag for ELSET */
1040 int flag_generate = 0; /* flag for GENERATE */
1041 int isAll = 0;
1042 char elset[HECMW_NAME_LEN + 1] = "";
1043 enum {
1044 ST_FINISHED,
1045 ST_KEYWORD_LINE,
1046 ST_KEYWORD_LINE_PARAM,
1047 ST_DATA_LINE,
1048 ST_DATA_LINE_GENERATE
1049 };
1050
1051 state = ST_KEYWORD_LINE;
1052 while (state != ST_FINISHED) {
1053 if (state == ST_KEYWORD_LINE) {
1054 if (read_elset_keyword()) return -1;
1055 state = ST_KEYWORD_LINE_PARAM;
1056 } else if (state == ST_KEYWORD_LINE_PARAM) {
1057 token = HECMW_ablex_next_token();
1058 if (token == HECMW_ABLEX_K_ELSET) {
1059 /* must */
1060 if (read_elset_param_elset(elset, &isAll)) return -1;
1061 flag_elset = 1;
1062 } else if (token == HECMW_ABLEX_K_GENERATE) {
1063 /* oprtional */
1064 flag_generate = 1;
1065 } else {
1066 set_err_token(token, HECMW_IO_ABAQUS_E0500, "Unknown parameter");
1067 return -1;
1068 }
1069
1070 /* check next parameter */
1071 token = HECMW_ablex_next_token();
1072 if (token == HECMW_ABLEX_NL) {
1073 /* check */
1074 if (!flag_elset) {
1075 set_err(HECMW_IO_ABAQUS_E0501, "");
1076 return -1;
1077 }
1078 state = flag_generate ? ST_DATA_LINE_GENERATE : ST_DATA_LINE;
1079 } else if (token == ',') {
1080 ; /* continue this state */
1081 } else {
1082 set_err_token(token, HECMW_IO_ABAQUS_E0500, "Unknown parameter");
1083 return -1;
1084 }
1085 } else if (state == ST_DATA_LINE) {
1086 int n, *elem;
1087
1088 HECMW_assert(!flag_generate);
1089 HECMW_assert(flag_elset);
1090
1091 if (read_elset_data(&n, &elem)) return -1;
1092
1093 if (HECMW_io_add_egrp(elset, n, elem) < 0) return -1;
1094 HECMW_free(elem);
1095
1096 /* check next state */
1097 token = HECMW_ablex_next_token();
1098 if (token != HECMW_ABLEX_INT) {
1099 state = ST_FINISHED;
1100 } else {
1101 state = ST_DATA_LINE;
1102 }
1104 } else if (state == ST_DATA_LINE_GENERATE) {
1105 int n, *elem;
1106
1107 HECMW_assert(flag_generate);
1108 HECMW_assert(flag_elset);
1109
1110 if (read_elset_data_generate(&n, &elem)) return -1;
1111
1112 if (HECMW_io_add_egrp(elset, n, elem) < 0) return -1;
1113 HECMW_free(elem);
1114
1115 /* check next state */
1116 token = HECMW_ablex_next_token();
1117 if (token != HECMW_ABLEX_INT) {
1118 state = ST_FINISHED;
1119 }
1121 } else {
1122 HECMW_assert(0);
1123 }
1124 }
1125 return 0;
1126}
1127
1128/*----------------------------------------------------------------------------*/
1129
1130static int read_element_header(void) {
1131 int token;
1132
1133 /* *ELEMENT */
1134 token = HECMW_ablex_next_token();
1135 if (token != HECMW_ABLEX_H_ELEMENT) {
1136 set_err_token(token, HECMW_IO_ABAQUS_E0600, "*ELEMENT required");
1137 return -1;
1138 }
1139
1140 token = HECMW_ablex_next_token();
1141 if (token != ',') {
1142 set_err_token(token, HECMW_IO_ABAQUS_E0600, "',' required after *ELEMENT");
1143 return -1;
1144 }
1145 return 0;
1146}
1147
1148static int read_element_param_type(int *hecmw_etype, int *abaqus_etype) {
1149 int token;
1150
1151 token = HECMW_ablex_next_token();
1152 if (token != '=') {
1153 set_err_token(token, HECMW_IO_ABAQUS_E0600, "'=' required after TYPE");
1154 return -1;
1155 }
1156 token = HECMW_ablex_next_token();
1157 *abaqus_etype = token;
1158 *hecmw_etype = get_HECMW_etype(*abaqus_etype);
1159 if (*hecmw_etype == -1) {
1160 set_err(HECMW_IO_ABAQUS_E0601, "Invalid type: %s", HECMW_ablex_get_text());
1161 return -1;
1162 }
1163 if (HECMW_get_max_node(*hecmw_etype) == -1) {
1164 set_err(HECMW_IO_ABAQUS_E0601, "Invalid type: %s", HECMW_ablex_get_text());
1165 return -1;
1166 }
1167 return 0;
1168}
1169
1170static int read_element_param_elset(char *elset) {
1171 char *p;
1172 int token;
1173
1174 token = HECMW_ablex_next_token();
1175 if (token != '=') {
1176 set_err_token(token, HECMW_IO_ABAQUS_E0600, "'=' required after ELSET");
1177 return -1;
1178 }
1179 token = HECMW_ablex_next_token();
1180 if (token != HECMW_ABLEX_NAME) {
1181 set_err_token(token, HECMW_IO_ABAQUS_E0600,
1182 "ELSET must begin with a letter");
1183 return -1;
1184 }
1186 if (strlen(p) > HECMW_NAME_LEN) {
1187 set_err(HECMW_IO_E0001, "");
1188 return -1;
1189 }
1190 strcpy(elset, p);
1191 HECMW_toupper(elset);
1192 if (HECMW_io_is_reserved_name(elset)) {
1193 set_err(HECMW_IO_E0003, "");
1194 return -1;
1195 }
1196 if (strcmp(elset, "ALL") == 0) {
1198 strcpy(elset, "ABAQUS_ESET_ALL");
1199 // return -1;
1200 }
1201 return 0;
1202}
1203
1204static int read_element_data(int *id, int nnode, int *node) {
1205 int token, i;
1206
1207 /* element ID */
1208 *id = 0;
1209 token = HECMW_ablex_next_token();
1210 if (token == ',') {
1212 } else if (token == HECMW_ABLEX_INT) {
1213 *id = HECMW_ablex_get_number();
1214 } else {
1215 set_err_token(token, HECMW_IO_ABAQUS_E0600, "");
1216 return -1;
1217 }
1218 if (*id <= 0) {
1219 set_err_token(token, HECMW_IO_ABAQUS_E0603, "");
1220 return -1;
1221 }
1222
1223 /* ',' */
1224 token = HECMW_ablex_next_token();
1225 if (token != ',') {
1226 set_err_token(token, HECMW_IO_ABAQUS_E0600, "',' required after elment ID");
1227 return -1;
1228 }
1229
1230 /* connectivity */
1231 i = 0;
1232 while (1) {
1233 token = HECMW_ablex_next_token();
1234 if (i != 0 && token == HECMW_ABLEX_NL) continue;
1235 node[i] = 0;
1236 if (token == ',') {
1238 } else if (token == HECMW_ABLEX_INT) {
1239 node[i] = HECMW_ablex_get_number();
1240 } else {
1241 set_err(HECMW_IO_ABAQUS_E0600, "");
1242 return -1;
1243 }
1244 if (node[i] <= 0) {
1245 set_err(HECMW_IO_ABAQUS_E0604, "");
1246 return -1;
1247 }
1248
1249 if (i == nnode - 1) break;
1250
1251 /* ',' or NL */
1252 token = HECMW_ablex_next_token();
1253 if (token != ',' && token != HECMW_ABLEX_NL) {
1254 set_err_token(token, HECMW_IO_ABAQUS_E0600,
1255 "',' or NL required after connectivity");
1256 return -1;
1257 }
1258
1259 i++;
1260 }
1261
1262 /* ',' */
1263 token = HECMW_ablex_next_token();
1264 if (token != ',') HECMW_ablex_unput_token();
1265 /* NL */
1266 token = HECMW_ablex_next_token();
1267 if (token != HECMW_ABLEX_NL) {
1268 set_err_token(token, HECMW_IO_ABAQUS_E0600, "NL required");
1269 return -1;
1270 }
1271
1272 return 0;
1273}
1274
1275static int read_element(void) {
1276 int token, state;
1277 int id;
1278 int nnode = 0;
1279 int node[HECMW_MAX_NODE_MAX];
1280 int type = -1; /* ABAQUS element type by LEX parameter */
1281 int hecmw_etype = -1; /* HEC-MW element type */
1282 int flag_type = 0; /* flag for TYPE */
1283 int flag_elset = 0; /* flag for ELSET */
1284 int flag_input = 0; /* flag for INPUT */
1285 char elset[HECMW_NAME_LEN + 1] = "";
1286 enum {
1287 ST_FINISHED,
1288 ST_KEYWORD_LINE,
1289 ST_KEYWORD_LINE_PARAM,
1290 ST_DATA_INCLUDE,
1291 ST_DATA_LINE,
1292 ST_DATA_LINE_REGIST
1293 };
1294
1295 state = ST_KEYWORD_LINE;
1296 while (state != ST_FINISHED) {
1297 if (state == ST_KEYWORD_LINE) {
1298 if (read_element_header()) return -1;
1299 state = ST_KEYWORD_LINE_PARAM;
1300 } else if (state == ST_KEYWORD_LINE_PARAM) {
1301 token = HECMW_ablex_next_token();
1302 if (token == HECMW_ABLEX_K_TYPE) {
1303 /* must */
1304 if (read_element_param_type(&hecmw_etype, &type)) return -1;
1305 flag_type = 1;
1306
1307 /* get # of connectivity */
1309 HECMW_assert(nnode > 0);
1311 } else if (token == HECMW_ABLEX_K_ELSET) {
1312 /* optional */
1313 if (read_element_param_elset(elset)) return -1;
1314 flag_elset = 1;
1315 } else if (token == HECMW_ABLEX_K_INPUT) {
1316 /* optional */
1317 if (read_input(HECMW_IO_ABAQUS_E0600)) return -1;
1318 flag_input = 1;
1319 } else {
1320 set_err_token(token, HECMW_IO_ABAQUS_E0600, "Unknown parameter");
1321 return -1;
1322 }
1323
1324 /* check next state */
1325 token = HECMW_ablex_next_token();
1326 if (token == HECMW_ABLEX_NL) {
1327 /* check TYPE */
1328 if (!flag_type) {
1329 set_err(HECMW_IO_ABAQUS_E0606, "");
1330 return -1;
1331 }
1332 state = flag_input ? ST_DATA_INCLUDE : ST_DATA_LINE;
1333 } else if (token == ',') {
1334 ; /* continue this state */
1335 } else {
1336 set_err_token(token, HECMW_IO_ABAQUS_E0600, "Unknown parameter");
1337 return -1;
1338 }
1339 } else if (state == ST_DATA_INCLUDE) {
1340 HECMW_assert(flag_input);
1341 HECMW_assert(flag_type);
1342 if (HECMW_ablex_switch_to_include(include_filename)) return -1;
1343 state = ST_DATA_LINE;
1344 } else if (state == ST_DATA_LINE) {
1345 HECMW_assert(flag_type);
1346 if (read_element_data(&id, nnode, node)) return -1;
1347 state = ST_DATA_LINE_REGIST;
1348 } else if (state == ST_DATA_LINE_REGIST) {
1349 Integer *secopt;
1350
1351 HECMW_assert(flag_type);
1352
1353 /* convert connectivity */
1355 return -1;
1356
1357 /* add element */
1358 if (HECMW_io_add_elem(id, hecmw_etype, node, 0, NULL) == NULL) return -1;
1359
1360 /* save secopt */
1361 secopt = HECMW_malloc(sizeof(*secopt));
1362 if (secopt == NULL) {
1363 set_err(errno, "");
1364 return -1;
1365 }
1366 secopt->i = get_secopt_abaqus(type);
1367 HECMW_assert(secopt->i != -1);
1368 if (elem_secopt == NULL) {
1369 elem_secopt =
1370 (struct hecmw_map_int *)HECMW_malloc(sizeof(struct hecmw_map_int));
1371 if (elem_secopt == NULL) return -1;
1372 if (HECMW_map_int_init(elem_secopt, free_Integer)) return -1;
1373 }
1374 if (HECMW_map_int_add(elem_secopt, id, secopt) < 0) return -1;
1375
1376 /* add element to egroup */
1377 if (HECMW_io_add_egrp("ALL", 1, &id) < 0) return -1;
1378
1379 if (flag_elset) {
1380 if (HECMW_io_add_egrp(elset, 1, &id) < 0) return -1;
1381 }
1382
1383 /* check next state */
1384 token = HECMW_ablex_next_token();
1385 if (token == HECMW_ABLEX_INT) {
1386 state = ST_DATA_LINE;
1387 } else {
1388 state = ST_FINISHED;
1389 }
1391 } else {
1392 HECMW_assert(0);
1393 }
1394 }
1395 return 0;
1396}
1397
1398/*----------------------------------------------------------------------------*/
1399
1400static int read_equation_keyword(int *token) {
1401 /* *EQUATION */
1402 *token = HECMW_ablex_next_token();
1403 if (*token != HECMW_ABLEX_H_EQUATION) {
1404 set_err_token(*token, HECMW_IO_ABAQUS_E0700, "*EQUATION required");
1405 return -1;
1406 }
1407 *token = HECMW_ablex_next_token();
1408 if (*token != ',' && *token != HECMW_ABLEX_NL) {
1409 set_err_token(*token, HECMW_IO_ABAQUS_E0700,
1410 "',' or NL required after *EQUATION");
1411 return -1;
1412 }
1413 return 0;
1414}
1415
1416static int read_equation_data_line1(int *neq) {
1417 int token;
1418
1419 /* NEQ */
1420 token = HECMW_ablex_next_token();
1421 if (token != HECMW_ABLEX_INT) {
1422 set_err_token(token, HECMW_IO_ABAQUS_E0700, "required NEQ");
1423 return -1;
1424 }
1425 *neq = HECMW_ablex_get_number();
1426 if (*neq < 2) {
1427 set_err(HECMW_IO_ABAQUS_E0701, "");
1428 return -1;
1429 }
1430
1431 /* NL */
1432 token = HECMW_ablex_next_token();
1433 if (token != HECMW_ABLEX_NL) {
1434 set_err_token(token, HECMW_IO_ABAQUS_E0700, "NL required after NEQ");
1435 return -1;
1436 }
1437 return 0;
1438}
1439
1440static int read_equation_data_line2(int neq) {
1441 int i, token;
1442 int is_node = 0;
1443 int is_ngrp = 0;
1444 enum { NITEM = 4 };
1445 struct hecmw_io_mpcitem *mpcitem = NULL;
1446
1447 mpcitem = HECMW_malloc(sizeof(*mpcitem) * neq);
1448 if (mpcitem == NULL) {
1449 set_err(errno, "");
1450 goto error;
1451 }
1452
1453 for (i = 0; i < neq; i++) {
1454 token = HECMW_ablex_next_token();
1455 if (i != 0 && token == HECMW_ABLEX_NL) break;
1456
1457 /* nod */
1458 if (token == HECMW_ABLEX_INT) {
1459 if (is_ngrp) {
1460 set_err(HECMW_IO_ABAQUS_E0702, "");
1461 goto error;
1462 }
1463 mpcitem[i].node = HECMW_ablex_get_number();
1464 strcpy(mpcitem[i].ngrp, "");
1465 is_node = 1;
1466 } else if (token == HECMW_ABLEX_NAME) {
1467 char *p = HECMW_ablex_get_text();
1468 if (is_node) {
1469 set_err(HECMW_IO_ABAQUS_E0702, "");
1470 goto error;
1471 }
1472 if (strlen(p) > HECMW_NAME_LEN) {
1473 set_err(HECMW_IO_E0001, "");
1474 goto error;
1475 }
1476 strcpy(mpcitem[i].ngrp, p);
1477 HECMW_toupper(mpcitem[i].ngrp);
1478 if (HECMW_io_is_reserved_name(mpcitem[i].ngrp)) {
1479 set_err(HECMW_IO_E0003, "");
1480 goto error;
1481 }
1482 mpcitem[i].node = -1;
1483 is_ngrp = 1;
1484 } else {
1485 set_err_token(token, HECMW_IO_ABAQUS_E0700, "Node ID or NGRP required");
1486 goto error;
1487 }
1488
1489 /* ',' */
1490 token = HECMW_ablex_next_token();
1491 if (token != ',') {
1492 set_err_token(token, HECMW_IO_ABAQUS_E0700, "',' required after node");
1493 goto error;
1494 }
1495
1496 /* DOF */
1497 token = HECMW_ablex_next_token();
1498 if (token != HECMW_ABLEX_INT) {
1499 set_err(HECMW_IO_ABAQUS_E0703, "");
1500 goto error;
1501 }
1502 mpcitem[i].dof = HECMW_ablex_get_number();
1503 if (HECMW_io_check_mpc_dof(mpcitem[i].dof)) {
1504 set_err(HECMW_IO_ABAQUS_E0703, "");
1505 goto error;
1506 }
1507
1508 /* ',' */
1509 token = HECMW_ablex_next_token();
1510 if (token != ',') {
1511 set_err_token(token, HECMW_IO_ABAQUS_E0700, "',' required after DOF");
1512 goto error;
1513 }
1514
1515 /* A */
1516 token = HECMW_ablex_next_token();
1517 if (token != HECMW_ABLEX_DOUBLE && token != HECMW_ABLEX_INT) {
1518 set_err_token(token, HECMW_IO_ABAQUS_E0700, "A(coefficient) required ");
1519 goto error;
1520 }
1521 mpcitem[i].a = HECMW_ablex_get_number();
1522
1523 /* ',' or NL */
1524 token = HECMW_ablex_next_token();
1525 if (token != ',' && token != HECMW_ABLEX_NL) {
1526 set_err_token(token, HECMW_IO_ABAQUS_E0700,
1527 "',' or NL required after coefficient");
1528 goto error;
1529 }
1530 if (token == ',' && i == NITEM - 1) {
1531 token = HECMW_ablex_next_token();
1532 if (token != HECMW_ABLEX_NL) {
1533 set_err_token(token, HECMW_IO_ABAQUS_E0700, "NL required");
1534 goto error;
1535 }
1536 continue;
1537 }
1538 if (token == HECMW_ABLEX_NL) continue;
1539 }
1540
1541 /* add */
1542 if (HECMW_io_add_mpc(neq, mpcitem, 0.0) == NULL) goto error;
1543 HECMW_free(mpcitem);
1544 return 0;
1545error:
1546 HECMW_free(mpcitem);
1547 return -1;
1548}
1549
1550static int read_equation(void) {
1551 int token, state;
1552 int neq = -1;
1553 int flag_input = 0; /* flag for INPUT */
1554 enum {
1555 ST_FINISHED,
1556 ST_KEYWORD_LINE,
1557 ST_KEYWORD_LINE_PARAM,
1558 ST_DATA_INCLUDE,
1559 ST_DATA_LINE1,
1560 ST_DATA_LINE2
1561 };
1562
1563 state = ST_KEYWORD_LINE;
1564 while (state != ST_FINISHED) {
1565 if (state == ST_KEYWORD_LINE) {
1566 if (read_equation_keyword(&token)) return -1;
1567 if (token == ',') {
1568 state = ST_KEYWORD_LINE_PARAM;
1569 } else if (token == HECMW_ABLEX_NL) {
1570 state = ST_DATA_LINE1;
1571 } else {
1572 HECMW_assert(0);
1573 }
1574 } else if (state == ST_KEYWORD_LINE_PARAM) {
1575 token = HECMW_ablex_next_token();
1576 if (token == HECMW_ABLEX_K_INPUT) {
1577 /* optional */
1578 if (read_input(HECMW_IO_ABAQUS_E0700)) return -1;
1579 flag_input = 1;
1580 } else {
1581 set_err_token(token, HECMW_IO_ABAQUS_E0700, "Unknown parameter");
1582 return -1;
1583 }
1584
1585 /* check next state */
1586 token = HECMW_ablex_next_token();
1587 if (token == HECMW_ABLEX_NL) {
1588 state = flag_input ? ST_DATA_INCLUDE : ST_DATA_LINE1;
1589 } else {
1590 set_err_token(token, HECMW_IO_ABAQUS_E0700, "NL required");
1591 return -1;
1592 }
1593 } else if (state == ST_DATA_INCLUDE) {
1594 HECMW_assert(flag_input);
1595 if (HECMW_ablex_switch_to_include(include_filename)) return -1;
1596 state = ST_DATA_LINE1;
1597 } else if (state == ST_DATA_LINE1) {
1598 if (read_equation_data_line1(&neq)) return -1;
1599 /* set next state */
1600 state = ST_DATA_LINE2;
1601 } else if (state == ST_DATA_LINE2) {
1602 HECMW_assert(neq != -1);
1603 if (read_equation_data_line2(neq)) return -1;
1604 /* check next state */
1605 token = HECMW_ablex_next_token();
1606 if (token == HECMW_ABLEX_INT) {
1607 state = ST_DATA_LINE1;
1608 } else {
1609 state = ST_FINISHED;
1610 }
1612 } else {
1613 HECMW_assert(0);
1614 }
1615 }
1616 return 0;
1617}
1618
1619/*----------------------------------------------------------------------------*/
1620
1621static int read_heading(void) {
1622 int token, len;
1623 char *p;
1624 struct hecmw_io_header *header;
1625
1626 header = HECMW_malloc(sizeof(struct hecmw_io_header));
1627 if (header == NULL) {
1628 set_err(errno, "");
1629 return -1;
1630 }
1631
1632 /* *HEADING */
1633 token = HECMW_ablex_next_token();
1634 if (token != HECMW_ABLEX_H_HEADING) {
1635 set_err_token(token, HECMW_IO_ABAQUS_E0800, "*HEADING required");
1636 return -1;
1637 }
1638
1639 /* get header data */
1640 token = HECMW_ablex_next_token();
1641 if (token != HECMW_ABLEX_HEADER) {
1642 set_err_token(token, HECMW_IO_ABAQUS_E0800,
1643 "TITLE required after *HEADING");
1644 return -1;
1645 /* set_err_token(token, HECMW_IO_ABAQUS_E0800, "TITLE ignored after
1646 *HEADING");
1647 header->header[0] = ' ';
1648 header->header[1] = '\0';*/
1649 } else {
1651 while (*p && *p == ' ') p++;
1652 if (p == NULL) p = "";
1653 len = strlen(p);
1654 if (len > HECMW_HEADER_LEN) len = HECMW_HEADER_LEN;
1655 strncpy(header->header, p, len);
1656 header->header[len] = '\0';
1657 }
1658
1659 /* Note: * NL is ignored by LEX until the end of the header data. */
1660
1661 /* Ignore the rest of the header data */
1663 ;
1665
1666 /* set */
1668
1669 return 0;
1670}
1671
1672/*----------------------------------------------------------------------------*/
1673
1674static int read_include(void) {
1675 int token;
1676
1677 /* !INCLUDE */
1678 token = HECMW_ablex_next_token();
1679 if (token != HECMW_ABLEX_H_INCLUDE) {
1680 set_err_token(token, HECMW_IO_ABAQUS_E0900, "*INCLUDE required");
1681 return -1;
1682 }
1683
1684 /* ',' */
1685 token = HECMW_ablex_next_token();
1686 if (token != ',') {
1687 set_err_token(token, HECMW_IO_ABAQUS_E0900, "',' required after *INCLUDE");
1688 return -1;
1689 }
1690
1691 /* INPUT */
1692 token = HECMW_ablex_next_token();
1693 if (token != HECMW_ABLEX_K_INPUT) {
1694 set_err_token(token, HECMW_IO_ABAQUS_E0901, "");
1695 return -1;
1696 }
1697
1698 /* =filename */
1699 if (read_input(HECMW_IO_ABAQUS_E0900)) return -1;
1700
1701 /* NL */
1702 token = HECMW_ablex_next_token();
1703 if (token != HECMW_ABLEX_NL) {
1704 set_err_token(token, HECMW_IO_ABAQUS_E0900,
1705 "NL required after INPUT value");
1706 return -1;
1707 }
1708
1709 /* include */
1710 if (HECMW_ablex_switch_to_include(include_filename)) return -1;
1711
1712 return 0;
1713}
1714
1715/*----------------------------------------------------------------------------*/
1716
1717static int read_initial_keyword(void) {
1718 int token;
1719
1720 /* *INITIAL CONDITIONS */
1721 token = HECMW_ablex_next_token();
1722 if (token != HECMW_ABLEX_H_INITIAL) {
1723 set_err_token(token, HECMW_IO_ABAQUS_E1000, "*INITIAL CONDITIONS required");
1724 return -1;
1725 }
1726
1727 token = HECMW_ablex_next_token();
1728 if (token != ',') {
1729 set_err_token(token, HECMW_IO_ABAQUS_E1001, "");
1730 return -1;
1731 }
1732
1733 return 0;
1734}
1735
1736static int read_initial_param_type(int *type) {
1737 int token;
1738
1739 token = HECMW_ablex_next_token();
1740 if (token != '=') {
1741 set_err_token(token, HECMW_IO_ABAQUS_E1000, "'=' reqired after TYPE");
1742 return -1;
1743 }
1744 token = HECMW_ablex_next_token();
1745 if (token != HECMW_ABLEX_K_TEMPERATURE) {
1746 set_err_token(token, HECMW_IO_ABAQUS_E1000, "TEMPERATURE required");
1747 return -1;
1748 }
1750 return 0;
1751}
1752
1753static int read_initial_data(int type) {
1754 int node, token;
1755 char *ngrp;
1756 double val;
1757
1758 /* node or ngrp */
1759 node = -1;
1760 ngrp = NULL;
1761 token = HECMW_ablex_next_token();
1762 if (token == ',') {
1763 set_err(HECMW_IO_ABAQUS_E1002, "");
1764 return -1;
1765 } else if (token == HECMW_ABLEX_INT) {
1766 node = HECMW_ablex_get_number();
1767 if (node <= 0) {
1768 set_err(HECMW_IO_ABAQUS_E1002, "");
1769 return -1;
1770 }
1771 } else if (token == HECMW_ABLEX_NAME) {
1772 ngrp = HECMW_ablex_get_text();
1773 if (strlen(ngrp) > HECMW_NAME_LEN) {
1774 set_err(HECMW_IO_E0001, "");
1775 return -1;
1776 }
1777 HECMW_toupper(ngrp);
1778 ngrp = HECMW_strdup(ngrp);
1779 if (ngrp == NULL) {
1780 set_err(errno, "");
1781 return -1;
1782 }
1783 } else {
1784 set_err_token(token, HECMW_IO_ABAQUS_E1000,
1785 "Node ID or NGROUP name required");
1786 return -1;
1787 }
1788
1789 /* ',' */
1790 token = HECMW_ablex_next_token();
1791 if (token != ',') {
1792 set_err_token(token, HECMW_IO_ABAQUS_E1000, "',' required after node");
1793 return -1;
1794 }
1795
1796 /* VAL */
1797 token = HECMW_ablex_next_token();
1798 if (token != HECMW_ABLEX_DOUBLE && token != HECMW_ABLEX_INT &&
1799 token != HECMW_ABLEX_NL) {
1800 set_err_token(token, HECMW_IO_ABAQUS_E1000, "VAL required");
1801 return -1;
1802 }
1803 if (token == HECMW_ABLEX_NL) {
1804 val = 0.0;
1806 } else {
1807 val = HECMW_ablex_get_number();
1808 }
1809
1810 /* skip this line */
1811 while ((token = HECMW_ablex_next_token()) && token != HECMW_ABLEX_NL)
1812 ;
1813 if (token != HECMW_ABLEX_NL) {
1814 set_err_token(token, HECMW_IO_ABAQUS_E1000, "NL required");
1815 return -1;
1816 }
1817
1818 /* add */
1819 HECMW_assert(type != -1);
1820 if (HECMW_io_add_initial(type, node, ngrp, val) == NULL) return -1;
1821 HECMW_free(ngrp);
1822
1823 return 0;
1824}
1825
1826static int read_initial(void) {
1827 int token, state;
1828 int type = -1;
1829 int flag_type = 0; /* flag for TYPE */
1830 int flag_input = 0; /* flag for INPUT */
1831 enum {
1832 ST_FINISHED,
1833 ST_KEYWORD_LINE,
1834 ST_KEYWORD_LINE_PARAM,
1835 ST_DATA_INCLUDE,
1836 ST_DATA_LINE
1837 };
1838
1839 state = ST_KEYWORD_LINE;
1840 while (state != ST_FINISHED) {
1841 if (state == ST_KEYWORD_LINE) {
1842 if (read_initial_keyword()) return -1;
1843 state = ST_KEYWORD_LINE_PARAM;
1844 } else if (state == ST_KEYWORD_LINE_PARAM) {
1845 token = HECMW_ablex_next_token();
1846 if (token == HECMW_ABLEX_K_TYPE) {
1847 /* must */
1848 if (read_initial_param_type(&type)) return -1;
1849 flag_type = 1;
1850 } else if (token == HECMW_ABLEX_K_INPUT) {
1851 /* oprtional */
1852 if (read_input(HECMW_IO_ABAQUS_E1000)) return -1;
1853 flag_input = 1;
1854 } else {
1855 set_err_token(token, HECMW_IO_ABAQUS_E1000, "Unknown parameter");
1856 return -1;
1857 }
1858
1859 /* check next parameter */
1860 token = HECMW_ablex_next_token();
1861 if (token == HECMW_ABLEX_NL) {
1862 if (flag_input) {
1863 state = ST_DATA_INCLUDE;
1864 } else {
1865 state = ST_DATA_LINE;
1866 }
1867 /* check */
1868 if (!flag_type) {
1869 set_err(HECMW_IO_ABAQUS_E1001, "");
1870 return -1;
1871 }
1872 } else if (token == ',') {
1873 ; /* continue this state */
1874 } else {
1875 set_err_token(token, HECMW_IO_ABAQUS_E1000, "Unknown parameter");
1876 return -1;
1877 }
1878 } else if (state == ST_DATA_INCLUDE) {
1879 HECMW_assert(flag_input);
1880 HECMW_assert(flag_type);
1881 if (HECMW_ablex_switch_to_include(include_filename)) return -1;
1882 state = ST_DATA_LINE;
1883 } else if (state == ST_DATA_LINE) {
1884 HECMW_assert(flag_type);
1885 if (read_initial_data(type)) return -1;
1886 /* check next state */
1887 token = HECMW_ablex_next_token();
1888 if (token != HECMW_ABLEX_INT && token != HECMW_ABLEX_NAME) {
1889 state = ST_FINISHED;
1890 }
1892 } else {
1893 HECMW_assert(0);
1894 }
1895 }
1896 return 0;
1897}
1898
1899/*----------------------------------------------------------------------------*/
1900
1901static int read_conductivity_keyword(int *last_token) {
1902 int token;
1903
1904 /* *CONDUCTIVITY */
1905 token = HECMW_ablex_next_token();
1906 if (token != HECMW_ABLEX_H_CONDUCTIVITY) {
1907 set_err_token(token, HECMW_IO_ABAQUS_E2500, "*CONDUCTIVITY required");
1908 return -1;
1909 }
1910
1911 token = HECMW_ablex_next_token();
1912 if (token != ',' && token != HECMW_ABLEX_NL) {
1913 set_err_token(token, HECMW_IO_ABAQUS_E2500,
1914 "',' or NL required after *CONDUCTIVITY");
1915 return -1;
1916 }
1917 *last_token = token;
1918
1919 return 0;
1920}
1921
1922static int read_conductivity_param_dependencies(int *dependencies) {
1923 return read_param_dependencies(dependencies, HECMW_IO_ABAQUS_E2500);
1924}
1925
1926static int read_conductivity_param_type(int *type) {
1927 int token;
1928
1929 token = HECMW_ablex_next_token();
1930 if (token != '=') {
1931 set_err_token(token, HECMW_IO_ABAQUS_E2500, "'=' required after TYPE");
1932 return -1;
1933 }
1934 token = HECMW_ablex_next_token();
1935 switch (token) {
1936 case HECMW_ABLEX_K_ISOTROPIC: /* fall through */
1937 case HECMW_ABLEX_K_ORTHOTROPIC: /* fall through */
1939 break;
1940 default:
1941 set_err_token(token, HECMW_IO_ABAQUS_E2500, "Invalid TYPE");
1942 return -1;
1943 }
1944 *type = token;
1945
1946 return 0;
1947}
1948
1949static int read_conductivity_data(int type, int dependencies,
1950 struct hecmw_io_matitem **matitem) {
1951 int n, temp_col;
1952 n = 0;
1953 temp_col = 0;
1954
1955 switch (type) {
1957 n = temp_col = 2;
1958 break;
1960 n = temp_col = 4;
1961 break;
1963 n = temp_col = 7;
1964 break;
1965 default:
1966 HECMW_assert(0);
1967 }
1968 return read_mat_data_common(n + dependencies, 8, temp_col, matitem,
1970}
1971
1972static int read_conductivity(void) {
1973 int token, state;
1974 int flag_dependencies = 0; /* flag for DEPENDENCIES */
1975 int flag_type = 0; /* flag for TYPE */
1976 int dependencies = 0;
1977 int type = HECMW_ABLEX_K_ISOTROPIC;
1978 enum { ST_FINISHED, ST_KEYWORD_LINE, ST_KEYWORD_LINE_PARAM, ST_DATA_LINE };
1979
1980 state = ST_KEYWORD_LINE;
1981 while (state != ST_FINISHED) {
1982 if (state == ST_KEYWORD_LINE) {
1983 if (read_conductivity_keyword(&token)) return -1;
1984 if (token == ',') {
1985 state = ST_KEYWORD_LINE_PARAM;
1986 } else if (token == HECMW_ABLEX_NL) {
1987 state = ST_DATA_LINE;
1988 } else {
1989 HECMW_assert(0);
1990 }
1991 } else if (state == ST_KEYWORD_LINE_PARAM) {
1992 token = HECMW_ablex_next_token();
1993 if (token == HECMW_ABLEX_K_DEPENDENCIES) {
1994 if (read_conductivity_param_dependencies(&dependencies)) return -1;
1995 flag_dependencies = 1;
1996 } else if (token == HECMW_ABLEX_K_TYPE) {
1997 if (read_conductivity_param_type(&type)) return -1;
1998 flag_type = 1;
1999 } else {
2000 set_err_token(token, HECMW_IO_ABAQUS_E2500, "Unknown parameter");
2001 return -1;
2002 }
2003 token = HECMW_ablex_next_token();
2004 if (token != ',' && token != HECMW_ABLEX_NL) {
2005 set_err_token(token, HECMW_IO_ABAQUS_E2500, "Unknown parameter");
2006 return -1;
2007 }
2008 if (token == HECMW_ABLEX_NL) {
2009 state = ST_DATA_LINE;
2010 }
2011 } else if (state == ST_DATA_LINE) {
2012 struct hecmw_io_matitem *item;
2013 if (read_conductivity_data(type, dependencies, &item)) return -1;
2014 if (add_mat_data(HECMW_ABLEX_H_CONDUCTIVITY, item)) return -1;
2015 state = ST_FINISHED;
2016 } else {
2017 HECMW_assert(0);
2018 }
2019 }
2020 return 0;
2021}
2022
2023/*----------------------------------------------------------------------------*/
2024
2025static int read_density_keyword(int *last_token) {
2026 int token;
2027
2028 /* *DENSITY */
2029 token = HECMW_ablex_next_token();
2030 if (token != HECMW_ABLEX_H_DENSITY) {
2031 set_err_token(token, HECMW_IO_ABAQUS_E2200, "*DENSITY required");
2032 return -1;
2033 }
2034
2035 token = HECMW_ablex_next_token();
2036 if (token != ',' && token != HECMW_ABLEX_NL) {
2037 set_err_token(token, HECMW_IO_ABAQUS_E2200,
2038 "',' or NL required after *DENSITY");
2039 return -1;
2040 }
2041 *last_token = token;
2042
2043 return 0;
2044}
2045
2046static int read_density_param_dependencies(int *dependencies) {
2047 return read_param_dependencies(dependencies, HECMW_IO_ABAQUS_E2200);
2048}
2049
2050static int read_density_data(int dependencies,
2051 struct hecmw_io_matitem **matitem) {
2052 return read_mat_data_common(2 + dependencies, 8, 2, matitem,
2054}
2055
2056static int read_density(void) {
2057 int token, state;
2058 int flag_dependencies = 0; /* flag for DEPENDENCIES */
2059 int dependencies = 0;
2060 enum { ST_FINISHED, ST_KEYWORD_LINE, ST_KEYWORD_LINE_PARAM, ST_DATA_LINE };
2061
2062 state = ST_KEYWORD_LINE;
2063 while (state != ST_FINISHED) {
2064 if (state == ST_KEYWORD_LINE) {
2065 if (read_density_keyword(&token)) return -1;
2066 if (token == ',') {
2067 state = ST_KEYWORD_LINE_PARAM;
2068 } else if (token == HECMW_ABLEX_NL) {
2069 state = ST_DATA_LINE;
2070 } else {
2071 HECMW_assert(0);
2072 }
2073 } else if (state == ST_KEYWORD_LINE_PARAM) {
2074 token = HECMW_ablex_next_token();
2075 if (token == HECMW_ABLEX_K_DEPENDENCIES) {
2076 if (read_density_param_dependencies(&dependencies)) return -1;
2077 flag_dependencies = 1;
2078 } else {
2079 set_err_token(token, HECMW_IO_ABAQUS_E2200, "Unknown parameter");
2080 return -1;
2081 }
2082 token = HECMW_ablex_next_token();
2083 if (token != HECMW_ABLEX_NL) {
2084 set_err_token(token, HECMW_IO_ABAQUS_E2200, "NL required");
2085 return -1;
2086 }
2087 state = ST_DATA_LINE;
2088 } else if (state == ST_DATA_LINE) {
2089 struct hecmw_io_matitem *item;
2090 if (read_density_data(dependencies, &item)) return -1;
2091 if (add_mat_data(HECMW_ABLEX_H_DENSITY, item)) return -1;
2092 state = ST_FINISHED;
2093 } else {
2094 HECMW_assert(0);
2095 }
2096 }
2097 return 0;
2098}
2099
2100/*----------------------------------------------------------------------------*/
2101
2102static int read_elastic_keyword(int *last_token) {
2103 int token;
2104
2105 /* *ELASTIC */
2106 token = HECMW_ablex_next_token();
2107 if (token != HECMW_ABLEX_H_ELASTIC) {
2108 set_err_token(token, HECMW_IO_ABAQUS_E2300, "*ELASTIC required");
2109 return -1;
2110 }
2111
2112 token = HECMW_ablex_next_token();
2113 if (token != ',' && token != HECMW_ABLEX_NL) {
2114 set_err_token(token, HECMW_IO_ABAQUS_E2300,
2115 "',' or NL required after *ELASTIC");
2116 return -1;
2117 }
2118 *last_token = token;
2119
2120 return 0;
2121}
2122
2123static int read_elastic_param_dependencies(int *dependencies) {
2124 return read_param_dependencies(dependencies, HECMW_IO_ABAQUS_E2300);
2125}
2126
2127static int read_elastic_param_type(int *type) {
2128 int token;
2129
2130 token = HECMW_ablex_next_token();
2131 if (token != '=') {
2132 set_err_token(token, HECMW_IO_ABAQUS_E2300, "'=' required after TYPE");
2133 return -1;
2134 }
2135 token = HECMW_ablex_next_token();
2136 switch (token) {
2137 case HECMW_ABLEX_K_ISOTROPIC: /* fall through */
2138 case HECMW_ABLEX_K_ENGINEERING_CONSTANTS: /* fall through */
2139 case HECMW_ABLEX_K_LAMINA: /* fall through */
2140 case HECMW_ABLEX_K_ORTHOTROPIC: /* fall through */
2142 break;
2143 default:
2144 set_err_token(token, HECMW_IO_ABAQUS_E2300, "Invalid TYPE");
2145 return -1;
2146 }
2147 *type = token;
2148
2149 return 0;
2150}
2151
2152static int read_elastic_param_moduli(int *moduli) {
2153 int token;
2154
2155 token = HECMW_ablex_next_token();
2156 if (token != '=') {
2157 set_err_token(token, HECMW_IO_ABAQUS_E2300, "'=' required after TYPE");
2158 return -1;
2159 }
2160 token = HECMW_ablex_next_token();
2161 switch (token) {
2163 break;
2164 default:
2165 set_err_token(token, HECMW_IO_ABAQUS_E2300, "Invalid TYPE");
2166 return -1;
2167 }
2168 *moduli = token;
2169
2170 return 0;
2171}
2172
2173static int read_elastic_data(int type, int dependencies,
2174 struct hecmw_io_matitem **matitem) {
2175 int n, temp_col;
2176 n = 0;
2177 temp_col = 0;
2178
2179 switch (type) {
2181 n = temp_col = 3;
2182 break;
2183 case HECMW_ABLEX_K_ENGINEERING_CONSTANTS: /* fall through */
2185 n = temp_col = 10;
2186 break;
2188 n = temp_col = 7;
2189 break;
2191 n = temp_col = 22;
2192 break;
2193 default:
2194 HECMW_assert(0);
2195 }
2196 return read_mat_data_common(n + dependencies, 8, temp_col, matitem,
2198}
2199
2200static int read_elastic(void) {
2201 int token, state;
2202 int flag_dependencies = 0; /* flag for DEPENDENCIES */
2203 int flag_type = 0; /* flag for TYPE */
2204 int flag_moduli = 0; /* flag for MODULI */
2205 int dependencies = 0;
2206 int type = HECMW_ABLEX_K_ISOTROPIC;
2207 int moduli = 0;
2208 enum { ST_FINISHED, ST_KEYWORD_LINE, ST_KEYWORD_LINE_PARAM, ST_DATA_LINE };
2209
2210 state = ST_KEYWORD_LINE;
2211 while (state != ST_FINISHED) {
2212 if (state == ST_KEYWORD_LINE) {
2213 if (read_elastic_keyword(&token)) return -1;
2214 if (token == ',') {
2215 state = ST_KEYWORD_LINE_PARAM;
2216 } else if (token == HECMW_ABLEX_NL) {
2217 state = ST_DATA_LINE;
2218 } else {
2219 HECMW_assert(0);
2220 }
2221 } else if (state == ST_KEYWORD_LINE_PARAM) {
2222 token = HECMW_ablex_next_token();
2223 if (token == HECMW_ABLEX_K_DEPENDENCIES) {
2224 if (read_elastic_param_dependencies(&dependencies)) return -1;
2225 flag_dependencies = 1;
2226 } else if (token == HECMW_ABLEX_K_TYPE) {
2227 if (read_elastic_param_type(&type)) return -1;
2228 flag_type = 1;
2229 } else if (token == HECMW_ABLEX_K_MODULI) {
2230 if (read_elastic_param_moduli(&moduli)) return -1;
2231 flag_moduli = 1;
2232 } else {
2233 set_err_token(token, HECMW_IO_ABAQUS_E2300, "Unknown parameter");
2234 return -1;
2235 }
2236 token = HECMW_ablex_next_token();
2237 if (token != ',' && token != HECMW_ABLEX_NL) {
2238 set_err_token(token, HECMW_IO_ABAQUS_E2300, "Unknown parameter");
2239 return -1;
2240 }
2241 if (token == HECMW_ABLEX_NL) {
2242 state = ST_DATA_LINE;
2243 }
2244 } else if (state == ST_DATA_LINE) {
2245 struct hecmw_io_matitem *item;
2246 if (read_elastic_data(type, dependencies, &item)) return -1;
2247 if (add_mat_data(HECMW_ABLEX_H_ELASTIC, item)) return -1;
2248 state = ST_FINISHED;
2249 } else {
2250 HECMW_assert(0);
2251 }
2252 }
2253 return 0;
2254}
2255
2256/*----------------------------------------------------------------------------*/
2257
2258static int read_specific_keyword(int *last_token) {
2259 int token;
2260
2261 /* *SPECIFIC HEAT */
2262 token = HECMW_ablex_next_token();
2263 if (token != HECMW_ABLEX_H_SPECIFIC_HEAT) {
2264 set_err_token(token, HECMW_IO_ABAQUS_E2400, "*SPECIFIC HEAT required");
2265 return -1;
2266 }
2267
2268 token = HECMW_ablex_next_token();
2269 if (token != ',' && token != HECMW_ABLEX_NL) {
2270 set_err_token(token, HECMW_IO_ABAQUS_E2400,
2271 "',' or NL required after *SPECIFIC HEAT");
2272 return -1;
2273 }
2274 *last_token = token;
2275
2276 return 0;
2277}
2278
2279static int read_specific_param_dependencies(int *dependencies) {
2280 return read_param_dependencies(dependencies, HECMW_IO_ABAQUS_E2400);
2281}
2282
2283static int read_specific_data(int dependencies,
2284 struct hecmw_io_matitem **matitem) {
2285 return read_mat_data_common(2 + dependencies, 8, 2, matitem,
2287}
2288
2289static int read_specific_heat(void) {
2290 int token, state;
2291 int flag_dependencies = 0; /* flag for DEPENDENCIES */
2292 int dependencies = 0;
2293 enum { ST_FINISHED, ST_KEYWORD_LINE, ST_KEYWORD_LINE_PARAM, ST_DATA_LINE };
2294
2295 state = ST_KEYWORD_LINE;
2296 while (state != ST_FINISHED) {
2297 if (state == ST_KEYWORD_LINE) {
2298 if (read_specific_keyword(&token)) return -1;
2299 if (token == ',') {
2300 state = ST_KEYWORD_LINE_PARAM;
2301 } else if (token == HECMW_ABLEX_NL) {
2302 state = ST_DATA_LINE;
2303 } else {
2304 HECMW_assert(0);
2305 }
2306 } else if (state == ST_KEYWORD_LINE_PARAM) {
2307 token = HECMW_ablex_next_token();
2308 if (token == HECMW_ABLEX_K_DEPENDENCIES) {
2309 if (read_specific_param_dependencies(&dependencies)) return -1;
2310 flag_dependencies = 1;
2311 } else {
2312 set_err_token(token, HECMW_IO_ABAQUS_E2400, "Unknown parameter");
2313 return -1;
2314 }
2315 token = HECMW_ablex_next_token();
2316 if (token != HECMW_ABLEX_NL) {
2317 set_err_token(token, HECMW_IO_ABAQUS_E2400, "NL required");
2318 return -1;
2319 }
2320 state = ST_DATA_LINE;
2321 } else if (state == ST_DATA_LINE) {
2322 struct hecmw_io_matitem *item;
2323 if (read_specific_data(dependencies, &item)) return -1;
2324 if (add_mat_data(HECMW_ABLEX_H_SPECIFIC_HEAT, item)) return -1;
2325 state = ST_FINISHED;
2326 } else {
2327 HECMW_assert(0);
2328 }
2329 }
2330 return 0;
2331}
2332
2333/*----------------------------------------------------------------------------*/
2334
2335static int read_material_param_name(char *name) {
2336 int token;
2337 char *p;
2338
2339 token = HECMW_ablex_next_token();
2340 if (token != '=') {
2341 set_err_token(token, HECMW_IO_ABAQUS_E1100, "'=' required after NAME");
2342 return -1;
2343 }
2344 token = HECMW_ablex_next_token();
2345 if (token != HECMW_ABLEX_NAME) {
2346 set_err_token(token, HECMW_IO_ABAQUS_E1100,
2347 "NAME must begin with a letter");
2348 return -1;
2349 }
2351 if (strlen(p) > HECMW_NAME_LEN) {
2352 set_err(HECMW_IO_E0001, "");
2353 return -1;
2354 }
2355 strcpy(name, p);
2356 HECMW_toupper(name);
2357 if (HECMW_io_is_reserved_name(name)) {
2358 set_err(HECMW_IO_E0003, "");
2359 return -1;
2360 }
2361 if (HECMW_io_get_mat(name)) {
2362 set_err(HECMW_IO_ABAQUS_E1102, "%s alredy exists", name);
2363 return -1;
2364 }
2365 return 0;
2366}
2367
2368static int read_material(void) {
2369 int token;
2370 char name[HECMW_NAME_LEN + 1] = "";
2371
2372 /* *MATERIAL */
2373 token = HECMW_ablex_next_token();
2374 if (token != HECMW_ABLEX_H_MATERIAL) {
2375 set_err_token(token, HECMW_IO_ABAQUS_E1100, "*MATERIAL required");
2376 return -1;
2377 }
2378
2379 token = HECMW_ablex_next_token();
2380 if (token != ',') {
2381 set_err_token(token, HECMW_IO_ABAQUS_E1101, "");
2382 return -1;
2383 }
2384
2385 token = HECMW_ablex_next_token();
2386 if (token != HECMW_ABLEX_K_NAME) {
2387 set_err_token(token, HECMW_IO_ABAQUS_E1100, "Unknown parameter");
2388 return -1;
2389 }
2390
2391 if (read_material_param_name(name)) return -1;
2392
2393 token = HECMW_ablex_next_token();
2394 if (token != HECMW_ABLEX_NL) {
2395 set_err_token(token, HECMW_IO_ABAQUS_E1100, "NL required");
2396 return -1;
2397 }
2398
2399 strcpy(matname, name);
2400
2401 return 0;
2402}
2403
2404/*----------------------------------------------------------------------------*/
2405#if 0
2406static int
2407read_ncopy(void)
2408{
2409 fprintf(stderr, "*NCOPY has not implemented yet\n");
2411 return 0;
2412}
2413
2414
2415/*----------------------------------------------------------------------------*/
2416
2417static int
2418read_nfill(void)
2419{
2420 fprintf(stderr, "*NFILL has not implemented yet\n");
2422 return 0;
2423}
2424
2425
2426/*----------------------------------------------------------------------------*/
2427
2428static int
2429read_ngen(void)
2430{
2431 fprintf(stderr, "*NGEN has not implemented yet\n");
2433 return 0;
2434}
2435#endif
2436
2437/*----------------------------------------------------------------------------*/
2438
2439static int read_nset_keyword(void) {
2440 int token;
2441
2442 /* *NSET */
2443 token = HECMW_ablex_next_token();
2444 if (token != HECMW_ABLEX_H_NSET) {
2445 set_err_token(token, HECMW_IO_ABAQUS_E1500, "*NSET required");
2446 return -1;
2447 }
2448
2449 token = HECMW_ablex_next_token();
2450 if (token != ',') {
2451 set_err_token(token, HECMW_IO_ABAQUS_E1500, "',' required after *NSET");
2452 return -1;
2453 }
2454 return 0;
2455}
2456
2457static int read_nset_param_nset(char *nset, int *isAll) {
2458 int token;
2459 char *p;
2460
2461 token = HECMW_ablex_next_token();
2462 if (token != '=') {
2463 set_err_token(token, HECMW_IO_ABAQUS_E1500, "'=' required after NSET");
2464 return -1;
2465 }
2466 token = HECMW_ablex_next_token();
2467 if (token != HECMW_ABLEX_NAME) {
2468 set_err_token(token, HECMW_IO_ABAQUS_E1500,
2469 "NSET must begin with a letter");
2470 return -1;
2471 }
2473 if (strlen(p) > HECMW_NAME_LEN) {
2474 set_err(HECMW_IO_E0001, "");
2475 return -1;
2476 }
2477 strcpy(nset, p);
2478 HECMW_toupper(nset);
2479 if (HECMW_io_is_reserved_name(nset)) {
2480 set_err(HECMW_IO_E0003, "");
2481 return -1;
2482 }
2483 if (strcmp(nset, "EQUATION_BLOCK") == 0) {
2484 set_err(HECMW_IO_E0003, "Reserved name: %s", nset);
2485 return -1;
2486 }
2487 if (strcmp(nset, "ALL") == 0) {
2489 strcpy(nset, "ABAQUS_NSET_ALL");
2490 *isAll = 1;
2491 // return -1;
2492 }
2493 return 0;
2494}
2495
2496static int read_nset_param_instance() {
2497 int token;
2498 char *p;
2499
2500 token = HECMW_ablex_next_token();
2501 if (token != '=') {
2502 set_err_token(token, HECMW_IO_ABAQUS_E1500, "'=' required after INSTANCE");
2503 return -1;
2504 }
2505 token = HECMW_ablex_next_token();
2506 if (token != HECMW_ABLEX_NAME) {
2507 set_err_token(token, HECMW_IO_ABAQUS_E1500,
2508 "NSET must begin with a letter");
2509 return -1;
2510 }
2511 return 0;
2512}
2513
2514static int read_nset_data(int *nnode, int **node_array) {
2515 int i, n, *node, token;
2516 struct hecmw_io_id *head, *prev, *p, *q;
2517
2518 n = 0;
2519 head = NULL;
2520 node = NULL;
2521 while (1) {
2522 struct hecmw_io_id *id;
2523
2524 token = HECMW_ablex_next_token();
2525 if (n != 0 && token == HECMW_ABLEX_NL) break;
2526
2527 id = HECMW_malloc(sizeof(*id));
2528 if (id == NULL) {
2529 set_err(errno, "");
2530 goto error;
2531 }
2532
2533 /* nodX */
2534 if (token != HECMW_ABLEX_INT && token != ',') {
2535 set_err_token(token, HECMW_IO_ABAQUS_E1500, "Node ID required");
2536 goto error;
2537 }
2538 if (token == ',') {
2539 id->id = 0;
2541 } else {
2542 id->id = HECMW_ablex_get_number();
2543 }
2544 id->next = NULL;
2545 if (head == NULL) {
2546 head = id;
2547 } else {
2548 prev->next = id;
2549 }
2550 prev = id;
2551 n++;
2552
2553 /* ',' or NL */
2554 token = HECMW_ablex_next_token();
2555 if (token != ',' && token != HECMW_ABLEX_NL) {
2556 set_err_token(token, HECMW_IO_ABAQUS_E1500,
2557 "',' or NL required after node ID");
2558 goto error;
2559 }
2560 if (token == HECMW_ABLEX_NL) break;
2561 }
2562
2564 HECMW_assert(n > 0);
2565
2566 node = HECMW_malloc(sizeof(*node) * n);
2567 if (node == NULL) {
2568 set_err(errno, "");
2569 goto error;
2570 }
2571 i = 0;
2572 for (p = head; p; p = q) {
2573 q = p->next;
2574 node[i++] = p->id;
2575 HECMW_free(p);
2576 }
2577 head = NULL;
2578
2579 *nnode = n;
2580 *node_array = node;
2581 return 0;
2582error:
2583 for (p = head; p; p = q) {
2584 q = p->next;
2585 HECMW_free(p);
2586 }
2587 HECMW_free(node);
2588 return -1;
2589}
2590
2591static int read_nset_data_generate(int *nnode, int **node_array) {
2592 int token, i, n, id, *node, nod1, nod2, nod3;
2593
2594 /* nod1 */
2595 token = HECMW_ablex_next_token();
2596 if (token != HECMW_ABLEX_INT) {
2597 set_err_token(token, HECMW_IO_ABAQUS_E1500, "nod1 required");
2598 return -1;
2599 }
2600 nod1 = HECMW_ablex_get_number();
2601 if (nod1 <= 0) {
2602 set_err(HECMW_IO_ABAQUS_E1502, "");
2603 return -1;
2604 }
2605
2606 /* ',' */
2607 token = HECMW_ablex_next_token();
2608 if (token != ',') {
2609 set_err_token(token, HECMW_IO_ABAQUS_E1500, "',' required after nod1");
2610 return -1;
2611 }
2612
2613 /* nod2 */
2614 token = HECMW_ablex_next_token();
2615 if (token != HECMW_ABLEX_INT) {
2616 set_err_token(token, HECMW_IO_ABAQUS_E1500, "nod2 requird");
2617 return -1;
2618 }
2619 nod2 = HECMW_ablex_get_number();
2620 if (nod2 <= 0) {
2621 set_err(HECMW_IO_ABAQUS_E1502, "");
2622 return -1;
2623 }
2624
2625 /* ',' or NL */
2626 token = HECMW_ablex_next_token();
2627 if (token == ',') {
2628 /* nod3 */
2629 token = HECMW_ablex_next_token();
2630 if (token != HECMW_ABLEX_INT) {
2631 set_err_token(token, HECMW_IO_ABAQUS_E1500, "Increment required");
2632 return -1;
2633 }
2634 nod3 = HECMW_ablex_get_number();
2635 if (nod3 <= 0) {
2636 set_err(HECMW_IO_ABAQUS_E1502, "");
2637 return -1;
2638 }
2639
2640 /* NL */
2641 token = HECMW_ablex_next_token();
2642 if (token != HECMW_ABLEX_NL) {
2643 set_err_token(token, HECMW_IO_ABAQUS_E1500,
2644 "NL required after increment");
2645 return -1;
2646 }
2647 } else if (token == HECMW_ABLEX_NL) {
2648 nod3 = 1;
2649 } else {
2650 set_err_token(token, HECMW_IO_ABAQUS_E1500,
2651 "',' or NL required after nod2");
2652 return -1;
2653 }
2654 HECMW_assert(token == HECMW_ABLEX_NL);
2655
2656 /* make node */
2657 if (nod1 > nod2) {
2658 set_err(HECMW_IO_ABAQUS_E1503,
2659 "Cannot generate between %d and %d with an increment of %d", nod1,
2660 nod2, nod3);
2661 return -1;
2662 }
2663 if ((nod2 - nod1) % nod3) {
2664 set_err(HECMW_IO_ABAQUS_E1503,
2665 "Cannot generate between %d and %d with an increment of %d", nod1,
2666 nod2, nod3);
2667 return -1;
2668 }
2669
2670 n = (nod2 - nod1) / nod3 + 1;
2671 node = HECMW_malloc(sizeof(int) * n);
2672 if (node == NULL) {
2673 set_err(errno, "");
2674 return -1;
2675 }
2676
2677 i = 0;
2678 for (id = nod1; id <= nod2; id += nod3) {
2679 node[i++] = id;
2680 }
2681 HECMW_assert(i == n);
2682
2683 *nnode = n;
2684 *node_array = node;
2685
2686 return 0;
2687}
2688
2689static int read_nset(void) {
2690 int token, state;
2691 int flag_nset = 0; /* flag for NSET */
2692 int flag_generate = 0; /* flag for GENERATE */
2693 int flag_unsorted = 0; /* flag for UNSORTED */
2694 int isAll = 0;
2695 char nset[HECMW_NAME_LEN + 1] = "";
2696 enum {
2697 ST_FINISHED,
2698 ST_KEYWORD_LINE,
2699 ST_KEYWORD_LINE_PARAM,
2700 ST_DATA_LINE,
2701 ST_DATA_LINE_GENERATE
2702 };
2703
2704 state = ST_KEYWORD_LINE;
2705 while (state != ST_FINISHED) {
2706 if (state == ST_KEYWORD_LINE) {
2707 if (read_nset_keyword()) return -1;
2708 state = ST_KEYWORD_LINE_PARAM;
2709 } else if (state == ST_KEYWORD_LINE_PARAM) {
2710 token = HECMW_ablex_next_token();
2711 if (token == HECMW_ABLEX_K_NSET) {
2712 /* must */
2713 if (read_nset_param_nset(nset, &isAll)) return -1;
2714 flag_nset = 1;
2715 } else if (token == HECMW_ABLEX_K_GENERATE) {
2716 /* oprtional */
2717 flag_generate = 1;
2718 } else if (token == HECMW_ABLEX_K_UNSORTED) {
2719 /* oprtional */
2720 log_warn(HECMW_IO_ABAQUS_W0097, "UNSORTED is not suppotred. Ignored.");
2721 flag_unsorted = 0; /* always ignore in this version */
2722 } else if (token == HECMW_ABLEX_K_INSTANCE) {
2723 read_nset_param_instance();
2724 } else {
2725 set_err_token(token, HECMW_IO_ABAQUS_E1500, "Unknown parameter");
2726 return -1;
2727 }
2728
2729 /* check next parameter */
2730 token = HECMW_ablex_next_token();
2731 if (token == HECMW_ABLEX_NL) {
2732 /* check */
2733 if (!flag_nset) {
2734 set_err(HECMW_IO_ABAQUS_E1501, "");
2735 return -1;
2736 }
2737 if (flag_generate) {
2738 state = ST_DATA_LINE_GENERATE;
2739 } else {
2740 state = ST_DATA_LINE;
2741 }
2742 } else if (token == ',') {
2743 ; /* continue this state */
2744 } else {
2745 set_err_token(token, HECMW_IO_ABAQUS_E1500, "Unknown parameter");
2746 return -1;
2747 }
2748 } else if (state == ST_DATA_LINE) {
2749 int n, *node;
2750
2751 HECMW_assert(flag_nset);
2752 if (read_nset_data(&n, &node)) return -1;
2753
2754 /* add node to group */
2755 if (HECMW_io_add_ngrp(nset, n, node) < 0) return -1;
2756 HECMW_free(node);
2757
2758 /* check next state */
2759 token = HECMW_ablex_next_token();
2760 if (token != HECMW_ABLEX_INT) {
2761 state = ST_FINISHED;
2762 } else {
2763 state = ST_DATA_LINE;
2764 }
2766 } else if (state == ST_DATA_LINE_GENERATE) {
2767 int n, *node;
2768
2769 HECMW_assert(flag_generate);
2770 HECMW_assert(flag_nset);
2771
2772 if (read_nset_data_generate(&n, &node)) return -1;
2773
2774 /* add node to group */
2775 if (HECMW_io_add_ngrp(nset, n, node) < 0) return -1;
2776 HECMW_free(node);
2777
2778 /* check next state */
2779 token = HECMW_ablex_next_token();
2780 if (token != HECMW_ABLEX_INT) {
2781 state = ST_FINISHED;
2782 }
2784 } else {
2785 HECMW_assert(0);
2786 }
2787 }
2788 return 0;
2789}
2790
2791/*----------------------------------------------------------------------------*/
2792
2793static int read_node_keyword(int *token) {
2794 /* *NODE */
2795 *token = HECMW_ablex_next_token();
2796 if (*token != HECMW_ABLEX_H_NODE) {
2797 set_err_token(*token, HECMW_IO_ABAQUS_E1600, "*NODE required");
2798 return -1;
2799 }
2800
2801 *token = HECMW_ablex_next_token();
2802 if (*token != HECMW_ABLEX_NL && *token != ',') {
2803 set_err_token(*token, HECMW_IO_ABAQUS_E1600,
2804 "',' or NL required after *NODE");
2805 return -1;
2806 }
2807 return 0;
2808}
2809
2810static int read_node_param_system(int *system) {
2811 int token;
2812
2813 token = HECMW_ablex_next_token();
2814 if (token != '=') {
2815 set_err_token(token, HECMW_IO_ABAQUS_E1600, "'=' required after SYSTEM");
2816 return -1;
2817 }
2818 token = HECMW_ablex_next_token();
2819 if (token != 'C' && token != 'R') {
2820 set_err_token(token, HECMW_IO_ABAQUS_E1600, "Invalid SYSTEM");
2821 return -1;
2822 }
2823 *system = token;
2824 return 0;
2825}
2826
2827static int read_node_param_nset(char *nset, int *isAll) {
2828 char *p;
2829 int token;
2830
2831 token = HECMW_ablex_next_token();
2832 if (token != '=') {
2833 set_err_token(token, HECMW_IO_ABAQUS_E1600, "'=' required after NSET");
2834 return -1;
2835 }
2836 token = HECMW_ablex_next_token();
2837 if (token != HECMW_ABLEX_NAME) {
2838 set_err_token(token, HECMW_IO_ABAQUS_E1600,
2839 "NSET must begin with a letter");
2840 return -1;
2841 }
2843 if (strlen(p) > HECMW_NAME_LEN) {
2844 set_err(HECMW_IO_E0001, "");
2845 return -1;
2846 }
2847 strcpy(nset, p);
2848 HECMW_toupper(nset);
2849 if (HECMW_io_is_reserved_name(nset)) {
2850 set_err(HECMW_IO_E0003, "");
2851 return -1;
2852 }
2853 if (strcmp(nset, "ALL") == 0) {
2855 strcpy(nset, "ABAQUS_ESET_ALL");
2856 *isAll = 1;
2857 // return -1;
2858 }
2859 return 0;
2860}
2861
2862static int read_node_data(int *id, double *x, double *y, double *z) {
2863 int token;
2864
2865 /* node ID */
2866 *id = 0;
2867 token = HECMW_ablex_next_token();
2868 if (token == ',') {
2870 } else if (token == HECMW_ABLEX_INT) {
2871 *id = HECMW_ablex_get_number();
2872 } else {
2873 set_err(HECMW_IO_ABAQUS_E1600, "");
2874 return -1;
2875 }
2876 if (*id <= 0) {
2877 set_err(HECMW_IO_ABAQUS_E1601, "");
2878 return -1;
2879 }
2880
2881 /* ',' */
2882 token = HECMW_ablex_next_token();
2883 if (token != ',') {
2884 set_err_token(token, HECMW_IO_ABAQUS_E1600, "',' required after nood ID");
2885 return -1;
2886 }
2887
2888 *x = *y = *z = 0.0;
2889 while (1) {
2890 /* X */
2891 token = HECMW_ablex_next_token();
2892 if (token == HECMW_ABLEX_NL) break;
2893 if (token == ',') {
2895 } else if (token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
2897 } else {
2898 set_err_token(token, HECMW_IO_ABAQUS_E1600, "X required");
2899 return -1;
2900 }
2901
2902 /* ',' */
2903 token = HECMW_ablex_next_token();
2904 if (token == HECMW_ABLEX_NL) break;
2905 if (token != ',') {
2906 set_err_token(token, HECMW_IO_ABAQUS_E1600, "',' required after X");
2907 return -1;
2908 }
2909
2910 /* Y */
2911 token = HECMW_ablex_next_token();
2912 if (token == HECMW_ABLEX_NL) break;
2913 if (token == ',') {
2915 } else if (token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
2917 } else {
2918 set_err_token(token, HECMW_IO_ABAQUS_E1600, "Y required");
2919 return -1;
2920 }
2921
2922 /* ',' */
2923 token = HECMW_ablex_next_token();
2924 if (token == HECMW_ABLEX_NL) break;
2925 if (token != ',') {
2926 set_err_token(token, HECMW_IO_ABAQUS_E1600, "',' required after Y");
2927 return -1;
2928 }
2929
2930 /* Z */
2931 token = HECMW_ablex_next_token();
2932 if (token == HECMW_ABLEX_NL) break;
2933 if (token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
2935 } else {
2936 set_err_token(token, HECMW_IO_ABAQUS_E1600, "Z required");
2937 return -1;
2938 }
2939
2940 /* ',' or NL */
2941 token = HECMW_ablex_next_token();
2942 if (token == HECMW_ABLEX_NL) break;
2943 if (token == ',') {
2944 token = HECMW_ablex_next_token();
2945 if (token != HECMW_ABLEX_NL) {
2946 set_err_token(token, HECMW_IO_ABAQUS_E1600, "NL required after Z");
2947 return -1;
2948 }
2949 }
2950
2951 break;
2952 }
2953 return 0;
2954}
2955
2956static int read_node_data_system(int system, double *x, double *y, double *z) {
2957 struct hecmw_coord coord, result;
2958
2959 /* prepare */
2960 coord.x = *x;
2961 coord.y = *y;
2962 coord.z = *z;
2963
2964 /* reflect parameter SYSTEM */
2965 if (system == 'C') {
2966 coord.y = HECMW_degree_to_radian(coord.y);
2967 if (HECMW_cylindrical_to_cartesian(&coord, &result)) {
2968 HECMW_assert(0);
2969 }
2970 coord = result;
2971 }
2972
2973 /* reflect *SYSTEM */
2974 if (HECMW_system(HECMW_io_get_system(), &coord, &result)) {
2975 HECMW_assert(0);
2976 }
2977 *x = result.x;
2978 *y = result.y;
2979 *z = result.z;
2980
2981 return 0;
2982}
2983
2984static int read_node(void) {
2985 int token, state;
2986 int system = 'R'; /* C:cylindrical coordinates, R:cartesian coordinates */
2987 int flag_system = 0; /* flag for SYSTEM */
2988 int flag_nset = 0; /* flag for NSET */
2989 int flag_input = 0; /* flag for INPUT */
2990 int isAll = 0;
2991 char nset[HECMW_NAME_LEN + 1] = "";
2992 enum {
2993 ST_FINISHED,
2994 ST_KEYWORD_LINE,
2995 ST_KEYWORD_LINE_PARAM,
2996 ST_DATA_INCLUDE,
2997 ST_DATA_LINE
2998 };
2999
3000 state = ST_KEYWORD_LINE;
3001 while (state != ST_FINISHED) {
3002 if (state == ST_KEYWORD_LINE) {
3003 if (read_node_keyword(&token)) return -1;
3004 if (token == HECMW_ABLEX_NL) {
3005 state = ST_DATA_LINE;
3006 } else if (token == ',') {
3007 state = ST_KEYWORD_LINE_PARAM;
3008 } else {
3009 HECMW_assert(0);
3010 }
3011 } else if (state == ST_KEYWORD_LINE_PARAM) {
3012 token = HECMW_ablex_next_token();
3013 if (token == HECMW_ABLEX_K_SYSTEM) {
3014 /* optional */
3015 if (read_node_param_system(&system)) return -1;
3016 flag_system = 1;
3017 } else if (token == HECMW_ABLEX_K_NSET) {
3018 /* optional */
3019 if (read_node_param_nset(nset, &isAll)) return -1;
3020 if (isAll == 0) {
3021 flag_nset = 1;
3022 }
3023 } else if (token == HECMW_ABLEX_K_INPUT) {
3024 /* optional */
3025 if (read_input(HECMW_IO_ABAQUS_E1600)) return -1;
3026 flag_input = 1;
3027 } else {
3028 set_err_token(token, HECMW_IO_ABAQUS_E1600, "Unknown parameter");
3029 return -1;
3030 }
3031
3032 /* check next parameter */
3033 token = HECMW_ablex_next_token();
3034 if (token == HECMW_ABLEX_NL) {
3035 state = flag_input ? ST_DATA_INCLUDE : ST_DATA_LINE;
3036 } else if (token == ',') {
3037 ; /* continue this state */
3038 } else {
3039 set_err_token(token, HECMW_IO_ABAQUS_E1600, "Unknown parameter");
3040 return -1;
3041 }
3042 } else if (state == ST_DATA_INCLUDE) {
3043 HECMW_assert(flag_input);
3044 if (HECMW_ablex_switch_to_include(include_filename)) return -1;
3045 state = ST_DATA_LINE;
3046 } else if (state == ST_DATA_LINE) {
3047 int id;
3048 double x, y, z;
3049
3050 if (read_node_data(&id, &x, &y, &z)) return -1;
3051
3052 /* check next state */
3053 token = HECMW_ablex_next_token();
3054 if (token != HECMW_ABLEX_INT) {
3055 state = ST_FINISHED;
3056 } else {
3057 state = ST_DATA_LINE;
3058 }
3060
3061 /* reflect SYSYEM, *SYSTEM */
3062 if (read_node_data_system(system, &x, &y, &z)) return -1;
3063
3064 /* add node */
3065 if (HECMW_io_add_node(id, x, y, z) == NULL) return -1;
3066
3067 /* add node to group */
3068 if (HECMW_io_add_ngrp("ALL", 1, &id) < 0) return -1;
3069 if (flag_nset) {
3070 if (HECMW_io_add_ngrp(nset, 1, &id) < 0) return -1;
3071 }
3072 } else {
3073 HECMW_assert(0);
3074 }
3075 }
3076 return 0;
3077}
3078
3079/*----------------------------------------------------------------------------*/
3080
3081static int read_shellsect_keyword(void) {
3082 int token;
3083
3084 /* *SHELL SECTION */
3085 token = HECMW_ablex_next_token();
3086 if (token != HECMW_ABLEX_H_SHELL_SECTION) {
3087 set_err_token(token, HECMW_IO_ABAQUS_E1700, "*SHELL SECTION required");
3088 return -1;
3089 }
3090
3091 token = HECMW_ablex_next_token();
3092 if (token != ',') {
3093 set_err_token(token, HECMW_IO_ABAQUS_E1700,
3094 "',' required after *SHELL SECTION");
3095 return -1;
3096 }
3097 return 0;
3098}
3099
3100static int read_shellsect_param_elset(char *elset) {
3101 int token;
3102 char *p;
3103
3104 token = HECMW_ablex_next_token();
3105 if (token != '=') {
3106 set_err_token(token, HECMW_IO_ABAQUS_E1700, "'=' reuqired after ELSET");
3107 return -1;
3108 }
3109 token = HECMW_ablex_next_token();
3110 if (token != HECMW_ABLEX_NAME) {
3111 set_err_token(token, HECMW_IO_ABAQUS_E1700,
3112 "ELSET must begin with a letter");
3113 return -1;
3114 }
3116 if (strlen(p) > HECMW_NAME_LEN) {
3117 set_err(HECMW_IO_E0001, "");
3118 return -1;
3119 }
3120 strcpy(elset, p);
3121 HECMW_toupper(elset);
3122 if (HECMW_io_is_reserved_name(elset)) {
3123 set_err(HECMW_IO_E0003, "");
3124 return -1;
3125 }
3126 return 0;
3127}
3128
3129static int read_shellsect_param_material(char *material) {
3130 int token;
3131 char *p;
3132
3133 token = HECMW_ablex_next_token();
3134 if (token != '=') {
3135 set_err_token(token, HECMW_IO_ABAQUS_E1700, "'=' reuqired after MATERIAL");
3136 return -1;
3137 }
3138 token = HECMW_ablex_next_token();
3139 if (token != HECMW_ABLEX_NAME) {
3140 set_err_token(token, HECMW_IO_ABAQUS_E1700,
3141 "MATERIAL must begin with a letter");
3142 return -1;
3143 }
3145 if (strlen(p) > HECMW_NAME_LEN) {
3146 set_err(HECMW_IO_E0001, "");
3147 return -1;
3148 }
3149 strcpy(material, p);
3150 HECMW_toupper(material);
3151 if (HECMW_io_is_reserved_name(material)) {
3152 set_err(HECMW_IO_E0003, "");
3153 return -1;
3154 }
3155 return 0;
3156}
3157
3158static int read_shellsect_data(double *thickness, int *integpoints) {
3159 int token;
3160
3161 /* THICKNESS */
3162 *thickness = 0.0;
3163 token = HECMW_ablex_next_token();
3164 if (token == ',') {
3166 } else if (token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
3167 *thickness = HECMW_ablex_get_number();
3168 } else {
3169 set_err_token(token, HECMW_IO_ABAQUS_E1700, "THICKNESS reuiqred");
3170 return -1;
3171 }
3172 if (*thickness <= 0.0) {
3173 set_err(HECMW_IO_ABAQUS_E1705, "");
3174 return -1;
3175 }
3176
3177 /* ',' */
3178 token = HECMW_ablex_next_token();
3179 if (token != ',') {
3180 set_err_token(token, HECMW_IO_ABAQUS_E1700, "',' required after THICKNESS");
3181 return -1;
3182 }
3183
3184 /* INTEGPOINTS */
3185 *integpoints = 0;
3186 token = HECMW_ablex_next_token();
3187 if (token == HECMW_ABLEX_NL) {
3189 } else if (token == HECMW_ABLEX_INT) {
3190 *integpoints = HECMW_ablex_get_number();
3191 } else {
3192 set_err_token(token, HECMW_IO_ABAQUS_E1700, "INTEGPOINTS required");
3193 return -1;
3194 }
3195 if (*integpoints <= 0) {
3196 set_err(HECMW_IO_ABAQUS_E1706, "");
3197 return -1;
3198 }
3199
3200 /* NL */
3201 token = HECMW_ablex_next_token();
3202 if (token != HECMW_ABLEX_NL) {
3203 set_err_token(token, HECMW_IO_ABAQUS_E1700,
3204 "NL required after INTEGPOINTS");
3205 return -1;
3206 }
3207
3208 return 0;
3209}
3210
3211static int read_shell_section(void) {
3212 int token, state;
3213 int composite = -1;
3214 int flag_elset = 0; /* flag for ELSET */
3215 int flag_material = 0; /* flag for MATERIAL */
3216 int flag_composite = 0; /* flag for COMPOSITE */
3217 char elset[HECMW_NAME_LEN + 1] = "";
3218 char material[HECMW_NAME_LEN + 1] = "ALL";
3219 enum { ST_FINISHED, ST_KEYWORD_LINE, ST_KEYWORD_LINE_PARAM, ST_DATA_LINE };
3220
3221 state = ST_KEYWORD_LINE;
3222 while (state != ST_FINISHED) {
3223 if (state == ST_KEYWORD_LINE) {
3224 if (read_shellsect_keyword()) return -1;
3225 state = ST_KEYWORD_LINE_PARAM;
3226 } else if (state == ST_KEYWORD_LINE_PARAM) {
3227 token = HECMW_ablex_next_token();
3228 if (token == HECMW_ABLEX_K_ELSET) {
3229 /* must */
3230 if (read_shellsect_param_elset(elset)) return -1;
3231 flag_elset = 1;
3232 } else if (token == HECMW_ABLEX_K_MATERIAL) {
3233 /* must */
3234 if (flag_composite) {
3235 set_err(HECMW_IO_ABAQUS_E1703, "");
3236 return -1;
3237 }
3238 if (read_shellsect_param_material(material)) return -1;
3239 flag_material = 1;
3240 } else {
3241 set_err_token(token, HECMW_IO_ABAQUS_E1700, "Unknown parameter");
3242 return -1;
3243 }
3244
3245 /* check next parameter */
3246 token = HECMW_ablex_next_token();
3247 if (token == HECMW_ABLEX_NL) {
3248 /* check */
3249 if (!flag_elset) {
3250 set_err(HECMW_IO_ABAQUS_E1702, "");
3251 return -1;
3252 }
3253 if (!flag_material) {
3254 set_err(HECMW_IO_ABAQUS_E1707, "");
3255 return -1;
3256 }
3257 /* set next state */
3258 state = ST_DATA_LINE;
3259 } else if (token == ',') {
3260 ; /* continue this state */
3261 } else {
3262 set_err_token(token, HECMW_IO_ABAQUS_E1700, "Unknown parameter");
3263 return -1;
3264 }
3265 } else if (state == ST_DATA_LINE) {
3266 double thickness;
3267 int integpoints;
3268 struct hecmw_io_section sect;
3269 union hecmw_io_section_item sect_item;
3270
3271 HECMW_assert(flag_elset);
3272
3273 if (read_shellsect_data(&thickness, &integpoints)) return -1;
3274
3275 /* set */
3276 sect_item.shell.thickness = thickness;
3277 sect_item.shell.integpoints = integpoints;
3278 strcpy(sect.egrp, elset);
3279 strcpy(sect.material, material);
3280 sect.composite = composite;
3281 sect.secopt = 0;
3282 sect.type = HECMW_SECT_TYPE_SHELL;
3283 sect.sect = sect_item;
3284 sect.next = NULL;
3285
3286 /* add */
3287 if (HECMW_io_add_sect(&sect) == NULL) return -1;
3288
3289 /* set next state */
3290 state = ST_FINISHED;
3291 } else {
3292 HECMW_assert(0);
3293 }
3294 }
3295 return 0;
3296}
3297
3298/*----------------------------------------------------------------------------*/
3299
3300static int read_solidsect_keyword(void) {
3301 int token;
3302
3303 /* *SOLID SECTION */
3304 token = HECMW_ablex_next_token();
3305 if (token != HECMW_ABLEX_H_SOLID_SECTION) {
3306 set_err_token(token, HECMW_IO_ABAQUS_E2100, "*SOLID SECTION required");
3307 return -1;
3308 }
3309
3310 token = HECMW_ablex_next_token();
3311 if (token != ',') {
3312 set_err_token(token, HECMW_IO_ABAQUS_E2100,
3313 "',' required after *SOLID SECTION");
3314 return -1;
3315 }
3316 return 0;
3317}
3318
3319static int read_solidsect_param_elset(char *elset) {
3320 int token;
3321 char *p;
3322
3323 token = HECMW_ablex_next_token();
3324 if (token != '=') {
3325 set_err_token(token, HECMW_IO_ABAQUS_E2100, "'=' reuqired after ELSET");
3326 return -1;
3327 }
3328 token = HECMW_ablex_next_token();
3329 if (token != HECMW_ABLEX_NAME) {
3330 set_err_token(token, HECMW_IO_ABAQUS_E2100,
3331 "ELSET must begin with a letter");
3332 return -1;
3333 }
3335 if (strlen(p) > HECMW_NAME_LEN) {
3336 set_err(HECMW_IO_E0001, "");
3337 return -1;
3338 }
3339 strcpy(elset, p);
3340 HECMW_toupper(elset);
3341 if (HECMW_io_is_reserved_name(elset)) {
3342 set_err(HECMW_IO_E0003, "");
3343 return -1;
3344 }
3345 return 0;
3346}
3347
3348static int read_solidsect_param_material(char *material) {
3349 int token;
3350 char *p;
3351
3352 token = HECMW_ablex_next_token();
3353 if (token != '=') {
3354 set_err_token(token, HECMW_IO_ABAQUS_E2100, "'=' reuqired after MATERIAL");
3355 return -1;
3356 }
3357 token = HECMW_ablex_next_token();
3358 if (token != HECMW_ABLEX_NAME) {
3359 set_err_token(token, HECMW_IO_ABAQUS_E2100,
3360 "MATERIAL must begin with a letter");
3361 return -1;
3362 }
3364 if (strlen(p) > HECMW_NAME_LEN) {
3365 set_err(HECMW_IO_E0001, "");
3366 return -1;
3367 }
3368 strcpy(material, p);
3369 HECMW_toupper(material);
3370 if (HECMW_io_is_reserved_name(material)) {
3371 set_err(HECMW_IO_E0003, "");
3372 return -1;
3373 }
3374 return 0;
3375}
3376
3377static int read_solidsect_param_orientation(char *orientation) {
3378 int token;
3379 char *p;
3380
3381 token = HECMW_ablex_next_token();
3382 if (token != '=') {
3383 set_err_token(token, HECMW_IO_ABAQUS_E2100,
3384 "'=' reuqired after ORIENTATION");
3385 return -1;
3386 }
3387 token = HECMW_ablex_next_token();
3388 if (token != HECMW_ABLEX_NAME) {
3389 set_err_token(token, HECMW_IO_ABAQUS_E2100,
3390 "ORIENTATION must begin with a letter");
3391 return -1;
3392 }
3394 if (strlen(p) > HECMW_NAME_LEN) {
3395 set_err(HECMW_IO_E0001, "");
3396 return -1;
3397 }
3398 strcpy(orientation, p);
3399 HECMW_toupper(orientation);
3400 if (HECMW_io_is_reserved_name(orientation)) {
3401 set_err(HECMW_IO_E0003, "");
3402 return -1;
3403 }
3404 return 0;
3405}
3406
3407static int read_solidsect_data(double *thickness) {
3408 int token;
3409
3410 /* THICKNESS */
3411 *thickness = 1.0;
3412 token = HECMW_ablex_next_token();
3413 if (token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
3414 *thickness = HECMW_ablex_get_number();
3415 /* ',' */
3416 token = HECMW_ablex_next_token();
3417 if (token != ',') {
3419 }
3420 /* NL */
3421 token = HECMW_ablex_next_token();
3422 if (token != HECMW_ABLEX_NL) {
3423 set_err_token(token, HECMW_IO_ABAQUS_E2100, "NL required");
3424 return -1;
3425 }
3426 } else {
3428 }
3429
3430 if (*thickness <= 0.0) {
3431 set_err(HECMW_IO_ABAQUS_E2105, "");
3432 return -1;
3433 }
3434
3435 return 0;
3436}
3437
3438static int read_solid_section(void) {
3439 int token, state;
3440 int composite = -1;
3441 int flag_elset = 0; /* flag for ELSET */
3442 int flag_material = 0; /* flag for MATERIAL */
3443 int flag_composite = 0; /* flag for COMPOSITE */
3444 char elset[HECMW_NAME_LEN + 1] = "";
3445 char material[HECMW_NAME_LEN + 1] = "ALL";
3446 char orientation[HECMW_NAME_LEN + 1] = "";
3447 enum { ST_FINISHED, ST_KEYWORD_LINE, ST_KEYWORD_LINE_PARAM, ST_DATA_LINE };
3448
3449 state = ST_KEYWORD_LINE;
3450 while (state != ST_FINISHED) {
3451 if (state == ST_KEYWORD_LINE) {
3452 if (read_solidsect_keyword()) return -1;
3453 state = ST_KEYWORD_LINE_PARAM;
3454 } else if (state == ST_KEYWORD_LINE_PARAM) {
3455 token = HECMW_ablex_next_token();
3456 if (token == HECMW_ABLEX_K_ELSET) {
3457 /* must */
3458 if (read_solidsect_param_elset(elset)) return -1;
3459 flag_elset = 1;
3460 } else if (token == HECMW_ABLEX_K_MATERIAL) {
3461 /* must */
3462 if (flag_composite) {
3463 set_err(HECMW_IO_ABAQUS_E2103, "");
3464 return -1;
3465 }
3466 if (read_solidsect_param_material(material)) return -1;
3467 flag_material = 1;
3468 } else if (token == HECMW_ABLEX_K_ORIENTATION) {
3469 if (read_solidsect_param_orientation(orientation)) return -1;
3470 } else {
3471 set_err_token(token, HECMW_IO_ABAQUS_E2100, "Unknown parameter");
3472 return -1;
3473 }
3474
3475 /* check next parameter */
3476 token = HECMW_ablex_next_token();
3477 if (token == HECMW_ABLEX_NL) {
3478 /* check */
3479 if (!flag_elset) {
3480 set_err(HECMW_IO_ABAQUS_E2102, "");
3481 return -1;
3482 }
3483 if (!flag_material) {
3484 set_err(HECMW_IO_ABAQUS_E2108, "");
3485 return -1;
3486 }
3487 /* set next state */
3488 state = ST_DATA_LINE;
3489 } else if (token == ',') {
3490 ; /* continue this state */
3491 } else {
3492 set_err_token(token, HECMW_IO_ABAQUS_E2100, "Unknown parameter");
3493 return -1;
3494 }
3495 } else if (state == ST_DATA_LINE) {
3496 int secopt;
3497 double thickness;
3498 struct hecmw_io_section sect;
3499 union hecmw_io_section_item sect_item;
3500
3501 HECMW_assert(flag_elset);
3502
3503 if (read_solidsect_data(&thickness)) return -1;
3504
3505 secopt = get_secopt(elset, HECMW_IO_ABAQUS_E2107);
3506 if (secopt < 0) {
3507 set_err_noloc(HECMW_IO_E1026, "Two or more secopt found in %s", elset);
3508 return -1;
3509 }
3510
3511 /* set */
3512 sect_item.solid.thickness = thickness;
3513 strcpy(sect.egrp, elset);
3514 strcpy(sect.material, material);
3515 sect.composite = composite;
3516 sect.secopt = secopt;
3517 sect.type = HECMW_SECT_TYPE_SOLID;
3518 sect.sect = sect_item;
3519 sect.next = NULL;
3520
3521 /* add */
3522 if (HECMW_io_add_sect(&sect) == NULL) return -1;
3523
3524 /* set next state */
3525 state = ST_FINISHED;
3526 } else {
3527 HECMW_assert(0);
3528 }
3529 }
3530 return 0;
3531}
3532
3533/*----------------------------------------------------------------------------*/
3534#if 0
3535static int
3536read_system_keyword(void)
3537{
3538 int token;
3539
3540 /* *SYSTEM */
3541 token = HECMW_ablex_next_token();
3542 if(token != HECMW_ABLEX_H_SYSTEM) {
3543 set_err_token(token, HECMW_IO_ABAQUS_E1900, "*SYSTEM required");
3544 return -1;
3545 }
3546
3547 /* NL */
3548 token = HECMW_ablex_next_token();
3549 if(token != HECMW_ABLEX_NL) {
3550 set_err_token(token, HECMW_IO_ABAQUS_E1900, "NL required after *SYSTEM");
3551 return -1;
3552 }
3553 return 0;
3554}
3555
3556
3557static int
3558read_system_data_line1a(struct hecmw_system_param *system, int *last_token)
3559{
3560 int token;
3561
3562 /* Xa */
3563 token = HECMW_ablex_next_token();
3564 if(token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
3565 system->xa = HECMW_ablex_get_number();
3566 } else if(token == ',') {
3567 system->xa = 0.0;
3569 } else {
3570 set_err_token(token, HECMW_IO_ABAQUS_E1900, "Xa required");
3571 return -1;
3572 }
3573
3574 /* ',' */
3575 token = HECMW_ablex_next_token();
3576 if(token != ',') {
3577 set_err_token(token, HECMW_IO_ABAQUS_E1900, "',' required after Xa");
3578 return -1;
3579 }
3580
3581 /* Ya */
3582 token = HECMW_ablex_next_token();
3583 if(token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
3584 system->ya = HECMW_ablex_get_number();
3585 } else if(token == ',') {
3586 system->ya = 0.0;
3588 } else {
3589 set_err_token(token, HECMW_IO_ABAQUS_E1900, "Ya required");
3590 return -1;
3591 }
3592
3593 /* ',' */
3594 token = HECMW_ablex_next_token();
3595 if(token != ',') {
3596 set_err_token(token, HECMW_IO_ABAQUS_E1900, "',' required after Ya");
3597 return -1;
3598 }
3599
3600 /* Za */
3601 token = HECMW_ablex_next_token();
3602 if(token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
3603 system->za = HECMW_ablex_get_number();
3604 } else if(token == ',' || token == HECMW_ABLEX_NL) {
3605 system->za = 0.0;
3607 } else {
3608 set_err_token(token, HECMW_IO_ABAQUS_E1900, "Za required");
3609 return -1;
3610 }
3611
3612 token = HECMW_ablex_next_token();
3613 if(token != ',' && token != HECMW_ABLEX_NL) {
3614 set_err_token(token, HECMW_IO_ABAQUS_E1900, "',' or NL required after Za");
3615 return -1;
3616 }
3617
3618 *last_token = token;
3619
3620 return 0;
3621}
3622
3623
3624static int
3625read_system_data_line1b(struct hecmw_system_param *system)
3626{
3627 int token;
3628 /* Xb */
3629 token = HECMW_ablex_next_token();
3630 if(token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
3631 system->xb = HECMW_ablex_get_number();
3632 } else if(token == ',') {
3633 system->xb = 0.0;
3635 } else {
3636 set_err_token(token, HECMW_IO_ABAQUS_E1900, "Xb required");
3637 return -1;
3638 }
3639
3640 /* ',' */
3641 token = HECMW_ablex_next_token();
3642 if(token != ',') {
3643 set_err_token(token, HECMW_IO_ABAQUS_E1900, "',' required after Xb");
3644 return -1;
3645 }
3646
3647 /* Yb */
3648 token = HECMW_ablex_next_token();
3649 if(token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
3650 system->yb = HECMW_ablex_get_number();
3651 } else if(token == ',') {
3652 system->yb = 0.0;
3654 } else {
3655 set_err_token(token, HECMW_IO_ABAQUS_E1900, "Yb required");
3656 return -1;
3657 }
3658
3659 /* ',' */
3660 token = HECMW_ablex_next_token();
3661 if(token != ',') {
3662 set_err_token(token, HECMW_IO_ABAQUS_E1900, "',' required after Yb");
3663 return -1;
3664 }
3665
3666 /* Zb */
3667 token = HECMW_ablex_next_token();
3668 if(token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
3669 system->zb = HECMW_ablex_get_number();
3670 } else if(token == HECMW_ABLEX_NL) {
3671 system->zb = 0.0;
3673 } else {
3674 set_err_token(token, HECMW_IO_ABAQUS_E1900, "Zb required");
3675 return -1;
3676 }
3677
3678 /*NL */
3679 token = HECMW_ablex_next_token();
3680 if(token != HECMW_ABLEX_NL) {
3681 set_err_token(token, HECMW_IO_ABAQUS_E1900, "NL required after Zb");
3682 return -1;
3683 }
3684
3685 return 0;
3686}
3687
3688
3689static int
3690read_system_data_line2(struct hecmw_system_param *system)
3691{
3692 int token;
3693
3694 /* Xc */
3695 token = HECMW_ablex_next_token();
3696 if(token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
3697 system->xc = HECMW_ablex_get_number();
3698 } else if(token == ',') {
3699 system->xc = 0.0;
3701 } else {
3702 set_err_token(token, HECMW_IO_ABAQUS_E1900, "Xc required");
3703 return -1;
3704 }
3705
3706 /* ',' */
3707 token = HECMW_ablex_next_token();
3708 if(token != ',') {
3709 set_err_token(token, HECMW_IO_ABAQUS_E1900, "',' required after Xc");
3710 return -1;
3711 }
3712
3713 /* Yc */
3714 token = HECMW_ablex_next_token();
3715 if(token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
3716 system->yc = HECMW_ablex_get_number();
3717 } else if(token == ',') {
3718 system->yc = 0.0;
3720 } else {
3721 set_err_token(token, HECMW_IO_ABAQUS_E1900, "Yc required");
3722 return -1;
3723 }
3724
3725 /* ',' */
3726 token = HECMW_ablex_next_token();
3727 if(token != ',') {
3728 set_err_token(token, HECMW_IO_ABAQUS_E1900, "',' required after Yc");
3729 return -1;
3730 }
3731
3732 /* Zc */
3733 token = HECMW_ablex_next_token();
3734 if(token == HECMW_ABLEX_DOUBLE || token == HECMW_ABLEX_INT) {
3735 system->zc = HECMW_ablex_get_number();
3736 } else if(token == HECMW_ABLEX_NL) {
3737 system->zc = 0.0;
3739 } else {
3740 set_err_token(token, HECMW_IO_ABAQUS_E1900, "Zc required");
3741 return -1;
3742 }
3743
3744 /* NL */
3745 token = HECMW_ablex_next_token();
3746 if(token != HECMW_ABLEX_NL) {
3747 set_err_token(token, HECMW_IO_ABAQUS_E1900, "NL required after Zc");
3748 return -1;
3749 }
3750
3751 return 0;
3752}
3753
3754
3755static int
3756read_system(void)
3757{
3758 int token,state;
3759 struct hecmw_system_param *system = NULL;
3760 enum {
3761 ST_FINISHED,
3762 ST_KEYWORD_LINE,
3763 ST_DATA_LINE1,
3764 ST_DATA_LINE2
3765 };
3766
3767 fprintf(stderr, "*SYSTEM has not implemented yet\n");
3769
3770 system = HECMW_malloc(sizeof(*system));
3771 if(system == NULL) {
3772 set_err(errno, "");
3773 return -1;
3774 }
3775
3776 /* default values */
3777 system->xa = 0.0;
3778 system->ya = 0.0;
3779 system->za = 0.0;
3780 system->xb = 0.0;
3781 system->yb = 0.0;
3782 system->zb = 0.0;
3783 system->xc = 0.0;
3784 system->yc = 0.0;
3785 system->zc = 0.0;
3786
3787 state = ST_KEYWORD_LINE;
3788 while(state != ST_FINISHED) {
3789 if(state == ST_KEYWORD_LINE) {
3790 if(read_system_keyword()) return -1;
3791 /* check next state */
3792 token = HECMW_ablex_next_token();
3793 if(token != HECMW_ABLEX_DOUBLE && token != HECMW_ABLEX_INT && token != ',') {
3794 /* clear *SYSTEM */
3795 HECMW_free(system);
3796 system = NULL;
3797 state = ST_FINISHED;
3798 } else {
3799 state = ST_DATA_LINE1;
3800 }
3802 } else if(state == ST_DATA_LINE1) {
3803 if(read_system_data_line1a(system, &token)) return -1;
3804 if(token == HECMW_ABLEX_NL) {
3805 state = ST_FINISHED;
3806 continue;
3807 }
3808 HECMW_assert(token == ',');
3809
3810 if(read_system_data_line1b(system)) return -1;
3811 token = HECMW_ablex_next_token();
3812 if(token != HECMW_ABLEX_DOUBLE && token != HECMW_ABLEX_INT && token != ',') {
3813 state = ST_FINISHED;
3814 } else {
3815 state = ST_DATA_LINE2;
3816 }
3818 } else if(state == ST_DATA_LINE2) {
3819 if(read_system_data_line2(system)) return -1;
3820 state = ST_FINISHED;
3821 } else {
3822 HECMW_assert(0);
3823 }
3824 }
3825
3826 /* set */
3827 HECMW_io_set_system(system);
3828
3829 return 0;
3830}
3831#endif
3832
3833/*----------------------------------------------------------------------------*/
3834static int read_boundary_keyword(void) {
3835 int token;
3836 /* static int isFirst = 0; */
3837
3838 /* *BOUNDARY */
3839 token = HECMW_ablex_next_token();
3840 if (token != HECMW_ABLEX_H_BOUNDARY) {
3841 set_err_token(token, HECMW_IO_ABAQUS_E1500, "*BOUDARY required");
3842 return -1;
3843 }
3844 token = HECMW_ablex_next_token();
3845 if (token != HECMW_ABLEX_NL) {
3846 set_err_token(token, HECMW_IO_ABAQUS_E1700,
3847 "',' is not required after *BOUDARY SECTION");
3848 return -1;
3849 }
3850 /* if(isFirst == 0) { */
3851 fprintf(stderr,
3852 "Auto-generated cards should be added in !BOUNDARY section of *.cnt "
3853 "file \n");
3854 /* isFirst =1; */
3855 /*} */
3856 return 0;
3857}
3858
3859static int read_boundary_data(int *nnode, int **node_array) {
3860 int i, n, *node, token;
3861 int isFirst, isSuggest, isNode;
3862 struct hecmw_io_id *head, *prev, *p, *q;
3863
3864 n = 0;
3865 isNode = 0;
3866 isSuggest = 0;
3867 head = NULL;
3868 node = NULL;
3869 while (1) {
3870 struct hecmw_io_id *id;
3871
3872 token = HECMW_ablex_next_token();
3873 if (token == HECMW_ABLEX_NL) break;
3874
3875 id = HECMW_malloc(sizeof(*id));
3876 if (id == NULL) {
3877 set_err(errno, "");
3878 goto error;
3879 }
3880
3881 /* node or NGRP */
3882 if (token != HECMW_ABLEX_INT && token != HECMW_ABLEX_DOUBLE &&
3883 token != ',') {
3884 isNode = 1;
3885 }
3886
3887 if (token == HECMW_ABLEX_NAME) {
3888 isSuggest = 1;
3889 char *c = HECMW_ablex_get_text();
3890 fprintf(stderr, "%s", c);
3891 }
3892 if (token == HECMW_ABLEX_INT && isSuggest == 1) {
3893 int i = HECMW_ablex_get_number();
3894 fprintf(stderr, ", %d", i);
3895 }
3896 if (token == HECMW_ABLEX_DOUBLE && isSuggest == 1) {
3897 double a = HECMW_ablex_get_number();
3898 fprintf(stderr, ", %f", a);
3899 }
3900
3901 if (token == ',') {
3902 id->id = 0;
3904 } else if (token == HECMW_ABLEX_INT) {
3905 id->id = HECMW_ablex_get_number();
3906 }
3907
3908 if (isNode == 0) {
3909 id->next = NULL;
3910 if (head == NULL) {
3911 head = id;
3912 } else {
3913 prev->next = id;
3914 }
3915 prev = id;
3916 n++;
3917 isNode = 1;
3918
3920 HECMW_assert(n > 0);
3921 }
3922
3923 /* ',' or NL */
3924 token = HECMW_ablex_next_token();
3925 if (token != ',' && token != HECMW_ABLEX_NL) {
3926 set_err_token(token, HECMW_IO_ABAQUS_E1500,
3927 "',' or NL required after node ID");
3928 goto error;
3929 }
3930 if (token == HECMW_ABLEX_NL) break;
3931 }
3932
3933 node = HECMW_malloc(sizeof(*node) * n);
3934 if (node == NULL) {
3935 set_err(errno, "");
3936 goto error;
3937 }
3938 i = 0;
3939 for (p = head; p; p = q) {
3940 q = p->next;
3941 node[i++] = p->id;
3942 HECMW_free(p);
3943 }
3944 head = NULL;
3945 isNode = 0;
3946
3947 *nnode = n;
3948 *node_array = node;
3949
3950 if (isSuggest == 1) {
3951 fprintf(stderr, "\n");
3952 isSuggest = 0;
3953 }
3954
3955 return 0;
3956error:
3957 for (p = head; p; p = q) {
3958 q = p->next;
3959 HECMW_free(p);
3960 }
3961 HECMW_free(node);
3962 return -1;
3963}
3964
3965static int read_boudary(void) {
3966 int token, state;
3967 int flag_boundary = 0; /* flag for BOUNDARY */
3968 int isNodeInput = 0;
3969 static int nbound = 0;
3970 char nset[HECMW_NAME_LEN + 1] = "";
3971 enum { ST_FINISHED, ST_KEYWORD_LINE, ST_KEYWORD_LINE_PARAM, ST_DATA_LINE };
3972
3973 state = ST_KEYWORD_LINE;
3974 while (state != ST_FINISHED) {
3975 if (state == ST_KEYWORD_LINE) {
3976 if (read_boundary_keyword()) return -1;
3977 state = ST_DATA_LINE;
3978 flag_boundary = 1;
3979 } else if (state == ST_KEYWORD_LINE_PARAM) {
3980 ;
3981 } else if (state == ST_DATA_LINE) {
3982 int n = 0;
3983 int *node;
3984
3985 HECMW_assert(flag_boundary);
3986 if (read_boundary_data(&n, &node)) return -1;
3987
3988 if (n > 0) {
3989 isNodeInput = 1;
3990
3991 /* add node to group */
3992 sprintf(nset, "BND%d", nbound);
3993 if (HECMW_io_add_ngrp(nset, n, node) < 0) return -1;
3994 HECMW_free(node);
3995 }
3996
3997 /* check next state */
3998 token = HECMW_ablex_next_token();
3999 if (token != HECMW_ABLEX_INT && token != HECMW_ABLEX_NAME) {
4000 state = ST_FINISHED;
4001 } else {
4002 state = ST_DATA_LINE;
4003 }
4005 } else {
4006 HECMW_assert(0);
4007 }
4008 }
4009
4010 if (isNodeInput == 1) {
4011 fprintf(stderr, "NGRP=BND%d\n", nbound);
4012 nbound++;
4013 }
4014
4015 return 0;
4016}
4017
4018/*----------------------------------------------------------------------------*/
4019static int read_cload_keyword(void) {
4020 int token;
4021 static int isFirst = 0;
4022
4023 /* *BOUNDARY */
4024 token = HECMW_ablex_next_token();
4025 if (token != HECMW_ABLEX_H_CLOAD) {
4026 set_err_token(token, HECMW_IO_ABAQUS_E1500, "*CLOAD required");
4027 return -1;
4028 }
4029 token = HECMW_ablex_next_token();
4030 if (token != HECMW_ABLEX_NL) {
4031 set_err_token(token, HECMW_IO_ABAQUS_E1700,
4032 "',' is not required after *CLOAD SECTION");
4033 return -1;
4034 }
4035 /*if(isFirst == 0) {*/
4036 fprintf(stderr,
4037 "Auto-generated cards should be added in !CLOAD section of *.cnt "
4038 "file \n");
4039 isFirst = 1;
4040 /*}*/
4041 return 0;
4042}
4043
4044static int read_cload(void) {
4045 int token, state;
4046 int flag_cload = 0; /* flag for CLOAD */
4047 int isCload = 0;
4048 static int ncload = 0;
4049 char nset[HECMW_NAME_LEN + 1] = "";
4050 enum { ST_FINISHED, ST_KEYWORD_LINE, ST_KEYWORD_LINE_PARAM, ST_DATA_LINE };
4051
4052 state = ST_KEYWORD_LINE;
4053 while (state != ST_FINISHED) {
4054 if (state == ST_KEYWORD_LINE) {
4055 if (read_cload_keyword()) return -1;
4056 state = ST_DATA_LINE;
4057 flag_cload = 1;
4058 } else if (state == ST_KEYWORD_LINE_PARAM) {
4059 ;
4060 } else if (state == ST_DATA_LINE) {
4061 int n, *node;
4062
4063 HECMW_assert(flag_cload);
4064 if (read_boundary_data(&n, &node)) return -1;
4065
4066 /* add node to group */
4067 if (n != 0) {
4068 isCload = 1;
4069
4070 sprintf(nset, "CLOAD%d", ncload);
4071 if (HECMW_io_add_ngrp(nset, n, node) < 0) return -1;
4072 HECMW_free(node);
4073 }
4074
4075 /* check next state */
4076 token = HECMW_ablex_next_token();
4077 if (token != HECMW_ABLEX_INT) {
4078 state = ST_FINISHED;
4079 } else {
4080 state = ST_DATA_LINE;
4081 }
4083 } else {
4084 HECMW_assert(0);
4085 }
4086 }
4087
4088 if (isCload != 0) {
4089 fprintf(stderr, "NGRP=CLOAD%d\n", ncload);
4090 ncload++;
4091 }
4092
4093 return 0;
4094}
4095
4096/*----------------------------------------------------------------------------*/
4097static int read_dload_keyword(void) {
4098 int token;
4099 static int isFirst = 0;
4100
4101 /* *DLOAD */
4102 token = HECMW_ablex_next_token();
4103 if (token != HECMW_ABLEX_H_DLOAD) {
4104 set_err_token(token, HECMW_IO_ABAQUS_E1500, "*DLOAD required");
4105 return -1;
4106 }
4107 token = HECMW_ablex_next_token();
4108 if (token != HECMW_ABLEX_NL) {
4109 set_err_token(token, HECMW_IO_ABAQUS_E1700,
4110 "',' is not required after *DLOAD SECTION");
4111 return -1;
4112 }
4113 /*if(isFirst == 0) {*/
4114 fprintf(stderr,
4115 "Auto-generated cards should be added in !DLOAD section of *.cnt "
4116 "file \n");
4117 isFirst = 1;
4118 /*}*/
4119 return 0;
4120}
4121
4122static int read_dload(void) {
4123 int token, state;
4124 int flag_dload = 0; /* flag for DLOAD */
4125 int isDload = 0;
4126 static int ndload = 0;
4127 char elset[HECMW_NAME_LEN + 1] = "";
4128 enum { ST_FINISHED, ST_KEYWORD_LINE, ST_KEYWORD_LINE_PARAM, ST_DATA_LINE };
4129
4130 state = ST_KEYWORD_LINE;
4131 while (state != ST_FINISHED) {
4132 if (state == ST_KEYWORD_LINE) {
4133 if (read_dload_keyword()) return -1;
4134 state = ST_DATA_LINE;
4135 flag_dload = 1;
4136 } else if (state == ST_KEYWORD_LINE_PARAM) {
4137 ;
4138 } else if (state == ST_DATA_LINE) {
4139 int n, *elem;
4140
4141 HECMW_assert(flag_dload);
4142 if (read_boundary_data(&n, &elem)) return -1;
4143
4144 if (n != 0) {
4145 isDload = 1;
4146 /* add node to group */
4147 sprintf(elset, "DLOAD%d", ndload);
4148 if (HECMW_io_add_egrp(elset, n, elem) < 0) return -1;
4149 HECMW_free(elem);
4150 }
4151
4152 /* check next state */
4153 token = HECMW_ablex_next_token();
4154 if (token != HECMW_ABLEX_INT) {
4155 state = ST_FINISHED;
4156 } else {
4157 state = ST_DATA_LINE;
4158 }
4160 } else {
4161 HECMW_assert(0);
4162 }
4163 }
4164
4165 if (isDload != 0) {
4166 fprintf(stderr, "NGRP=DLOAD%d is automatically generated\n", ndload);
4167 ndload++;
4168 }
4169
4170 return 0;
4171}
4172
4173/*------------------------------------------------------------------------------
4174 ReadFunc table
4175*/
4176
4177typedef int (*ReadFunc)(void);
4178
4179static struct read_func_table {
4180 int token;
4181 ReadFunc func;
4182} read_func_table[] = {
4183 {HECMW_ABLEX_H_AMPLITUDE, read_amplitude},
4184 {HECMW_ABLEX_H_BOUNDARY, read_boudary},
4185 {HECMW_ABLEX_H_CONDUCTIVITY, read_conductivity},
4186 {HECMW_ABLEX_H_CLOAD, read_cload},
4187 {HECMW_ABLEX_H_DLOAD, read_dload},
4188 {HECMW_ABLEX_H_DENSITY, read_density},
4189 /* { HECMW_ABLEX_H_ECOPY, read_ecopy }, */
4190 /* { HECMW_ABLEX_H_EGEN, read_egen }, */
4191 {HECMW_ABLEX_H_ELASTIC, read_elastic},
4192 {HECMW_ABLEX_H_ELEMENT, read_element},
4193 {HECMW_ABLEX_H_ELSET, read_elset},
4194 {HECMW_ABLEX_H_EQUATION, read_equation},
4195 {HECMW_ABLEX_H_HEADING, read_heading},
4196 {HECMW_ABLEX_H_INCLUDE, read_include},
4197 {HECMW_ABLEX_H_INITIAL, read_initial},
4198 {HECMW_ABLEX_H_MATERIAL, read_material},
4199 /* { HECMW_ABLEX_H_NCOPY, read_ncopy }, */
4200 /* { HECMW_ABLEX_H_NFILL, read_nfill }, */
4201 /* { HECMW_ABLEX_H_NGEN, read_ngen }, */
4202 {HECMW_ABLEX_H_NODE, read_node},
4203 {HECMW_ABLEX_H_NSET, read_nset},
4204 {HECMW_ABLEX_H_SHELL_SECTION, read_shell_section},
4205 {HECMW_ABLEX_H_SOLID_SECTION, read_solid_section},
4206 {HECMW_ABLEX_H_SPECIFIC_HEAT, read_specific_heat},
4207 /* { HECMW_ABLEX_H_SYSTEM, read_system }, */
4208};
4209
4210#define N_READ_FUNC (sizeof(read_func_table) / sizeof(read_func_table[0]))
4211
4212/* static int (* get_read_func(int token))(void) */
4213static ReadFunc get_read_func(int token) {
4214 int i;
4215
4216 for (i = 0; i < N_READ_FUNC; i++) {
4217 if (token == read_func_table[i].token) {
4218 return read_func_table[i].func;
4219 }
4220 }
4221 return NULL;
4222}
4223
4224static int parse(void) {
4225 int token, head;
4226 ReadFunc func;
4227
4228 while ((token = HECMW_ablex_next_token())) {
4229 if (token == HECMW_ABLEX_NL) continue;
4230 head = token;
4231 func = get_read_func(token);
4232 if (func == NULL) {
4233 char *p = HECMW_ablex_get_text();
4234 if (p[0] != '*') {
4235 set_err(HECMW_IO_ABAQUS_E0098, "");
4236 return -1;
4237 }
4238 /* skip unsupported keyword */
4239 token = HECMW_ablex_next_token();
4240 p = token ? HECMW_ablex_get_text() : "";
4242 if (!token) break;
4243 while ((token = HECMW_ablex_next_token())) {
4245 if (p[0] == '*') break;
4246 }
4247 if (!token) break;
4248 HECMW_ablex_unput_token(); /* unput *XXXX */
4249 continue;
4250 }
4251 if (is_material_keyword(token) && !is_material_zone()) {
4252 set_err(HECMW_IO_ABAQUS_E0096, "keyword: %s", HECMW_ablex_get_text());
4253 return -1;
4254 }
4255 if (!is_material_keyword(token) && is_material_zone()) {
4256 if (regist_material()) return -1;
4257 set_material_zone(0);
4258 }
4259 HECMW_ablex_unput_token(); /* unput *XXXX */
4260 if ((*func)()) return -1;
4262 set_material_zone(1);
4263 }
4264 }
4265 if (is_material_zone()) {
4266 if (regist_material()) return -1;
4267 set_material_zone(0);
4268 }
4269 return 0;
4270}
4271
4272/*----------------------------------------------------------------------------*/
4273
4274static int post_abaqus(void) {
4275 HECMW_map_int_finalize(elem_secopt);
4276 HECMW_free(elem_secopt);
4277 return 0;
4278}
4279
4280/* read only. Not make hecmwST_local_mesh */
4281int HECMW_read_abaqus_mesh(const char *filename) {
4282 FILE *fp;
4283
4284 HECMW_log(HECMW_LOG_DEBUG, "Start to read ABAQUS mesh");
4285
4286 if (filename == NULL) {
4287 set_err_noloc(HECMW_IO_E0001,
4288 "Not specified filename for ABAQUS mesh input routine");
4289 return -1;
4290 }
4291 HECMW_log(HECMW_LOG_DEBUG, "ABAQUS mesh file is '%s'", filename);
4292
4293 if (strlen(filename) > HECMW_FILENAME_LEN) {
4294 set_err_noloc(HECMW_IO_E0002, "");
4295 return -1;
4296 }
4297
4298 strcpy(grid_filename, filename);
4299 HECMW_io_set_gridfile(grid_filename);
4300
4301 if ((fp = fopen(filename, "r")) == NULL) {
4302 set_err_noloc(HECMW_IO_ABAQUS_E0001, "File: %s, %s", filename,
4303 strerror(errno));
4304 return -1;
4305 }
4306
4307 if (HECMW_ablex_set_input(fp)) return -1;
4308
4309 HECMW_log(HECMW_LOG_DEBUG, "Parsing...");
4310 if (parse()) {
4311 return -1;
4312 }
4313
4314 if (fclose(fp)) {
4315 set_err_noloc(HECMW_IO_ABAQUS_E0002, "File: %s, %s", filename,
4316 strerror(errno));
4317 return -1;
4318 }
4319
4320 if (post_abaqus()) {
4321 return -1;
4322 }
4323
4324 strcpy(grid_filename, "Unknown");
4325
4326 return 0;
4327}
4328
4329struct hecmwST_local_mesh *HECMW_get_abaqus_mesh(const char *filename) {
4330 struct hecmwST_local_mesh *local_mesh;
4331
4332 if (HECMW_io_init()) return NULL;
4333 if (HECMW_io_pre_process()) return NULL;
4334 if (HECMW_read_abaqus_mesh(filename)) return NULL;
4335 if (HECMW_io_post_process()) return NULL;
4336 local_mesh = HECMW_io_make_local_mesh();
4337 if (local_mesh == NULL) return NULL;
4338 if (HECMW_io_finalize()) return NULL;
4339
4340 strcpy(grid_filename, "Unknown");
4341
4342 return local_mesh;
4343}
int HECMW_ablex_get_lineno(void)
Definition: hecmw_ablex.c:3655
int HECMW_ablex_unput_token(void)
Definition: hecmw_ablex.c:3726
int HECMW_ablex_next_token(void)
Definition: hecmw_ablex.c:3665
int HECMW_ablex_is_including(void)
Definition: hecmw_ablex.c:3663
int HECMW_ablex_switch_to_include(const char *filename)
Definition: hecmw_ablex.c:3704
double HECMW_ablex_get_number(void)
Definition: hecmw_ablex.c:3659
char * HECMW_ablex_get_text(void)
Definition: hecmw_ablex.c:3661
int HECMW_ablex_set_input(FILE *fp)
Definition: hecmw_ablex.c:3677
@ HECMW_ABLEX_E_DC2D8
Definition: hecmw_ablex.h:114
@ HECMW_ABLEX_E_DC3D6
Definition: hecmw_ablex.h:116
@ HECMW_ABLEX_E_INTER8
Definition: hecmw_ablex.h:130
@ HECMW_ABLEX_E_CPE6
Definition: hecmw_ablex.h:99
@ HECMW_ABLEX_E_CPS3
Definition: hecmw_ablex.h:102
@ HECMW_ABLEX_E_DCAX6
Definition: hecmw_ablex.h:123
@ HECMW_ABLEX_E_C3D15
Definition: hecmw_ablex.h:86
@ HECMW_ABLEX_E_CAX4R
Definition: hecmw_ablex.h:91
@ HECMW_ABLEX_E_S4R
Definition: hecmw_ablex.h:132
@ HECMW_ABLEX_H_INITIAL
Definition: hecmw_ablex.h:29
@ HECMW_ABLEX_K_TYPE
Definition: hecmw_ablex.h:70
@ HECMW_ABLEX_K_LAMINA
Definition: hecmw_ablex.h:57
@ HECMW_ABLEX_E_DC3D4
Definition: hecmw_ablex.h:115
@ HECMW_ABLEX_E_DC1D3
Definition: hecmw_ablex.h:110
@ HECMW_ABLEX_E_CAX4I
Definition: hecmw_ablex.h:90
@ HECMW_ABLEX_K_RELATIVE
Definition: hecmw_ablex.h:64
@ HECMW_ABLEX_E_T3D2
Definition: hecmw_ablex.h:134
@ HECMW_ABLEX_E_DC2D4
Definition: hecmw_ablex.h:112
@ HECMW_ABLEX_E_DC3D15
Definition: hecmw_ablex.h:119
@ HECMW_ABLEX_E_DS8
Definition: hecmw_ablex.h:128
@ HECMW_ABLEX_E_CPE8
Definition: hecmw_ablex.h:100
@ HECMW_ABLEX_H_DENSITY
Definition: hecmw_ablex.h:21
@ HECMW_ABLEX_H_HEADING
Definition: hecmw_ablex.h:27
@ HECMW_ABLEX_H_CONDUCTIVITY
Definition: hecmw_ablex.h:20
@ HECMW_ABLEX_E_CPE4R
Definition: hecmw_ablex.h:98
@ HECMW_ABLEX_E_C3D20
Definition: hecmw_ablex.h:87
@ HECMW_ABLEX_E_CAX8R
Definition: hecmw_ablex.h:94
@ HECMW_ABLEX_H_INCLUDE
Definition: hecmw_ablex.h:28
@ HECMW_ABLEX_K_TABULAR
Definition: hecmw_ablex.h:67
@ HECMW_ABLEX_E_C3D8I
Definition: hecmw_ablex.h:84
@ HECMW_ABLEX_H_SHELL_SECTION
Definition: hecmw_ablex.h:33
@ HECMW_ABLEX_E_C3D6
Definition: hecmw_ablex.h:82
@ HECMW_ABLEX_E_B32
Definition: hecmw_ablex.h:80
@ HECMW_ABLEX_K_DEPENDENCIES
Definition: hecmw_ablex.h:51
@ HECMW_ABLEX_H_DLOAD
Definition: hecmw_ablex.h:39
@ HECMW_ABLEX_HEADER
Definition: hecmw_ablex.h:17
@ HECMW_ABLEX_NAME
Definition: hecmw_ablex.h:15
@ HECMW_ABLEX_E_CPS6
Definition: hecmw_ablex.h:106
@ HECMW_ABLEX_INT
Definition: hecmw_ablex.h:13
@ HECMW_ABLEX_K_ABSOLUTE
Definition: hecmw_ablex.h:46
@ HECMW_ABLEX_K_ISOTROPIC
Definition: hecmw_ablex.h:54
@ HECMW_ABLEX_K_VALUE
Definition: hecmw_ablex.h:72
@ HECMW_ABLEX_H_NODE
Definition: hecmw_ablex.h:31
@ HECMW_ABLEX_K_ENGINEERING_CONSTANTS
Definition: hecmw_ablex.h:49
@ HECMW_ABLEX_K_STEP_TIME
Definition: hecmw_ablex.h:65
@ HECMW_ABLEX_E_DC3D20
Definition: hecmw_ablex.h:120
@ HECMW_ABLEX_E_S8R
Definition: hecmw_ablex.h:133
@ HECMW_ABLEX_E_DCAX8
Definition: hecmw_ablex.h:124
@ HECMW_ABLEX_E_CAX4
Definition: hecmw_ablex.h:89
@ HECMW_ABLEX_E_DC1D2
Definition: hecmw_ablex.h:109
@ HECMW_ABLEX_H_ELASTIC
Definition: hecmw_ablex.h:22
@ HECMW_ABLEX_E_INTER4
Definition: hecmw_ablex.h:129
@ HECMW_ABLEX_E_DC2D6
Definition: hecmw_ablex.h:113
@ HECMW_ABLEX_E_DCAX3
Definition: hecmw_ablex.h:121
@ HECMW_ABLEX_H_AMPLITUDE
Definition: hecmw_ablex.h:19
@ HECMW_ABLEX_K_GENERATE
Definition: hecmw_ablex.h:52
@ HECMW_ABLEX_E_CPE8R
Definition: hecmw_ablex.h:101
@ HECMW_ABLEX_H_SOLID_SECTION
Definition: hecmw_ablex.h:34
@ HECMW_ABLEX_K_ELSET
Definition: hecmw_ablex.h:48
@ HECMW_ABLEX_E_DINTER8
Definition: hecmw_ablex.h:126
@ HECMW_ABLEX_K_ORIENTATION
Definition: hecmw_ablex.h:63
@ HECMW_ABLEX_E_C3D8
Definition: hecmw_ablex.h:83
@ HECMW_ABLEX_K_MODULI
Definition: hecmw_ablex.h:59
@ HECMW_ABLEX_E_CPS4I
Definition: hecmw_ablex.h:104
@ HECMW_ABLEX_K_INPUT
Definition: hecmw_ablex.h:53
@ HECMW_ABLEX_K_TIME
Definition: hecmw_ablex.h:69
@ HECMW_ABLEX_H_SPECIFIC_HEAT
Definition: hecmw_ablex.h:35
@ HECMW_ABLEX_H_CLOAD
Definition: hecmw_ablex.h:38
@ HECMW_ABLEX_H_NSET
Definition: hecmw_ablex.h:32
@ HECMW_ABLEX_E_CPE4I
Definition: hecmw_ablex.h:97
@ HECMW_ABLEX_E_DCAX4
Definition: hecmw_ablex.h:122
@ HECMW_ABLEX_K_DEFINITION
Definition: hecmw_ablex.h:50
@ HECMW_ABLEX_H_ELSET
Definition: hecmw_ablex.h:24
@ HECMW_ABLEX_E_CAX8
Definition: hecmw_ablex.h:93
@ HECMW_ABLEX_DOUBLE
Definition: hecmw_ablex.h:14
@ HECMW_ABLEX_E_C3D10
Definition: hecmw_ablex.h:85
@ HECMW_ABLEX_H_BOUNDARY
Definition: hecmw_ablex.h:37
@ HECMW_ABLEX_K_MATERIAL
Definition: hecmw_ablex.h:58
@ HECMW_ABLEX_E_DS4
Definition: hecmw_ablex.h:127
@ HECMW_ABLEX_E_CPS4R
Definition: hecmw_ablex.h:105
@ HECMW_ABLEX_E_CPE3
Definition: hecmw_ablex.h:95
@ HECMW_ABLEX_E_DC3D8
Definition: hecmw_ablex.h:117
@ HECMW_ABLEX_E_CAX3
Definition: hecmw_ablex.h:88
@ HECMW_ABLEX_E_CAX6
Definition: hecmw_ablex.h:92
@ HECMW_ABLEX_K_NSET
Definition: hecmw_ablex.h:61
@ HECMW_ABLEX_NL
Definition: hecmw_ablex.h:12
@ HECMW_ABLEX_E_CPS4
Definition: hecmw_ablex.h:103
@ HECMW_ABLEX_K_INSTANCE
Definition: hecmw_ablex.h:55
@ HECMW_ABLEX_K_TEMPERATURE
Definition: hecmw_ablex.h:68
@ HECMW_ABLEX_E_DC3D10
Definition: hecmw_ablex.h:118
@ HECMW_ABLEX_K_NAME
Definition: hecmw_ablex.h:60
@ HECMW_ABLEX_H_SYSTEM
Definition: hecmw_ablex.h:36
@ HECMW_ABLEX_H_EQUATION
Definition: hecmw_ablex.h:26
@ HECMW_ABLEX_E_T3D3
Definition: hecmw_ablex.h:135
@ HECMW_ABLEX_K_ANISOTROPIC
Definition: hecmw_ablex.h:47
@ HECMW_ABLEX_E_C3D4
Definition: hecmw_ablex.h:81
@ HECMW_ABLEX_E_CPS8
Definition: hecmw_ablex.h:107
@ HECMW_ABLEX_K_SYSTEM
Definition: hecmw_ablex.h:66
@ HECMW_ABLEX_K_UNSORTED
Definition: hecmw_ablex.h:71
@ HECMW_ABLEX_E_DINTER4
Definition: hecmw_ablex.h:125
@ HECMW_ABLEX_E_B31
Definition: hecmw_ablex.h:79
@ HECMW_ABLEX_E_S3R
Definition: hecmw_ablex.h:131
@ HECMW_ABLEX_K_ORTHOTROPIC
Definition: hecmw_ablex.h:62
@ HECMW_ABLEX_E_CPS8R
Definition: hecmw_ablex.h:108
@ HECMW_ABLEX_E_CPE4
Definition: hecmw_ablex.h:96
@ HECMW_ABLEX_E_DC2D3
Definition: hecmw_ablex.h:111
@ HECMW_ABLEX_H_MATERIAL
Definition: hecmw_ablex.h:30
@ HECMW_ABLEX_FILENAME
Definition: hecmw_ablex.h:16
@ HECMW_ABLEX_K_INSTANTANEOUS
Definition: hecmw_ablex.h:56
@ HECMW_ABLEX_H_ELEMENT
Definition: hecmw_ablex.h:23
HECMW_Comm HECMW_comm_get_comm(void)
Definition: hecmw_comm.c:699
#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_HEADER_LEN
Definition: hecmw_config.h:68
#define HECMW_NAME_LEN
Definition: hecmw_config.h:70
int HECMW_convert_connectivity(int from, int hecmw_etype, int *conn)
#define HECMW_CONNTYPE_ABAQUS
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_cylindrical_to_cartesian(const struct hecmw_coord *coord, struct hecmw_coord *result)
double HECMW_degree_to_radian(double deg)
int HECMW_read_abaqus_mesh(const char *filename)
struct hecmwST_local_mesh * HECMW_get_abaqus_mesh(const char *filename)
int(* ReadFunc)(void)
#define N_READ_FUNC
#define N_MAT_KEYS
int(* ReadFunc)(void)
int HECMW_io_check_mpc_dof(int dof)
int HECMW_io_is_reserved_name(const char *name)
int HECMW_io_add_ngrp(const char *name, int nnode, int *node)
struct hecmw_io_material * HECMW_io_get_mat(const char *name)
struct hecmw_io_element * HECMW_io_add_elem(int id, int type, int *node, int nmatitem, double *matitem)
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)
struct hecmw_io_amplitude * HECMW_io_add_amp(const char *name, int definition, int time, int value, double val, double t)
struct hecmw_io_initial * HECMW_io_add_initial(int type, int node, const char *ngrp, double val)
struct hecmw_io_section * HECMW_io_add_sect(struct hecmw_io_section *sect)
struct hecmw_io_mpc * HECMW_io_add_mpc(int neq, const struct hecmw_io_mpcitem *mpcitem, double cnst)
int HECMW_io_init(void)
int HECMW_io_pre_process(void)
void HECMW_io_set_system(struct hecmw_system_param *system)
int HECMW_io_post_process(void)
struct hecmw_system_param * HECMW_io_get_system(void)
struct hecmw_io_id_array * HECMW_io_get_elem_in_egrp(const char *name)
int HECMW_io_set_gridfile(char *gridfile)
int HECMW_io_finalize(void)
struct hecmw_io_material * HECMW_io_add_mat(const char *name, struct hecmw_io_material *mat)
void HECMW_io_set_header(struct hecmw_io_header *header)
#define NULL
#define HECMW_INITIAL_TYPE_TEMPERATURE
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_WARN
Definition: hecmw_log.h:17
#define HECMW_LOG_DEBUG
Definition: hecmw_log.h:21
#define HECMW_calloc(nmemb, size)
Definition: hecmw_malloc.h:21
#define HECMW_free(ptr)
Definition: hecmw_malloc.h:24
#define HECMW_strdup(s)
Definition: hecmw_malloc.h:23
#define HECMW_malloc(size)
Definition: hecmw_malloc.h:20
int HECMW_map_int_add(struct hecmw_map_int *map, int key, void *value)
void HECMW_map_int_finalize(struct hecmw_map_int *map)
Definition: hecmw_map_int.c:40
void * HECMW_map_int_get(const struct hecmw_map_int *map, int key)
int HECMW_map_int_init(struct hecmw_map_int *map, void(*free_fnc)(void *))
Definition: hecmw_map_int.c:18
#define HECMW_IO_ABAQUS_E0501
Definition: hecmw_msgno.h:77
#define HECMW_IO_ABAQUS_E1500
Definition: hecmw_msgno.h:107
#define HECMW_IO_ABAQUS_E0900
Definition: hecmw_msgno.h:91
#define HECMW_IO_ABAQUS_E1503
Definition: hecmw_msgno.h:110
#define HECMW_IO_ABAQUS_E0901
Definition: hecmw_msgno.h:92
#define HECMW_IO_ABAQUS_E0503
Definition: hecmw_msgno.h:79
#define HECMW_IO_ABAQUS_E0002
Definition: hecmw_msgno.h:67
#define HECMW_IO_ABAQUS_E0502
Definition: hecmw_msgno.h:78
#define HECMW_IO_ABAQUS_W0095
Definition: hecmw_msgno.h:138
#define HECMW_IO_ABAQUS_E0098
Definition: hecmw_msgno.h:70
#define HECMW_IO_ABAQUS_E1705
Definition: hecmw_msgno.h:118
#define HECMW_IO_ABAQUS_E2100
Definition: hecmw_msgno.h:125
#define HECMW_IO_ABAQUS_E2500
Definition: hecmw_msgno.h:137
#define HECMW_IO_ABAQUS_E1706
Definition: hecmw_msgno.h:119
#define HECMW_IO_ABAQUS_E1002
Definition: hecmw_msgno.h:95
#define HECMW_IO_E1026
Definition: hecmw_msgno.h:158
#define HECMW_IO_ABAQUS_E0604
Definition: hecmw_msgno.h:83
#define HECMW_IO_ABAQUS_E0101
Definition: hecmw_msgno.h:72
#define HECMW_IO_ABAQUS_E1700
Definition: hecmw_msgno.h:113
#define HECMW_IO_ABAQUS_E2200
Definition: hecmw_msgno.h:134
#define HECMW_IO_ABAQUS_E0601
Definition: hecmw_msgno.h:81
#define HECMW_IO_ABAQUS_E0603
Definition: hecmw_msgno.h:82
#define HECMW_IO_ABAQUS_E2107
Definition: hecmw_msgno.h:132
#define HECMW_IO_ABAQUS_E2103
Definition: hecmw_msgno.h:128
#define HECMW_IO_ABAQUS_E0600
Definition: hecmw_msgno.h:80
#define HECMW_IO_ABAQUS_E2400
Definition: hecmw_msgno.h:136
#define HECMW_IO_ABAQUS_E1101
Definition: hecmw_msgno.h:97
#define HECMW_IO_E0003
Definition: hecmw_msgno.h:143
#define HECMW_IO_ABAQUS_E0096
Definition: hecmw_msgno.h:69
#define HECMW_IO_ABAQUS_E0606
Definition: hecmw_msgno.h:85
#define HECMW_IO_ABAQUS_E0500
Definition: hecmw_msgno.h:76
#define HECMW_IO_ABAQUS_E0100
Definition: hecmw_msgno.h:71
#define HECMW_IO_ABAQUS_E1702
Definition: hecmw_msgno.h:115
#define HECMW_IO_E0002
Definition: hecmw_msgno.h:142
#define HECMW_IO_ABAQUS_E1000
Definition: hecmw_msgno.h:93
#define HECMW_IO_ABAQUS_E1707
Definition: hecmw_msgno.h:120
#define HECMW_IO_ABAQUS_E1703
Definition: hecmw_msgno.h:116
#define HECMW_IO_ABAQUS_E1600
Definition: hecmw_msgno.h:111
#define HECMW_IO_ABAQUS_E0701
Definition: hecmw_msgno.h:87
#define HECMW_IO_ABAQUS_E0703
Definition: hecmw_msgno.h:89
#define HECMW_IO_ABAQUS_E1001
Definition: hecmw_msgno.h:94
#define HECMW_IO_ABAQUS_E1502
Definition: hecmw_msgno.h:109
#define HECMW_IO_ABAQUS_W0097
Definition: hecmw_msgno.h:139
#define HECMW_IO_ABAQUS_E1900
Definition: hecmw_msgno.h:123
#define HECMW_IO_ABAQUS_W0099
Definition: hecmw_msgno.h:140
#define HECMW_IO_ABAQUS_E2105
Definition: hecmw_msgno.h:130
#define HECMW_IO_ABAQUS_E1501
Definition: hecmw_msgno.h:108
#define HECMW_IO_E0001
Definition: hecmw_msgno.h:141
#define HECMW_IO_W1021
Definition: hecmw_msgno.h:274
#define HECMW_IO_ABAQUS_E0702
Definition: hecmw_msgno.h:88
#define HECMW_IO_ABAQUS_E2108
Definition: hecmw_msgno.h:133
#define HECMW_IO_ABAQUS_E0700
Definition: hecmw_msgno.h:86
#define HECMW_IO_ABAQUS_E1102
Definition: hecmw_msgno.h:98
#define HECMW_IO_ABAQUS_E2102
Definition: hecmw_msgno.h:127
#define HECMW_IO_ABAQUS_E1100
Definition: hecmw_msgno.h:96
#define HECMW_IO_ABAQUS_E1601
Definition: hecmw_msgno.h:112
#define HECMW_IO_ABAQUS_E0003
Definition: hecmw_msgno.h:68
#define HECMW_IO_ABAQUS_E0800
Definition: hecmw_msgno.h:90
#define HECMW_IO_ABAQUS_E0001
Definition: hecmw_msgno.h:66
#define HECMW_IO_ABAQUS_E2300
Definition: hecmw_msgno.h:135
int HECMW_get_path_separator(void)
Definition: hecmw_path.c:34
int HECMW_is_absolute_path(const char *path)
Definition: hecmw_path.c:45
char * HECMW_dirname(const char *path)
Definition: hecmw_path.c:167
int nelem
int nnode
char head[HECMW_HEADER_LEN+1]
#define HECMW_AMP_TYPEDEF_TABULAR
Definition: hecmw_struct.h:62
#define HECMW_SECT_TYPE_SOLID
Definition: hecmw_struct.h:15
#define HECMW_SECT_TYPE_SHELL
Definition: hecmw_struct.h:16
#define HECMW_AMP_TYPEVAL_RELATIVE
Definition: hecmw_struct.h:68
#define HECMW_AMP_TYPEVAL_ABSOLUTE
Definition: hecmw_struct.h:69
#define HECMW_AMP_TYPETIME_STEP
Definition: hecmw_struct.h:65
int HECMW_system(struct hecmw_system_param *param, struct hecmw_coord *coord, struct hecmw_coord *result)
Definition: hecmw_system.c:12
void HECMW_abort(HECMW_Comm comm)
Definition: hecmw_util.c:88
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
char * HECMW_toupper(char *s)
Definition: hecmw_util.c:102
int HECMW_vsnprintf(char *str, size_t size, const char *format, va_list ap)
Definition: hecmw_util.c:145
#define HECMW_assert(cond)
Definition: hecmw_util.h:40
Separator_result * separator
Definition: matrix_repart.c:16
I/O and Utility.
char header[HECMW_HEADER_LEN+1]
struct hecmw_io_id * next
struct hecmw_io_material::hecmw_io_matitem * item
char name[HECMW_NAME_LEN+1]
union hecmw_io_section::hecmw_io_section_item sect