FrontISTR  5.2.0
Large-scale structural analysis program with finit element method
hecmw_part_get_control.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 <math.h>
9 #include <errno.h>
10 
11 #include "hecmw_util.h"
12 #include "hecmw_io.h"
13 
14 #include "hecmw_partlex.h"
15 #include "hecmw_part_define.h"
16 #include "hecmw_part_struct.h"
17 #include "hecmw_part_get_control.h"
18 
19 static char ctrl_file_name[HECMW_FILENAME_LEN] = "\0";
20 static int args_subdomain = 0;
21 
22 /*================================================================================================*/
23 
24 extern int HECMW_part_set_subdomains(int n_domain) {
25  args_subdomain = n_domain;
26  return 0;
27 }
28 
29 extern int HECMW_part_set_ctrl_file_name(char *fname) {
30  if (fname == NULL) {
31  HECMW_set_error(HECMW_PART_E_INV_ARG, "'fname' is NULL");
32  goto error;
33  }
34  if (strlen(fname) > HECMW_FILENAME_LEN) {
36  "control file for partitioner");
37  goto error;
38  }
39 
40  strcpy(ctrl_file_name, fname);
41 
42  return 0;
43 
44 error:
45  return -1;
46 }
47 
48 /*============================================================================*/
49 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
50 /* partitioning type < TYPE={ NODE-BASED | ELEMENT-BASED } > */
51 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
52 static int part_cont_type(void) {
53  int token;
54 
55  /* '=' */
56  token = HECMW_partlex_next_token();
57  if (token != '=') {
59  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
60  "part_cont_type", HECMW_partlex_get_text());
61  return -1;
62  }
63 
64  /* { NODE-BASED | ELEMENT-BASED } */
65  token = HECMW_partlex_next_token();
66  switch (token) {
67  case HECMW_PARTLEX_V_NODE_BASED: /* TYPE=NODE-BASED */
69 
70  case HECMW_PARTLEX_V_ELEMENT_BASED: /* TYPE=ELEMENT-BASED */
72 
73  default:
75  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
76  "part_cont_type", HECMW_partlex_get_text());
77  return -1;
78  }
79 }
80 
81 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
82 /* partitioning method < METHOD={ RCB | KMETIS | PMETIS } > */
83 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
84 static int part_cont_method(void) {
85  int token;
86 
87  /* '=' */
88  token = HECMW_partlex_next_token();
89  if (token != '=') {
91  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
92  "part_cont_method", HECMW_partlex_get_text());
93  return -1;
94  }
95 
96  /* { RCB | KMETIS | PMETIS } */
97  token = HECMW_partlex_next_token();
98  switch (token) {
99  case HECMW_PARTLEX_V_RCB: /* METHOD=RCB */
100  return HECMW_PART_METHOD_RCB;
101 
102  case HECMW_PARTLEX_V_KMETIS: /* METHOD=KMETIS */
104 
105  case HECMW_PARTLEX_V_PMETIS: /* METHOD=PMETIS */
107 
108  default:
110  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
111  "part_cont_method", HECMW_partlex_get_text());
112  return -1;
113  }
114 }
115 
116 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
117 /* number of sub-domains < DOMAIN=n > */
118 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
119 static int part_cont_domain(void) {
120  int token, domain;
121 
122  /* '=' */
123  token = HECMW_partlex_next_token();
124  if (token != '=') {
126  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
127  "part_cont_domain", HECMW_partlex_get_text());
128  return -1;
129  }
130 
131  /* n */
132  token = HECMW_partlex_next_token();
133  switch (token) {
134  case HECMW_PARTLEX_INT: /* DOMAIN=n */
135  domain = (int)HECMW_partlex_get_number();
136  if (domain < 1) {
139  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
140  "part_cont_domain", HECMW_partlex_get_text());
141  return -1;
142  }
143  return domain;
144 
145  default:
147  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
148  "part_cont_domain", HECMW_partlex_get_text());
149  return -1;
150  }
151 }
152 
153 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
154 /* depth of overlapping zone < DEPTH=n > */
155 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
156 static int part_cont_depth(void) {
157  int token, depth;
158 
159  /* '=' */
160  token = HECMW_partlex_next_token();
161  if (token != '=') {
163  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
164  "part_cont_depth", HECMW_partlex_get_text());
165  return -1;
166  }
167 
168  /* n */
169  token = HECMW_partlex_next_token();
170  switch (token) {
171  case HECMW_PARTLEX_INT: /* DEPTH=n */
172  depth = (int)HECMW_partlex_get_number();
173  if (depth < 1) {
175  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
176  "part_cont_depth", HECMW_partlex_get_text());
177  return -1;
178  }
179  return depth;
180 
181  default:
183  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
184  "part_cont_depth", HECMW_partlex_get_text());
185  return -1;
186  }
187 }
188 
189 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
190 /* ucd file name < UCD=filename > */
191 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
192 static int part_cont_ucd(char *name) {
193  char *p;
194  int token, is_print_ucd = 0;
195 
196  /* '=' */
197  token = HECMW_partlex_next_token();
198  if (token != '=') {
200  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
201  "part_cont_ucd", HECMW_partlex_get_text());
202  return -1;
203  }
204 
205  /* filename */
206  token = HECMW_partlex_next_token();
207  switch (token) {
208  case HECMW_PARTLEX_NAME: /* UCD=filename */
209  case HECMW_PARTLEX_FILENAME: /* UCD=filename */
211  if (strlen(p) > HECMW_FILENAME_LEN) {
214  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
215  "part_cont_ucd", HECMW_partlex_get_text());
216  return -1;
217  }
218  strcpy(name, p);
219  is_print_ucd = 1;
220 
221  return is_print_ucd;
222 
223  default:
225  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
226  "part_cont_ucd", HECMW_partlex_get_text());
227  return -1;
228  }
229 
230  HECMW_assert(0);
231 
232  return -1;
233 }
234 
235 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
236 /* partitioning contact < CONTACT={ DEFAULT | AGGREGATE | DISTRIBUTE | SIMPLE }
237  * > */
238 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
239 static int part_cont_contact(void) {
240  int token;
241 
242  /* '=' */
243  token = HECMW_partlex_next_token();
244  if (token != '=') {
246  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
247  "part_cont_method", HECMW_partlex_get_text());
248  return -1;
249  }
250 
251  /* { DEFAULT | AGGREGATE | DISTRIBUTE | SIMPLE } */
252  token = HECMW_partlex_next_token();
253  switch (token) {
254  case HECMW_PARTLEX_V_DEFAULT: /* CONTACT=DEFAULT */
256 
257  case HECMW_PARTLEX_V_AGGREGATE: /* CONTACT=AGGREGATE */
259 
260  case HECMW_PARTLEX_V_DISTRIBUTE: /* CONTACT=DISTRIBUTE */
262 
263  case HECMW_PARTLEX_V_SIMPLE: /* CONTACT=SIMPLE */
265 
266  default:
268  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
269  "part_cont_method", HECMW_partlex_get_text());
270  return -1;
271  }
272 }
273 
274 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
275 /* partitioning directions for RCB partitioning < x, y, z > */
276 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
277 static int part_cont_rcb_divs(int n_domain) {
278  int base, rest, n;
279  int i;
280 
281  for (i = 0; i < n_domain; i++) {
282  n = (int)pow(2, i);
283  base = n_domain / n;
284  rest = n_domain % n;
285 
286  if ((base == 1) && (rest == 0)) return i;
287  if ((base == 0) && (rest == 1)) return 0;
288  if ((base == 1) && (rest > 0)) return -1;
289  }
290 
291  HECMW_assert(0);
292 
293  return 0;
294 }
295 
296 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
297 static int part_cont_rcb_opt(struct hecmw_part_cont_data *cont_data) {
298  int token;
299  int i;
300 
301  if (cont_data->n_domain == 1) {
302  cont_data->n_rcb_div = 0;
303  cont_data->rcb_axis = NULL;
304  return 0;
305  }
306 
307  /* number of decompositions */
308  cont_data->n_rcb_div = part_cont_rcb_divs(cont_data->n_domain);
309  if (cont_data->n_rcb_div < -1) {
311  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%d)", __FILE__, __LINE__,
312  "part_cont_rcb_opt", cont_data->n_domain);
313  return -1;
314  }
315 
316  /* partitioning directions */
317  cont_data->rcb_axis = (int *)HECMW_malloc(sizeof(int) * cont_data->n_rcb_div);
318  if (cont_data->rcb_axis == NULL) {
320  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
321  "part_cont_rcb_opt", "cont_data->rcb_axis");
322  return -1;
323  }
324 
325  for (i = 0; i < cont_data->n_rcb_div; i++) {
326  token = HECMW_partlex_next_token();
327 
328  switch (token) {
329  case 'x':
330  cont_data->rcb_axis[i] = HECMW_PART_RCB_X_AXIS;
331  break;
332 
333  case 'y':
334  cont_data->rcb_axis[i] = HECMW_PART_RCB_Y_AXIS;
335  break;
336 
337  case 'z':
338  cont_data->rcb_axis[i] = HECMW_PART_RCB_Z_AXIS;
339  break;
340 
341  default:
343  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
344  "part_cont_rcb_opt", HECMW_partlex_get_text());
345  HECMW_free(cont_data->rcb_axis);
346  return -1;
347  }
348 
349  token = HECMW_partlex_next_token();
350  if (token != ',' && token != HECMW_PARTLEX_NL && token) {
351  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
352  "part_cont_rcb_opt", HECMW_partlex_get_text());
353  HECMW_free(cont_data->rcb_axis);
354  return -1;
355  }
356 
357  if (i + 1 == cont_data->n_rcb_div) {
358  if (token == ',') {
360  while ((token = HECMW_partlex_next_token()) != HECMW_PARTLEX_NL) {
361  }
362  }
363  break;
364  } else {
365  if (token == HECMW_PARTLEX_NL || !token) {
367  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s", __FILE__, __LINE__,
368  "part_cont_rcb_opt");
369  HECMW_free(cont_data->rcb_axis);
370  return -1;
371  }
372  }
373  }
374 
375  return 0;
376 }
377 
378 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
379 /* control data for partitioner < !PARTITION > */
380 /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
381 static int part_cont_partition(struct hecmw_part_cont_data *cont_data) {
382  int token;
383 
384  cont_data->type = -1;
385  cont_data->method = -1;
386  cont_data->n_domain = -1;
387  cont_data->depth = -1;
388  cont_data->is_print_ucd = -1;
389  cont_data->contact = -1;
390  strcpy(cont_data->ucd_file_name, "\0");
391 
392  while ((token = HECMW_partlex_next_token()) != HECMW_PARTLEX_NL ||
393  (token = HECMW_partlex_next_token())) {
394  switch (token) {
395  case HECMW_PARTLEX_K_TYPE: /* TYPE */
396  cont_data->type = part_cont_type();
397  if (cont_data->type < 0) return -1;
398  break;
399 
400  case HECMW_PARTLEX_K_METHOD: /* METHOD */
401  cont_data->method = part_cont_method();
402  if (cont_data->method < 0) return -1;
403  break;
404 
405  case HECMW_PARTLEX_K_DOMAIN: /* DOMAIN */
406  cont_data->n_domain = part_cont_domain();
407  if (cont_data->n_domain < 0) return -1;
408  break;
409 
410  case HECMW_PARTLEX_K_DEPTH: /* DEPTH */
411  cont_data->depth = part_cont_depth();
412  if (cont_data->depth < 0) return -1;
413  break;
414 
415  case HECMW_PARTLEX_K_UCD: /* UCD */
416  cont_data->is_print_ucd = part_cont_ucd(cont_data->ucd_file_name);
417  if (cont_data->is_print_ucd < 0) return -1;
418  break;
419 
420  case HECMW_PARTLEX_K_CONTACT: /* CONTACT */
421  cont_data->contact = part_cont_contact();
422  if (cont_data->contact < 0) return -1;
423  break;
424 
425  default:
426  HECMW_log(HECMW_LOG_ERROR, "%s %s (%s)",
428  "in control data for partitioner", HECMW_partlex_get_text());
429  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
430  "part_cont_partition", HECMW_partlex_get_text());
431  return -1;
432  }
433 
434  token = HECMW_partlex_next_token();
435  if (token != ',' && token != HECMW_PARTLEX_NL && token != EOF) {
436  HECMW_log(HECMW_LOG_ERROR, "%s %s (%s)",
438  "in control file for partitioner", HECMW_partlex_get_text());
439  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
440  "part_cont_partition", HECMW_partlex_get_text());
441  return -1;
442  } else {
443  if (token == HECMW_PARTLEX_NL || token == EOF) break;
444  }
445  }
446 
447  /* check data */
448  if (cont_data->type < 0) {
450  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s", __FILE__, __LINE__,
451  "part_cont_partition");
452  return -1;
453  }
454 
455 #ifndef HECMW_PART_WITH_METIS
456  if (cont_data->method == HECMW_PART_METHOD_PMETIS) {
458  HECMW_log(HECMW_LOG_DEBUG, "%s:%d", __FILE__, __LINE__);
459  return -1;
460  }
461 
462  if (cont_data->method == HECMW_PART_METHOD_KMETIS) {
464  HECMW_log(HECMW_LOG_DEBUG, "%s:%d", __FILE__, __LINE__);
465  return -1;
466  }
467 #endif
468 
471 
472  if (cont_data->method < 0) {
474  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s", __FILE__, __LINE__,
475  "part_cont_partition");
476  return -1;
477  }
479  cont_data->method == HECMW_PART_METHOD_KMETIS ||
481 
482  if (cont_data->n_domain <= 0) {
484  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s", __FILE__, __LINE__,
485  "part_cont_partition");
486  return -1;
487  }
488 
489  if (cont_data->depth < 0) {
490  cont_data->depth = 1;
491  }
492 
493  if (cont_data->is_print_ucd < 0) {
494  cont_data->is_print_ucd = 0;
495  }
496 
497  /* partitioning directions ( option for RCB ) */
498  if (cont_data->method == HECMW_PART_METHOD_RCB) {
499  if (token == EOF) {
501  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s", __FILE__, __LINE__,
502  "part_cont_partition");
503  return -1;
504  }
505  part_cont_rcb_opt(cont_data);
506  }
507 
508  if (token == EOF) {
509  HECMW_log(HECMW_LOG_ERROR, "%s (%s)",
511  "control file for partitioner");
512  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s", __FILE__, __LINE__,
513  "part_cont_partition");
514  return -1;
515  } else {
516  return 0;
517  }
518 }
519 
520 /*----------------------------------------------------------------------------*/
521 /* get control data */
522 /*----------------------------------------------------------------------------*/
523 static int part_get_control(struct hecmw_part_cont_data *cont_data) {
524  int token, stat;
525  FILE *fp;
526 
527  if (args_subdomain){
529  cont_data->method = HECMW_PART_METHOD_KMETIS; /*HECMW_PART_METHOD_RCB; HECMW_PART_METHOD_PMETIS;*/
530  cont_data->n_domain = args_subdomain;
531  cont_data->depth = 1;
532  cont_data->is_print_ucd = 0;
534  return 0;
535  }
536 
537  /* open file */
538  if (strlen(ctrl_file_name) == 0) {
539  HECMW_log(HECMW_LOG_ERROR, "%s (%s)",
541  "control file name for partitioner is not set");
542  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s", __FILE__, __LINE__,
543  "part_get_control");
544  return -1;
545  }
546  if ((fp = fopen(ctrl_file_name, "r")) == NULL) {
547  HECMW_log(HECMW_LOG_ERROR, "%s (%s)", HECMW_strmsg(errno),
548  "control file for partitioner");
549  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s", __FILE__, __LINE__,
550  "part_get_control");
551  return -1;
552  }
553 
554  /* initialize lex */
555  stat = HECMW_partlex_set_input(fp);
556  if (stat) {
557  return -1;
558  }
559 
560  /* get control data */
561  while ((token = HECMW_partlex_next_token())) {
562  switch (token) {
563  case HECMW_PARTLEX_H_PARTITION: /* !PARTITION */
564  token = HECMW_partlex_next_token();
565  switch (token) {
566  case ',': /* normal */
567  if (part_cont_partition(cont_data)) return -1;
568  break;
569 
570  case HECMW_PARTLEX_NL: /* no option */
576  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s", __FILE__, __LINE__,
577  "part_cont_partition");
578  return -1;
579 
580  default: /* invalid delimiter */
581  HECMW_log(HECMW_LOG_ERROR, "%s (%s)",
584  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
585  "part_cont_partition", HECMW_partlex_get_text());
586  return -1;
587  }
588  break;
589 
590  case HECMW_PARTLEX_NL: /* new line */
591  break;
592 
593  case 'x':
594  case 'y':
595  case 'z':
596  switch (cont_data->method) {
598  if (cont_data->n_domain > 1) {
601  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
602  "part_cont_partition", HECMW_partlex_get_text());
603  return -1;
604  } else {
605  break;
606  }
607 
612  break;
613 
614  default:
617  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
618  "part_cont_partition", HECMW_partlex_get_text());
619  return -1;
620  }
621  while ((token = HECMW_partlex_next_token()) &&
622  token != HECMW_PARTLEX_NL) {
623  }
624  goto finalize;
625 
626  default:
628  HECMW_log(HECMW_LOG_DEBUG, "%s:%d:%s (%s)", __FILE__, __LINE__,
629  "part_cont_partition", HECMW_partlex_get_text());
630  return -1;
631  }
632  }
633 
634 /* close file */
635 finalize:
636  if (fclose(fp)) {
638  "control file for partitioner");
639  return -1;
640  }
641 
642  return 0;
643 }
644 
645 /*============================================================================*/
646 
649 
650  /* allocate structure for control data */
652  sizeof(struct hecmw_part_cont_data));
653  if (cont_data == NULL) {
655  return NULL;
656  }
657  cont_data->rcb_axis = NULL;
658 
659  /* get control data via file */
660  if (part_get_control(cont_data)) {
662  return NULL;
663  }
664 
665  return cont_data;
666 }
667 
668 /*================================================================================================*/
669 
671  if (cont_data->rcb_axis) {
672  HECMW_free(cont_data->rcb_axis);
673  }
675 }
#define HECMW_FILENAME_LEN
Definition: hecmw_config.h:72
int HECMW_set_error(int errorno, const char *fmt,...)
Definition: hecmw_error.c:37
#define NULL
int HECMW_log(int loglv, const char *fmt,...)
Definition: hecmw_log.c:260
#define HECMW_LOG_ERROR
Definition: hecmw_log.h:15
#define HECMW_LOG_WARN
Definition: hecmw_log.h:17
#define HECMW_LOG_DEBUG
Definition: hecmw_log.h:21
#define HECMW_free(ptr)
Definition: hecmw_malloc.h:24
#define HECMW_malloc(size)
Definition: hecmw_malloc.h:20
char * HECMW_strmsg(int msgno)
Definition: hecmw_msg.c:31
#define HECMW_PART_E_CTRL_DEPTH_NOEQ
#define HECMW_PART_E_FILE_CLOSE
#define HECMW_PART_E_CTRL_UCD_INVAL
#define HECMW_PART_METHOD_PMETIS
#define HECMW_PART_E_CTRL_UCD_NOEQ
#define HECMW_PART_E_CTRL_DOMAIN_POW
#define HECMW_PART_W_CTRL_RCB_MANY_DIR
#define HECMW_PART_RCB_Z_AXIS
#define HECMW_PART_RCB_Y_AXIS
#define HECMW_PART_E_CTRL_NODEF_KMETIS
#define HECMW_PART_E_CTRL_TYPE_INVAL
#define HECMW_PART_RCB_X_AXIS
#define HECMW_PART_E_TOO_LONG_FNAME
#define HECMW_PART_E_CTRL_RCB_FEW_DIR
#define HECMW_PART_E_CTRL_NO_METHOD
#define HECMW_PART_METHOD_RCB
#define HECMW_PART_E_CTRL_METHOD_NOEQ
#define HECMW_PART_E_CTRL_METHOD_INVAL
#define HECMW_PART_CONTACT_DEFAULT
#define HECMW_PART_E_INV_ARG
#define HECMW_PART_E_CTRL_NO_TYPE
#define HECMW_PART_E_CTRL_TYPE_NOEQ
#define HECMW_PART_E_CTRL_DOMAIN_NOEQ
#define HECMW_PART_TYPE_NODE_BASED
#define HECMW_PART_E_CTRL_RCB_NODIR
#define HECMW_PART_E_CTRL_RCB_INVAL
#define HECMW_PART_METHOD_KMETIS
#define HECMW_PART_E_CTRL_DOMAIN_INVAL
#define HECMW_PART_E_CTRL_DEPTH_INVAL
#define HECMW_PART_E_INVALID_TOKEN
#define HECMW_PART_E_CTRL_NODEF_PMETIS
#define HECMW_PART_E_CTRL_CONTACT_INVAL
#define HECMW_PART_CONTACT_DISTRIBUTE
#define HECMW_PART_CONTACT_SIMPLE
#define HECMW_PART_E_INVALID_EOF
#define HECMW_PART_CONTACT_AGGREGATE
#define HECMW_PART_E_CTRL_UCD_TOO_LONG
#define HECMW_PART_E_CTRL_NO_DOMAIN
#define HECMW_PART_E_NULL_POINTER
#define HECMW_PART_W_CTRL_DIR_WORCB
#define HECMW_PART_TYPE_ELEMENT_BASED
void HECMW_part_free_control(struct hecmw_part_cont_data *cont_data)
int HECMW_part_set_ctrl_file_name(char *fname)
struct hecmw_part_cont_data * HECMW_part_get_control(void)
int HECMW_part_set_subdomains(int n_domain)
#define HECMW_PARTLEX_V_DEFAULT
Definition: hecmw_partlex.h:47
#define HECMW_PARTLEX_V_DISTRIBUTE
Definition: hecmw_partlex.h:51
#define HECMW_PARTLEX_FILENAME
Definition: hecmw_partlex.h:19
#define HECMW_PARTLEX_K_TYPE
Definition: hecmw_partlex.h:23
#define HECMW_PARTLEX_K_DOMAIN
Definition: hecmw_partlex.h:27
#define HECMW_PARTLEX_K_METHOD
Definition: hecmw_partlex.h:25
#define HECMW_PARTLEX_V_RCB
Definition: hecmw_partlex.h:39
#define HECMW_PARTLEX_K_UCD
Definition: hecmw_partlex.h:31
#define HECMW_PARTLEX_V_PMETIS
Definition: hecmw_partlex.h:43
#define HECMW_PARTLEX_INT
Definition: hecmw_partlex.h:13
char * HECMW_partlex_get_text(void)
#define HECMW_PARTLEX_V_SIMPLE
Definition: hecmw_partlex.h:53
#define HECMW_PARTLEX_NL
Definition: hecmw_partlex.h:11
int HECMW_partlex_set_input(FILE *fp)
#define HECMW_PARTLEX_V_AGGREGATE
Definition: hecmw_partlex.h:49
double HECMW_partlex_get_number(void)
#define HECMW_PARTLEX_V_NODE_BASED
Definition: hecmw_partlex.h:35
#define HECMW_PARTLEX_NAME
Definition: hecmw_partlex.h:17
#define HECMW_PARTLEX_K_CONTACT
Definition: hecmw_partlex.h:33
#define HECMW_PARTLEX_K_DEPTH
Definition: hecmw_partlex.h:29
#define HECMW_PARTLEX_H_PARTITION
Definition: hecmw_partlex.h:21
#define HECMW_PARTLEX_V_KMETIS
Definition: hecmw_partlex.h:41
int HECMW_partlex_next_token(void)
#define HECMW_PARTLEX_V_ELEMENT_BASED
Definition: hecmw_partlex.h:37
#define HECMW_assert(cond)
Definition: hecmw_util.h:40