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