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