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