FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
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"
18
19static char ctrl_file_name[HECMW_FILENAME_LEN] = "\0";
20static int args_subdomain = 0;
21
22/*================================================================================================*/
23
24extern int HECMW_part_set_subdomains(int n_domain) {
25 args_subdomain = n_domain;
26 return 0;
27}
28
29extern 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
44error:
45 return -1;
46}
47
48/*============================================================================*/
49/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
50/* partitioning type < TYPE={ NODE-BASED | ELEMENT-BASED } > */
51/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
52static int part_cont_type(void) {
53 int token;
54
55 /* '=' */
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 } */
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/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
84static int part_cont_method(void) {
85 int token;
86
87 /* '=' */
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 } */
98 switch (token) {
99 case HECMW_PARTLEX_V_RCB: /* 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/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
119static 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/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
156static 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/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
192static 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/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
239static 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/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
277static 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/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
297static 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/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
381static 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 }
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/*----------------------------------------------------------------------------*/
523static 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 */
635finalize:
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
struct hecmw_part_cont_data * HECMW_part_get_control(void)
void HECMW_part_free_control(struct hecmw_part_cont_data *cont_data)
int HECMW_part_set_ctrl_file_name(char *fname)
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
#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
char * HECMW_partlex_get_text(void)
#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