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