Debian Codegraph @

packages/seacas/applications/nem_slice/elb_elem.C

raw
1 /*
2 * Copyright(C) 1999-2020, 2023, 2024 National Technology & Engineering Solutions
3 * of Sandia, LLC (NTESS). Under the terms of Contract DE-NA0003525 with
4 * NTESS, the U.S. Government retains certain rights in this software.
5 *
6 * See packages/seacas/LICENSE for details
7 */
8
9 #include "elb_elem.h"
10 #include "elb_err.h" // for error_report, Gen_Error
11 #include "elb_util.h" // for in_list
12 #include "vector_data.h"
13 #include <cstddef> // for size_t
14 #include <cstdlib> // for exit
15 #include <cstring> // for strncasecmp
16 #include <fmt/ostream.h>
17 #include <vector> // for vector
18
19 /*****************************************************************************/
20 /*****************************************************************************/
21 namespace {
22 template <typename INT>
23 inline int numbermatch(INT *sidenodes, size_t i, size_t j, size_t k, size_t value)
24 {
25 if ((size_t)sidenodes[(i + j) % k] == value) {
26 return 1;
27 }
28 return 0;
29 }
30 } // namespace
31
32 /*****************************************************************************/
33 /* Function get_elem_type() begins:
34 *----------------------------------------------------------------------------
35 * This function returns the type of element based on the ExodusII element
36 * string and number of nodes.
37 *
38 * Need the number of dimensions in order to distinguish between
39 * TRI elements in a 2d mesh from TRI elements in a 3d mesh.
40 *****************************************************************************/
41 const char *elem_name_from_enum(const ElementType elem_type)
42 {
43 static const char *elem_names[(int)ElementType::NULL_EL] = {
44 "SPHERE", "BAR2", "BAR3", "QUAD4", "QUAD8", "QUAD9", "SHELL4",
45 "SHELL8", "SHELL9", "TRI3", "TRI4", "TRI6", "TRI7", "TSHELL3",
46 "TSHELL4", "TSHELL6", "TSHELL7", "HEX8", "HEX16", "HEX20", "HEX27",
47 "HEXSHELL", "TET4", "TET10", "TET8", "TET14", "TET15", "WEDGE6",
48 "WEDGE12", "WEDGE15", "WEDGE16", "WEDGE20", "WEDGE21", "PYRAMID5", "PYRAMID13",
49 "PYRAMID14", "PYRAMID18", "PYRAMID19", "SHELL2", "SHELL3", "BAR1D2", "BAR1D3"};
50 return elem_names[(int)elem_type];
51 }
52
53 ElementType get_elem_type(const char *elem_name, const int num_nodes, const int num_dim)
54 {
55
56 ElementType answer = ElementType::NULL_EL;
57 switch (elem_name[0]) {
58 case 'h':
59 case 'H':
60 if (strncasecmp(elem_name, "HEX", 3) == 0) {
61 switch (num_nodes) {
62 case 8: answer = ElementType::HEX8; break;
63 case 12: answer = ElementType::HEXSHELL; break;
64 case 16: answer = ElementType::HEX16; break;
65 case 20: answer = ElementType::HEX20; break;
66 case 27: answer = ElementType::HEX27; break;
67 default:
68 Gen_Error(0, "fatal: unsupported HEX element");
69 error_report();
70 exit(1);
71 }
72 }
73 break;
74
75 case 'c':
76 case 'C':
77 if (strncasecmp(elem_name, "CIRCLE", 6) == 0) {
78 answer = ElementType::SPHERE;
79 }
80 break;
81
82 case 's':
83 case 'S':
84 if (strncasecmp(elem_name, "SPHERE", 6) == 0) {
85 answer = ElementType::SPHERE;
86 }
87 else if (strncasecmp(elem_name, "SHELL", 5) == 0) {
88 switch (num_nodes) {
89 case 2:
90 if (num_dim == 2) {
91 answer = ElementType::SHELL2;
92 }
93 else {
94 Gen_Error(0, "fatal: unsupported SHELL element");
95 error_report();
96 exit(1);
97 }
98 break;
99 case 3:
100 if (num_dim == 2) {
101 answer = ElementType::SHELL3;
102 }
103 else {
104 Gen_Error(0, "fatal: unsupported SHELL element");
105 error_report();
106 exit(1);
107 }
108 break;
109 case 4: answer = ElementType::SHELL4; break;
110 case 8: answer = ElementType::SHELL8; break;
111 case 9: answer = ElementType::SHELL9; break;
112 default:
113 Gen_Error(0, "fatal: unsupported SHELL element");
114 error_report();
115 exit(1);
116 }
117 }
118 break;
119
120 case 'b':
121 case 'B':
122 case 't':
123 case 'T':
124 case 'r':
125 case 'R':
126 if (strncasecmp(elem_name, "BEAM", 4) == 0 || strncasecmp(elem_name, "TRUSS", 5) == 0 ||
127 strncasecmp(elem_name, "ROD", 3) == 0 || strncasecmp(elem_name, "BAR", 3) == 0) {
128 switch (num_nodes) {
129 case 2: answer = num_dim == 1 ? ElementType::BAR1D2 : ElementType::BAR2; break;
130 case 3: answer = num_dim == 1 ? ElementType::BAR1D3 : ElementType::BAR3; break;
131 default:
132 Gen_Error(0, "fatal: unsupported BAR/BEAM/TRUSS element");
133 error_report();
134 exit(1);
135 }
136 }
137 else if (strncasecmp(elem_name, "TRI", 3) == 0) {
138 switch (num_nodes) {
139 case 3:
140 if (num_dim == 2) {
141 answer = ElementType::TRI3;
142 }
143 else {
144 answer = ElementType::TSHELL3;
145 }
146 break;
147 case 4:
148 if (num_dim == 2) {
149 answer = ElementType::TRI4;
150 }
151 else {
152 answer = ElementType::TSHELL4;
153 }
154 break;
155 case 6:
156 if (num_dim == 2) {
157 answer = ElementType::TRI6;
158 }
159 else {
160 answer = ElementType::TSHELL6;
161 }
162 break;
163 case 7:
164 if (num_dim == 2) {
165 answer = ElementType::TRI7;
166 }
167 else {
168 answer = ElementType::TSHELL7;
169 }
170 break;
171 default:
172 Gen_Error(0, "fatal: unsupported TRI element");
173 error_report();
174 exit(1);
175 }
176 }
177 else if (strncasecmp(elem_name, "TET", 3) == 0) {
178 switch (num_nodes) {
179 case 4: answer = ElementType::TET4; break;
180 case 8: answer = ElementType::TET8; break;
181 case 10: answer = ElementType::TET10; break;
182 case 14: answer = ElementType::TET14; break;
183 case 15: answer = ElementType::TET15; break;
184 default:
185 Gen_Error(0, "fatal: unsupported TET element");
186 error_report();
187 exit(1);
188 }
189 }
190 break;
191
192 case 'q':
193 case 'Q':
194 if (strncasecmp(elem_name, "QUAD", 4) == 0) {
195 switch (num_nodes) {
196 case 4:
197 if (num_dim == 2) {
198 answer = ElementType::QUAD4;
199 }
200 else {
201 answer = ElementType::SHELL4;
202 }
203 break;
204 case 8:
205 if (num_dim == 2) {
206 answer = ElementType::QUAD8;
207 }
208 else {
209 answer = ElementType::SHELL8;
210 }
211 break;
212 case 9:
213 if (num_dim == 2) {
214 answer = ElementType::QUAD9;
215 }
216 else {
217 answer = ElementType::SHELL9;
218 }
219 break;
220 default:
221 Gen_Error(0, "fatal: unsupported QUAD element");
222 error_report();
223 exit(1);
224 }
225 }
226 break;
227
228 case 'w':
229 case 'W':
230 if (strncasecmp(elem_name, "WEDGE", 5) == 0) {
231 switch (num_nodes) {
232 case 6: answer = ElementType::WEDGE6; break;
233 case 12: answer = ElementType::WEDGE12; break;
234 case 15: answer = ElementType::WEDGE15; break;
235 case 16: answer = ElementType::WEDGE16; break;
236 case 20: answer = ElementType::WEDGE20; break;
237 case 21: answer = ElementType::WEDGE21; break;
238 default:
239 Gen_Error(0, "fatal: unsupported WEDGE element");
240 error_report();
241 exit(1);
242 }
243 }
244 break;
245
246 case 'p':
247 case 'P':
248 if (strncasecmp(elem_name, "PYR", 3) == 0) {
249 switch (num_nodes) {
250 case 5: answer = ElementType::PYRAMID5; break;
251 case 13: answer = ElementType::PYRAMID13; break;
252 case 14: answer = ElementType::PYRAMID14; break;
253 case 18: answer = ElementType::PYRAMID18; break;
254 case 19: answer = ElementType::PYRAMID19; break;
255 default:
256 Gen_Error(0, "fatal: unsupported PYRAMID element");
257 error_report();
258 exit(1);
259 }
260 }
261 break;
262
263 default: break;
264 }
265
266 if (answer == ElementType::NULL_EL) {
267 std::string errstr;
268 errstr = fmt::format("fatal: unknown element type '{}' read", elem_name);
269 Gen_Error(0, errstr);
270 error_report();
271 exit(1);
272 }
273
274 return answer;
275
276 } /*---------------------------End get_elem_type()---------------------------*/
277
278 /*****************************************************************************/
279 /*****************************************************************************/
280 /*****************************************************************************/
281 /* Convenience functions for code readability
282 *****************************************************************************/
283 bool is_hex(ElementType etype)
284 {
285 return etype == ElementType::HEX8 || etype == ElementType::HEX27 || etype == ElementType::HEX20 ||
286 etype == ElementType::HEXSHELL;
287 }
288
289 bool is_tet(ElementType etype)
290 {
291 return etype == ElementType::TET4 || etype == ElementType::TET10 || etype == ElementType::TET8 ||
292 etype == ElementType::TET14 || etype == ElementType::TET15;
293 }
294
295 bool is_wedge(ElementType etype)
296 {
297 return etype == ElementType::WEDGE6 || etype == ElementType::WEDGE15 ||
298 etype == ElementType::WEDGE16 || etype == ElementType::WEDGE20 ||
299 etype == ElementType::WEDGE21;
300 }
301
302 bool is_pyramid(ElementType etype)
303 {
304 return etype == ElementType::PYRAMID5 || etype == ElementType::PYRAMID13 ||
305 etype == ElementType::PYRAMID14 || etype == ElementType::PYRAMID18 ||
306 etype == ElementType::PYRAMID19;
307 }
308
309 bool is_3d_element(ElementType etype)
310 {
311 return is_hex(etype) || is_tet(etype) || is_wedge(etype) || is_pyramid(etype);
312 }
313
314 /*****************************************************************************/
315 /*****************************************************************************/
316 /*****************************************************************************/
317 /* Function get_elem_info() begins:
318 *----------------------------------------------------------------------------
319 * This function returns various information about the input element type.
320 *****************************************************************************/
321 int get_elem_info(const ElementInfo req, const ElementType etype)
322 {
323
324 int answer = 0;
325
326 switch (etype) /* Switch over the element type */
327 {
328 case ElementType::BAR1D2:
329 switch (req) {
330 case ElementInfo::NNODES: answer = 2; break;
331 case ElementInfo::NSIDE_NODES: answer = 1; break;
332 case ElementInfo::NSIDES: answer = 2; break;
333 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 1; break;
334 default:
335 Gen_Error(0, "fatal: unknown quantity");
336 error_report();
337 exit(1);
338 }
339 break;
340
341 case ElementType::BAR2:
342 switch (req) {
343 case ElementInfo::NNODES: answer = 2; break;
344 case ElementInfo::NSIDE_NODES: answer = 2; break;
345 case ElementInfo::NSIDES: answer = 1; break;
346 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 1; break;
347 default:
348 Gen_Error(0, "fatal: unknown quantity");
349 error_report();
350 exit(1);
351 }
352 break;
353
354 case ElementType::SHELL2:
355 switch (req) {
356 case ElementInfo::NNODES: answer = 2; break;
357 case ElementInfo::NSIDE_NODES: answer = 2; break;
358 case ElementInfo::NSIDES: answer = 1; break;
359 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 1; break;
360 default:
361 Gen_Error(0, "fatal: unknown quantity");
362 error_report();
363 exit(1);
364 }
365 break;
366
367 case ElementType::SHELL3:
368 switch (req) {
369 case ElementInfo::NNODES: answer = 3; break;
370 case ElementInfo::NSIDE_NODES: answer = 2; break;
371 case ElementInfo::NSIDES: answer = 1; break;
372 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 1; break;
373 default:
374 Gen_Error(0, "fatal: unknown quantity");
375 error_report();
376 exit(1);
377 }
378 break;
379
380 case ElementType::BAR1D3:
381 switch (req) {
382 case ElementInfo::NNODES: answer = 3; break;
383 case ElementInfo::NSIDE_NODES: answer = 1; break;
384 case ElementInfo::NSIDES: answer = 2; break;
385 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 1; break;
386 default:
387 Gen_Error(0, "fatal: unknown quantity");
388 error_report();
389 exit(1);
390 }
391 break;
392
393 case ElementType::BAR3:
394 switch (req) {
395 case ElementInfo::NNODES: answer = 3; break;
396 case ElementInfo::NSIDE_NODES: answer = 2; break;
397 case ElementInfo::NSIDES: answer = 1; break;
398 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 1; break;
399 default:
400 Gen_Error(0, "fatal: unknown quantity");
401 error_report();
402 exit(1);
403 }
404 break;
405
406 case ElementType::SPHERE:
407 switch (req) {
408 case ElementInfo::NNODES: answer = 1; break;
409 case ElementInfo::NSIDE_NODES: answer = 0; break;
410 case ElementInfo::NSIDES: answer = 0; break;
411 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
412 }
413 break;
414
415 case ElementType::QUAD4: /* First order quad */
416 switch (req) /* select type of information required*/
417 {
418 case ElementInfo::NNODES: /* number of nodes */ answer = 4; break;
419 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
420 case ElementInfo::NSIDE_NODES: answer = 2; break;
421 case ElementInfo::NSIDES: answer = 4; break;
422 default:
423 Gen_Error(0, "fatal:unknown quantity");
424 error_report();
425 exit(1);
426 }
427 break;
428
429 case ElementType::QUAD8: /* 2nd order serendipity quad */
430 switch (req) /* select type of information required */
431 {
432 case ElementInfo::NNODES: /* number of nodes */ answer = 8; break;
433 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
434 case ElementInfo::NSIDE_NODES: answer = 3; break;
435 case ElementInfo::NSIDES: answer = 4; break;
436 default:
437 Gen_Error(0, "fatal: unknown quantity");
438 error_report();
439 exit(1);
440 }
441 break;
442
443 case ElementType::QUAD9: /* biquadratic quadrilateral */
444 switch (req) /* select type of information required */
445 {
446 case ElementInfo::NNODES: /* number of nodes */ answer = 9; break;
447 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
448 case ElementInfo::NSIDE_NODES: answer = 3; break;
449 case ElementInfo::NSIDES: answer = 4; break;
450 default:
451 Gen_Error(0, "fatal: unknown quantity");
452 error_report();
453 exit(1);
454 }
455 break;
456
457 /* NOTE: cannot determine NSIDE_NODES for SHELL element */
458 case ElementType::SHELL4:
459 switch (req) {
460 case ElementInfo::NNODES: answer = 4; break;
461 case ElementInfo::NSIDES: answer = 6; break;
462 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
463 default:
464 Gen_Error(0, "fatal: unknown quantity");
465 error_report();
466 exit(1);
467 }
468 break;
469
470 case ElementType::SHELL8:
471 switch (req) {
472 case ElementInfo::NNODES: answer = 8; break;
473 case ElementInfo::NSIDES: answer = 6; break;
474 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
475 default:
476 Gen_Error(0, "fatal: unknown quantity");
477 error_report();
478 exit(1);
479 }
480 break;
481
482 case ElementType::SHELL9:
483 switch (req) {
484 case ElementInfo::NNODES: answer = 9; break;
485 case ElementInfo::NSIDES: answer = 6; break;
486 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
487 default:
488 Gen_Error(0, "fatal: unknown quantity");
489 error_report();
490 exit(1);
491 }
492 break;
493
494 case ElementType::TRI3:
495 switch (req) /* select type of information required */
496 {
497 case ElementInfo::NNODES: /* number of nodes */ answer = 3; break;
498 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
499 case ElementInfo::NSIDE_NODES: answer = 2; break;
500 case ElementInfo::NSIDES: answer = 3; break;
501 default:
502 Gen_Error(0, "fatal: unknown quantity");
503 error_report();
504 exit(1);
505 }
506 break;
507
508 case ElementType::TRI4:
509 switch (req) /* select type of information required */
510 {
511 case ElementInfo::NNODES: /* number of nodes */ answer = 4; break;
512 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
513 case ElementInfo::NSIDE_NODES: answer = 2; break;
514 case ElementInfo::NSIDES: answer = 3; break;
515 default:
516 Gen_Error(0, "fatal: unknown quantity");
517 error_report();
518 exit(1);
519 }
520 break;
521
522 case ElementType::TRI6:
523 switch (req) /* select type of information required */
524 {
525 case ElementInfo::NNODES: /* number of nodes */ answer = 6; break;
526 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
527 case ElementInfo::NSIDE_NODES: answer = 3; break;
528 case ElementInfo::NSIDES: answer = 3; break;
529 default:
530 Gen_Error(0, "fatal: unknown quantity");
531 error_report();
532 exit(1);
533 }
534 break;
535
536 case ElementType::TRI7:
537 switch (req) /* select type of information required */
538 {
539 case ElementInfo::NNODES: /* number of nodes */ answer = 7; break;
540 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
541 case ElementInfo::NSIDE_NODES: answer = 3; break;
542 case ElementInfo::NSIDES: answer = 3; break;
543 default:
544 Gen_Error(0, "fatal: unknown quantity");
545 error_report();
546 exit(1);
547 }
548 break;
549
550 /* NOTE: cannot determine NSIDE_NODES for TSHELL element */
551 case ElementType::TSHELL3:
552 switch (req) /* select type of information required */
553 {
554 case ElementInfo::NNODES: /* number of nodes */ answer = 3; break;
555 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
556 case ElementInfo::NSIDES: answer = 5; break;
557 default:
558 Gen_Error(0, "fatal: unknown quantity");
559 error_report();
560 exit(1);
561 }
562 break;
563
564 case ElementType::TSHELL4:
565 switch (req) /* select type of information required */
566 {
567 case ElementInfo::NNODES: /* number of nodes */ answer = 4; break;
568 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
569 case ElementInfo::NSIDES: answer = 5; break;
570 default:
571 Gen_Error(0, "fatal: unknown quantity");
572 error_report();
573 exit(1);
574 }
575 break;
576
577 case ElementType::TSHELL6:
578 switch (req) /* select type of information required */
579 {
580 case ElementInfo::NNODES: /* number of nodes */ answer = 6; break;
581 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
582 case ElementInfo::NSIDES: answer = 5; break;
583 default:
584 Gen_Error(0, "fatal: unknown quantity");
585 error_report();
586 exit(1);
587 }
588 break;
589
590 case ElementType::TSHELL7:
591 switch (req) /* select type of information required */
592 {
593 case ElementInfo::NNODES: /* number of nodes */ answer = 7; break;
594 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 2; break;
595 case ElementInfo::NSIDES: answer = 5; break;
596 default:
597 Gen_Error(0, "fatal: unknown quantity");
598 error_report();
599 exit(1);
600 }
601 break;
602
603 case ElementType::HEX8: /* trilinear hexahedron */
604 switch (req) /* select type of information required */
605 {
606 case ElementInfo::NNODES: /* number of nodes */ answer = 8; break;
607 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
608 case ElementInfo::NSIDE_NODES: answer = 4; break;
609 case ElementInfo::NSIDES: answer = 6; break;
610 default:
611 Gen_Error(0, "fatal: unknown quantity");
612 error_report();
613 exit(1);
614 }
615 break;
616
617 case ElementType::HEX16: /* localization element NSNODES is not consistent... */
618 switch (req) {
619 case ElementInfo::NNODES: /* number of nodes */ answer = 16; break;
620 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
621 case ElementInfo::NSIDES: answer = 6; break;
622 default:
623 Gen_Error(0, "fatal: unknown quantity");
624 error_report();
625 exit(1);
626 }
627 break;
628
629 case ElementType::HEX20: /* serendipity triquadratic hexahedron */
630 switch (req) /* select type of information required */
631 {
632 case ElementInfo::NNODES: /* number of nodes */ answer = 20; break;
633 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
634 case ElementInfo::NSIDE_NODES: answer = 8; break;
635 case ElementInfo::NSIDES: answer = 6; break;
636 default:
637 Gen_Error(0, "fatal: unknown quantity");
638 error_report();
639 exit(1);
640 }
641 break;
642
643 case ElementType::HEX27: /* triquadratic hexahedron */
644 switch (req) /* select type of information required*/
645 {
646 case ElementInfo::NNODES: /* number of nodes */ answer = 27; break;
647 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
648 case ElementInfo::NSIDE_NODES: answer = 9; break;
649 case ElementInfo::NSIDES: answer = 6; break;
650 default:
651 Gen_Error(0, "fatal: unknown quantity");
652 error_report();
653 exit(1);
654 }
655 break;
656
657 /* NOTE: cannot determine NSIDE_NODES for HEXSHELL element */
658 case ElementType::HEXSHELL:
659 switch (req) {
660 case ElementInfo::NNODES: answer = 12; break;
661 case ElementInfo::NSIDES: answer = 6; break;
662 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
663 default:
664 Gen_Error(0, "fatal: unknown quantity");
665 error_report();
666 exit(1);
667 }
668 break;
669
670 case ElementType::TET4: /* trilinear tetrahedron */
671 switch (req) /* select type of information required*/
672 {
673 case ElementInfo::NNODES: /* number of nodes */ answer = 4; break;
674 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
675 case ElementInfo::NSIDE_NODES: answer = 3; break;
676 case ElementInfo::NSIDES: answer = 4; break;
677 default:
678 Gen_Error(0, "fatal: unknown quantity");
679 error_report();
680 exit(1);
681 }
682 break;
683
684 case ElementType::TET10: /* triquadradic tetrahedron */
685 switch (req) /* select type of information required */
686 {
687 case ElementInfo::NNODES: /* number of nodes */ answer = 10; break;
688 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
689 case ElementInfo::NSIDE_NODES: answer = 6; break;
690 case ElementInfo::NSIDES: answer = 4; break;
691 default:
692 Gen_Error(0, "fatal: unknown quantity");
693 error_report();
694 exit(1);
695 }
696 break;
697
698 case ElementType::TET14:
699 switch (req) /* select type of information required */
700 {
701 case ElementInfo::NNODES: /* number of nodes */ answer = 14; break;
702 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
703 case ElementInfo::NSIDE_NODES: answer = 7; break;
704 case ElementInfo::NSIDES: answer = 4; break;
705 default:
706 Gen_Error(0, "fatal: unknown quantity");
707 error_report();
708 exit(1);
709 }
710 break;
711
712 case ElementType::TET15:
713 switch (req) /* select type of information required */
714 {
715 case ElementInfo::NNODES: /* number of nodes */ answer = 15; break;
716 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
717 case ElementInfo::NSIDE_NODES: answer = 7; break;
718 case ElementInfo::NSIDES: answer = 4; break;
719 default:
720 Gen_Error(0, "fatal: unknown quantity");
721 error_report();
722 exit(1);
723 }
724 break;
725
726 case ElementType::TET8: /* 8-node (midface nodes) tetrahedron */
727 switch (req) /* select type of information required */
728 {
729 case ElementInfo::NNODES: /* number of nodes */ answer = 8; break;
730 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
731 case ElementInfo::NSIDE_NODES: answer = 4; break;
732 case ElementInfo::NSIDES: answer = 4; break;
733 default:
734 Gen_Error(0, "fatal: unknown quantity");
735 error_report();
736 exit(1);
737 }
738 break;
739
740 /* NOTE: cannot determine NSIDE_NODES for WEDGE elements */
741 case ElementType::WEDGE6:
742 switch (req) {
743 case ElementInfo::NNODES: answer = 6; break;
744 case ElementInfo::NSIDES: answer = 5; break;
745 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
746 default:
747 Gen_Error(0, "fatal: unknown quantity");
748 error_report();
749 exit(1);
750 }
751 break;
752
753 case ElementType::WEDGE12:
754 switch (req) {
755 case ElementInfo::NNODES: answer = 12; break;
756 case ElementInfo::NSIDES: answer = 5; break;
757 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
758 default:
759 Gen_Error(0, "fatal: unknown quantity");
760 error_report();
761 exit(1);
762 }
763 break;
764
765 case ElementType::WEDGE15:
766 switch (req) {
767 case ElementInfo::NNODES: answer = 15; break;
768 case ElementInfo::NSIDES: answer = 5; break;
769 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
770 default:
771 Gen_Error(0, "fatal: unknown quantity");
772 error_report();
773 exit(1);
774 }
775 break;
776
777 case ElementType::WEDGE16:
778 switch (req) {
779 case ElementInfo::NNODES: answer = 16; break;
780 case ElementInfo::NSIDES: answer = 5; break;
781 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
782 default:
783 Gen_Error(0, "fatal: unknown quantity");
784 error_report();
785 exit(1);
786 }
787 break;
788
789 case ElementType::WEDGE20:
790 switch (req) {
791 case ElementInfo::NNODES: answer = 20; break;
792 case ElementInfo::NSIDES: answer = 5; break;
793 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
794 default:
795 Gen_Error(0, "fatal: unknown quantity");
796 error_report();
797 exit(1);
798 }
799 break;
800
801 case ElementType::WEDGE21:
802 switch (req) {
803 case ElementInfo::NNODES: answer = 21; break;
804 case ElementInfo::NSIDES: answer = 5; break;
805 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
806 default:
807 Gen_Error(0, "fatal: unknown quantity");
808 error_report();
809 exit(1);
810 }
811 break;
812
813 /* NOTE: cannot determine NSIDE_NODES for PYRAMID element */
814 case ElementType::PYRAMID5:
815 switch (req) {
816 case ElementInfo::NNODES: answer = 5; break;
817 case ElementInfo::NSIDES: answer = 5; break;
818 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
819 default:
820 Gen_Error(0, "fatal: unknown quantity");
821 error_report();
822 exit(1);
823 }
824 break;
825
826 case ElementType::PYRAMID13:
827 switch (req) {
828 case ElementInfo::NNODES: answer = 13; break;
829 case ElementInfo::NSIDES: answer = 5; break;
830 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
831 default:
832 Gen_Error(0, "fatal: unknown quantity");
833 error_report();
834 exit(1);
835 }
836 break;
837
838 case ElementType::PYRAMID14:
839 switch (req) {
840 case ElementInfo::NNODES: answer = 14; break;
841 case ElementInfo::NSIDES: answer = 5; break;
842 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
843 default:
844 Gen_Error(0, "fatal: unknown quantity");
845 error_report();
846 exit(1);
847 }
848 break;
849
850 case ElementType::PYRAMID18:
851 switch (req) {
852 case ElementInfo::NNODES: answer = 18; break;
853 case ElementInfo::NSIDES: answer = 5; break;
854 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
855 default:
856 Gen_Error(0, "fatal: unknown quantity");
857 error_report();
858 exit(1);
859 }
860 break;
861
862 case ElementType::PYRAMID19:
863 switch (req) {
864 case ElementInfo::NNODES: answer = 19; break;
865 case ElementInfo::NSIDES: answer = 5; break;
866 case ElementInfo::NDIM: /* number of physical dimensions */ answer = 3; break;
867 default:
868 Gen_Error(0, "fatal: unknown quantity");
869 error_report();
870 exit(1);
871 }
872 break;
873
874 default:
875 Gen_Error(0, "fatal: unknown or unimplemented element type");
876 error_report();
877 exit(1);
878 }
879
880 return answer;
881
882 } /*---------------------------End get_elem_info()---------------------------*/
883
884 /*****************************************************************************/
885 /*****************************************************************************/
886 /*****************************************************************************/
887 /* Function get_side_id() begins:
888 *----------------------------------------------------------------------------
889 * This function returns the Side ID (as used in ExodusII) given a list of
890 * nodes on that side.
891 *
892 * Changed so that it is now order dependent, but independent of starting
893 * node for 3-D sides. On 2-D sides (lines), the starting node is important.
894 *
895 * Now supoports degenerate faces in HEX elements.
896 *****************************************************************************/
897 template int get_side_id(const ElementType etype, const int *connect, const int nsnodes,
898 int side_nodes[], const int skip_check, const int partial_adj);
899 template int get_side_id(const ElementType etype, const int64_t *connect, const int nsnodes,
900 int64_t side_nodes[], const int skip_check, const int partial_adj);
901
902 template <typename INT>
903 int get_side_id(const ElementType etype, const INT *connect, const int nsnodes, INT side_nodes[],
904 const int skip_check, const int partial_adj)
905 {
906 int count = 0;
907 /* min_match for hex elements means that min_match+1 nodes
908 on a face of a hex must match to return the side of the
909 hex on which the nodes exist, i.e., if 3/4 nodes of a hex
910 match, then it might be considered connected. If it is
911 connected, then min_match states if 3/4 nodes is considered a face of
912 a hex or not */
913
914 /* Default for min_match is 3, 2 is trial and error stuff */
915
916 const int min_match = 3;
917 /* const int min_match = 2; */
918
919 /* check if this is a degenerate face */
920 int dup = 0;
921 std::array<int, 9> location{};
922 for (int i = 0; i < (nsnodes - 1); i++) {
923 for (int j = (i + 1); j < nsnodes; j++) {
924 if (side_nodes[i] == side_nodes[j]) {
925 location[dup++] = i; /* location of duplicated node */
926 }
927 }
928 }
929
930 int nnodes = get_elem_info(ElementInfo::NNODES, etype);
931
932 /* Find all of the side nodes in the connect table */
933 int num = 0;
934 for (int i = 0; i < nnodes; i++) {
935 for (int j = 0; j < nsnodes; j++) {
936 if (connect[i] == side_nodes[j]) {
937 num++;
938 break;
939 }
940 }
941 if (num == nsnodes) {
942 break;
943 }
944 }
945
946 /* I commented out the conditional statement causing the
947 error if 2 hexes only share 3 out of 4 nodes. I replaced
948 this with what is seen below. It works, but only for
949 this particular case */
950
951 /* the following ifdef is used to determine face adjacency
952 old way: numnodes on face must match on both elements
953 new way: only 3/4 of hex nodes have to match to be face adjacent */
954
955 if (((partial_adj == 1) && (num < nsnodes - 1) && (num >= 2)) ||
956 ((partial_adj != 1) && (num != nsnodes))) {
957 if (skip_check) {
958 if (skip_check == 1) /* print only if skip_check is 1 (not > 1) */
959 Gen_Error(0, "warning: not all side nodes in connect table for element");
960 }
961 else {
962 Gen_Error(0, "fatal: not all side nodes in connect table for element");
963 return -1;
964 }
965 }
966
967 if ((partial_adj == 1) && (num != nsnodes)) {
968 return 0;
969 }
970
971 /* Find the side ID */
972 switch (etype) {
973 case ElementType::BAR1D2:
974 case ElementType::BAR1D3:
975 /* SIDE 1 */
976 if (side_nodes[0] == connect[0]) {
977 return 1;
978 }
979 if (side_nodes[0] == connect[1]) {
980 return 2;
981 }
982 break;
983
984 case ElementType::BAR2:
985 case ElementType::BAR3:
986 case ElementType::SHELL2:
987 case ElementType::SHELL3:
988 /* SIDE 1 */
989 if (side_nodes[0] == connect[0] && side_nodes[1] == connect[1]) {
990 return 1;
991 }
992 break;
993 case ElementType::QUAD4:
994 case ElementType::QUAD8:
995 case ElementType::QUAD9:
996 /* SIDE 1 */
997 if (side_nodes[0] == connect[0] && side_nodes[1] == connect[1]) {
998 return 1;
999 }
1000
1001 /* SIDE 2 */
1002 if (side_nodes[0] == connect[1] && side_nodes[1] == connect[2]) {
1003 return 2;
1004 }
1005
1006 /* SIDE 3 */
1007 if (side_nodes[0] == connect[2] && side_nodes[1] == connect[3]) {
1008 return 3;
1009 }
1010
1011 /* SIDE 4 */
1012 if (side_nodes[0] == connect[3] && side_nodes[1] == connect[0]) {
1013 return 4;
1014 }
1015
1016 break;
1017
1018 case ElementType::TRI3:
1019 case ElementType::TRI4:
1020 case ElementType::TRI6:
1021 case ElementType::TRI7:
1022 /* SIDE 1 */
1023 if (side_nodes[0] == connect[0] && side_nodes[1] == connect[1]) {
1024 return 1;
1025 }
1026
1027 /* SIDE 2 */
1028 if (side_nodes[0] == connect[1] && side_nodes[1] == connect[2]) {
1029 return 2;
1030 }
1031
1032 /* SIDE 3 */
1033 if (side_nodes[0] == connect[2] && side_nodes[1] == connect[0]) {
1034 return 3;
1035 }
1036
1037 break;
1038
1039 case ElementType::TET4:
1040 case ElementType::TET10:
1041 case ElementType::TET14:
1042 case ElementType::TET15:
1043 case ElementType::TET8:
1044 /* check the # of side nodes */
1045 if (nsnodes < 3) {
1046 return 0;
1047 }
1048
1049 /* SIDE 1, 3, or 4 */
1050 if ((num = in_list(connect[0], nsnodes, side_nodes)) >= 0) {
1051 if (side_nodes[(1 + num) % 3] == connect[1] && side_nodes[(2 + num) % 3] == connect[3]) {
1052 return 1;
1053 }
1054 if (side_nodes[(1 + num) % 3] == connect[3] && side_nodes[(2 + num) % 3] == connect[2]) {
1055 return 3;
1056 }
1057 if (side_nodes[(1 + num) % 3] == connect[2] && side_nodes[(2 + num) % 3] == connect[1]) {
1058 return 4;
1059 }
1060 }
1061
1062 /* SIDE 2 */
1063 if ((num = in_list(connect[1], nsnodes, side_nodes)) >= 0) {
1064 if (side_nodes[(1 + num) % 3] == connect[2] && side_nodes[(2 + num) % 3] == connect[3]) {
1065 return 2;
1066 }
1067 }
1068
1069 break;
1070
1071 case ElementType::HEX8:
1072 case ElementType::HEX16:
1073 case ElementType::HEX20:
1074 case ElementType::HEX27:
1075 case ElementType::HEXSHELL: /* this should be the same as a HEX element */
1076 /* check the # of side nodes */
1077 if (nsnodes < 4) {
1078 return 0;
1079 }
1080
1081 /* SIDE 1 */
1082 if ((num = in_list(connect[0], nsnodes, side_nodes)) >= 0) {
1083 count = 0;
1084 count += numbermatch(side_nodes, 1, num, 4, connect[1]);
1085 count += numbermatch(side_nodes, 2, num, 4, connect[5]);
1086 count += numbermatch(side_nodes, 3, num, 4, connect[4]);
1087 if (count >= min_match) {
1088 return 1;
1089 }
1090
1091 /* if this is the duplicated node, then find the next occurrence */
1092 if (dup) {
1093 for (int i = 0; i < dup; i++) {
1094 if (connect[0] == side_nodes[location[i]]) {
1095 num = in_list(connect[0], (nsnodes - num), &(side_nodes[num + 1])) + location[i] + 1;
1096 count = 0;
1097 count += numbermatch(side_nodes, 1, num, 4, connect[1]);
1098 count += numbermatch(side_nodes, 2, num, 4, connect[5]);
1099 count += numbermatch(side_nodes, 3, num, 4, connect[4]);
1100 if (count >= min_match) {
1101 return 1;
1102 }
1103 }
1104 }
1105 }
1106 }
1107
1108 /* SIDE 2 */
1109 if ((num = in_list(connect[1], nsnodes, side_nodes)) >= 0) {
1110 count = 0;
1111 count += numbermatch(side_nodes, 1, num, 4, connect[2]);
1112 count += numbermatch(side_nodes, 2, num, 4, connect[6]);
1113 count += numbermatch(side_nodes, 3, num, 4, connect[5]);
1114 if (count >= min_match) {
1115 return 2;
1116 }
1117
1118 /* if this is the duplicated node, then find the next occurrence */
1119 if (dup) {
1120 for (int i = 0; i < dup; i++) {
1121 if (connect[1] == side_nodes[location[i]]) {
1122 num = in_list(connect[1], (nsnodes - num), &(side_nodes[num + 1])) + location[i] + 1;
1123 count = 0;
1124 count += numbermatch(side_nodes, 1, num, 4, connect[2]);
1125 count += numbermatch(side_nodes, 2, num, 4, connect[6]);
1126 count += numbermatch(side_nodes, 3, num, 4, connect[5]);
1127 if (count >= min_match) {
1128 return 2;
1129 }
1130 }
1131 }
1132 }
1133 }
1134
1135 /* SIDE 3 */
1136 if ((num = in_list(connect[2], nsnodes, side_nodes)) >= 0) {
1137 count = 0;
1138 count += numbermatch(side_nodes, 1, num, 4, connect[3]);
1139 count += numbermatch(side_nodes, 2, num, 4, connect[7]);
1140 count += numbermatch(side_nodes, 3, num, 4, connect[6]);
1141 if (count >= min_match) {
1142 return 3;
1143 }
1144
1145 /* if this is the duplicated node, then find the next occurrence */
1146 if (dup) {
1147 for (int i = 0; i < dup; i++) {
1148 if (connect[2] == side_nodes[location[i]]) {
1149 num = in_list(connect[2], (nsnodes - num), &(side_nodes[num + 1])) + location[i] + 1;
1150 count = 0;
1151 count += numbermatch(side_nodes, 1, num, 4, connect[3]);
1152 count += numbermatch(side_nodes, 2, num, 4, connect[7]);
1153 count += numbermatch(side_nodes, 3, num, 4, connect[6]);
1154 if (count >= min_match) {
1155 return 3;
1156 }
1157 }
1158 }
1159 }
1160 }
1161
1162 /* SIDE 4 */
1163 if ((num = in_list(connect[3], nsnodes, side_nodes)) >= 0) {
1164 count = 0;
1165 count += numbermatch(side_nodes, 1, num, 4, connect[0]);
1166 count += numbermatch(side_nodes, 2, num, 4, connect[4]);
1167 count += numbermatch(side_nodes, 3, num, 4, connect[7]);
1168 if (count >= min_match) {
1169 return 4;
1170 }
1171
1172 /* if this is the duplicated node, then find the next occurrence */
1173 if (dup) {
1174 for (int i = 0; i < dup; i++) {
1175 if (connect[3] == side_nodes[location[i]]) {
1176 num = in_list(connect[3], (nsnodes - num), &(side_nodes[num + 1])) + location[i] + 1;
1177 count = 0;
1178 count += numbermatch(side_nodes, 1, num, 4, connect[0]);
1179 count += numbermatch(side_nodes, 2, num, 4, connect[4]);
1180 count += numbermatch(side_nodes, 3, num, 4, connect[7]);
1181 if (count >= min_match) {
1182 return 4;
1183 }
1184 }
1185 }
1186 }
1187 }
1188
1189 /* SIDE 5 */
1190 if ((num = in_list(connect[0], nsnodes, side_nodes)) >= 0) {
1191 count = 0;
1192 count += numbermatch(side_nodes, 1, num, 4, connect[3]);
1193 count += numbermatch(side_nodes, 2, num, 4, connect[2]);
1194 count += numbermatch(side_nodes, 3, num, 4, connect[1]);
1195 if (count >= min_match) {
1196 return 5;
1197 }
1198
1199 /* if this is the duplicated node, then find the next occurrence */
1200 if (dup) {
1201 for (int i = 0; i < dup; i++) {
1202 if (connect[0] == side_nodes[location[i]]) {
1203 num = in_list(connect[0], (nsnodes - num), &(side_nodes[num + 1])) + location[i] + 1;
1204 count = 0;
1205 count += numbermatch(side_nodes, 1, num, 4, connect[3]);
1206 count += numbermatch(side_nodes, 2, num, 4, connect[2]);
1207 count += numbermatch(side_nodes, 3, num, 4, connect[1]);
1208 if (count >= min_match) {
1209 return 5;
1210 }
1211 }
1212 }
1213 }
1214 }
1215
1216 /* SIDE 6 */
1217 if ((num = in_list(connect[4], nsnodes, side_nodes)) >= 0) {
1218 count = 0;
1219 count += numbermatch(side_nodes, 1, num, 4, connect[5]);
1220 count += numbermatch(side_nodes, 2, num, 4, connect[6]);
1221 count += numbermatch(side_nodes, 3, num, 4, connect[7]);
1222 if (count >= min_match) {
1223 return 6;
1224 }
1225
1226 /* if this is the duplicated node, then find the next occurrence */
1227 if (dup) {
1228 for (int i = 0; i < dup; i++) {
1229 if (connect[4] == side_nodes[location[i]]) {
1230 num = in_list(connect[4], (nsnodes - num), &(side_nodes[num + 1])) + location[i] + 1;
1231 count = 0;
1232 count += numbermatch(side_nodes, 1, num, 4, connect[5]);
1233 count += numbermatch(side_nodes, 2, num, 4, connect[6]);
1234 count += numbermatch(side_nodes, 3, num, 4, connect[7]);
1235 if (count >= min_match) {
1236 return 6;
1237 }
1238 }
1239 }
1240 }
1241 }
1242
1243 break;
1244
1245 case ElementType::SHELL4:
1246 case ElementType::SHELL8:
1247 case ElementType::SHELL9:
1248
1249 /* 2D sides */
1250 if (nsnodes == 2 || nsnodes == 3) {
1251 /* SIDE 3 */
1252 if (side_nodes[0] == connect[0] && side_nodes[1] == connect[1]) {
1253 return 3;
1254 }
1255
1256 /* SIDE 4 */
1257 if (side_nodes[0] == connect[1] && side_nodes[1] == connect[2]) {
1258 return 4;
1259 }
1260
1261 /* SIDE 5 */
1262 if (side_nodes[0] == connect[2] && side_nodes[1] == connect[3]) {
1263 return 5;
1264 }
1265
1266 /* SIDE 6 */
1267 if (side_nodes[0] == connect[3] && side_nodes[1] == connect[0]) {
1268 return 6;
1269 }
1270 }
1271
1272 /* 3D faces */
1273 else if (nsnodes == 4 || nsnodes == 8 || nsnodes == 9) {
1274
1275 /* SIDE 1 */
1276 if ((num = in_list(connect[0], nsnodes, side_nodes)) >= 0) {
1277 if (side_nodes[(1 + num) % 4] == connect[1] && side_nodes[(2 + num) % 4] == connect[2] &&
1278 side_nodes[(3 + num) % 4] == connect[3]) {
1279 return 1;
1280 }
1281 if (side_nodes[(1 + num) % 4] == connect[3] && side_nodes[(2 + num) % 4] == connect[2] &&
1282 side_nodes[(3 + num) % 4] == connect[1]) {
1283 return 2;
1284 }
1285 }
1286 }
1287
1288 break;
1289
1290 case ElementType::WEDGE6:
1291 case ElementType::WEDGE12:
1292 case ElementType::WEDGE15:
1293 case ElementType::WEDGE16:
1294 case ElementType::WEDGE20:
1295 case ElementType::WEDGE21:
1296
1297 /* quad sides */
1298 if (nsnodes == 4 || nsnodes == 8 || nsnodes == 9) {
1299 if ((num = in_list(connect[0], nsnodes, side_nodes)) >= 0) {
1300 if (side_nodes[(1 + num) % 4] == connect[1] && side_nodes[(2 + num) % 4] == connect[4] &&
1301 side_nodes[(3 + num) % 4] == connect[3]) {
1302 return 1;
1303 }
1304 if (side_nodes[(1 + num) % 4] == connect[3] && side_nodes[(2 + num) % 4] == connect[5] &&
1305 side_nodes[(3 + num) % 4] == connect[2]) {
1306 return 3;
1307 }
1308 }
1309
1310 if ((num = in_list(connect[1], nsnodes, side_nodes)) >= 0) {
1311 if (side_nodes[(1 + num) % 4] == connect[2] && side_nodes[(2 + num) % 4] == connect[5] &&
1312 side_nodes[(3 + num) % 4] == connect[4]) {
1313 return 2;
1314 }
1315 }
1316 }
1317
1318 /* triangle sides */
1319 else if (nsnodes == 3 || nsnodes == 6 || nsnodes == 7) {
1320 if ((num = in_list(connect[0], nsnodes, side_nodes)) >= 0) {
1321 if (side_nodes[(1 + num) % 3] == connect[2] && side_nodes[(2 + num) % 3] == connect[1]) {
1322 return 4;
1323 }
1324 }
1325
1326 if ((num = in_list(connect[3], nsnodes, side_nodes)) >= 0) {
1327 if (side_nodes[(1 + num) % 3] == connect[4] && side_nodes[(2 + num) % 3] == connect[5]) {
1328 return 5;
1329 }
1330 }
1331 }
1332
1333 break;
1334
1335 case ElementType::TSHELL3:
1336 case ElementType::TSHELL4:
1337 case ElementType::TSHELL6:
1338 case ElementType::TSHELL7:
1339
1340 /* 2D sides */
1341 if (nsnodes == 2 || (etype == ElementType::TSHELL6 && nsnodes == 3) ||
1342 (etype == ElementType::TSHELL7 && nsnodes == 3)) {
1343 /* SIDE 3 */
1344 if (side_nodes[0] == connect[0] && side_nodes[1] == connect[1]) {
1345 return 3;
1346 }
1347
1348 /* SIDE 4 */
1349 if (side_nodes[0] == connect[1] && side_nodes[1] == connect[2]) {
1350 return 4;
1351 }
1352
1353 /* SIDE 5 */
1354 if (side_nodes[0] == connect[2] && side_nodes[1] == connect[0]) {
1355 return 5;
1356 }
1357 }
1358
1359 /* 3D faces */
1360 else if (nsnodes == 3 || nsnodes == 4 || nsnodes == 6 || nsnodes == 7) {
1361 if ((num = in_list(connect[0], nsnodes, side_nodes)) >= 0) {
1362 if (side_nodes[(1 + num) % 3] == connect[1] && side_nodes[(2 + num) % 3] == connect[2]) {
1363 return 1;
1364 }
1365 if (side_nodes[(1 + num) % 3] == connect[2] && side_nodes[(2 + num) % 3] == connect[1]) {
1366 return 2;
1367 }
1368 }
1369 }
1370
1371 break;
1372
1373 case ElementType::PYRAMID5:
1374 case ElementType::PYRAMID13:
1375 case ElementType::PYRAMID14:
1376 case ElementType::PYRAMID18:
1377 case ElementType::PYRAMID19:
1378 /* triangular sides */
1379 if (nsnodes == 3 || nsnodes == 6 || nsnodes == 7) {
1380 /* SIDE 1 */
1381 if ((num = in_list(connect[0], nsnodes, side_nodes)) >= 0) {
1382 if (side_nodes[(1 + num) % 3] == connect[1] && side_nodes[(2 + num) % 3] == connect[4]) {
1383 return 1;
1384 }
1385 if (side_nodes[(1 + num) % 3] == connect[4] && side_nodes[(2 + num) % 3] == connect[3]) {
1386 return 4;
1387 }
1388 }
1389
1390 /* SIDE 2 */
1391 if ((num = in_list(connect[1], nsnodes, side_nodes)) >= 0) {
1392 if (side_nodes[(1 + num) % 3] == connect[2] && side_nodes[(2 + num) % 3] == connect[4]) {
1393 return 2;
1394 }
1395 }
1396
1397 /* SIDE 3 */
1398 if ((num = in_list(connect[2], nsnodes, side_nodes)) >= 0) {
1399 if (side_nodes[(1 + num) % 3] == connect[3] && side_nodes[(2 + num) % 3] == connect[4]) {
1400 return 3;
1401 }
1402 }
1403 }
1404
1405 else if (nsnodes == 4 || nsnodes == 8 || nsnodes == 9) {
1406 /* SIDE 5 */
1407 if ((num = in_list(connect[0], nsnodes, side_nodes)) >= 0) {
1408 if (side_nodes[(1 + num) % 4] == connect[3] && side_nodes[(2 + num) % 4] == connect[2] &&
1409 side_nodes[(3 + num) % 4] == connect[1]) {
1410 return 5;
1411 }
1412 }
1413 }
1414
1415 break;
1416
1417 case ElementType::SPHERE: break;
1418
1419 default: {
1420 std::string err_buff;
1421 err_buff = fmt::format("fatal: unknown element type {} in function {}", static_cast<int>(etype),
1422 __func__);
1423 Gen_Error(0, err_buff);
1424 error_report();
1425 exit(1);
1426 }
1427 } /* End "switch(etype)" */
1428
1429 return 0;
1430 } /*---------------------------End get_side_id()-----------------------------*/
1431
1432 /*****************************************************************************/
1433 /*****************************************************************************/
1434 /*****************************************************************************/
1435 /* Function get_side_id_hex_tet() begins:
1436 *----------------------------------------------------------------------------
1437 * This function returns the Side ID (as used in ExodusII) of a HEX element
1438 * given a list of at least 3 nodes on that side. This function works on
1439 * the fact that any three nodes define a side of a hex. When a tet is
1440 * connected to a side of a hex, there are only three nodes connecting
1441 * the two. In this case a side id can be found.
1442 *****************************************************************************/
1443 template int get_side_id_hex_tet(const ElementType etype, const int *connect, int nsnodes,
1444 const int side_nodes[]);
1445 template int get_side_id_hex_tet(const ElementType etype, const int64_t *connect, int nsnodes,
1446 const int64_t side_nodes[]);
1447
1448 template <typename INT>
1449 int get_side_id_hex_tet(const ElementType etype, /* The element type */
1450 const INT *connect, /* The element connectivity */
1451 int nsnodes, /* The number of side nodes */
1452 const INT side_nodes[]) /* The list of side node IDs */
1453 {
1454 std::array<int, MAX_SIDE_NODES> loc_node_ids{};
1455
1456 int nnodes = get_elem_info(ElementInfo::NNODES, etype);
1457
1458 /* Find the local node numbers for nodes forming the side */
1459 int lcnt = 0;
1460 for (int i1 = 0; i1 < nnodes; i1++) {
1461 for (int i2 = 0; i2 < nsnodes; i2++) {
1462 if (connect[i1] == side_nodes[i2]) {
1463 loc_node_ids[lcnt++] = i1 + 1;
1464 break;
1465 }
1466 }
1467 if (lcnt == nsnodes) {
1468 break;
1469 }
1470 }
1471
1472 switch (etype) {
1473 case ElementType::TET4:
1474 case ElementType::TET10:
1475 case ElementType::TET8:
1476 case ElementType::TET14:
1477 case ElementType::TET15: {
1478 auto il1 = in_list(1, lcnt, Data(loc_node_ids)) >= 0;
1479 auto il2 = in_list(2, lcnt, Data(loc_node_ids)) >= 0;
1480 auto il3 = in_list(3, lcnt, Data(loc_node_ids)) >= 0;
1481 auto il4 = in_list(4, lcnt, Data(loc_node_ids)) >= 0;
1482
1483 if (il1 && il2 && il4) {
1484 return 1;
1485 }
1486
1487 if (il2 && il3 && il4) {
1488 return 2;
1489 }
1490
1491 if (il1 && il3 && il4) {
1492 return 3;
1493 }
1494
1495 if (il1 && il2 && il3) {
1496 return 4;
1497 }
1498 } break;
1499
1500 case ElementType::HEX8:
1501 case ElementType::HEX16:
1502 case ElementType::HEX20:
1503 case ElementType::HEX27: {
1504 auto il1 = in_list(1, lcnt, Data(loc_node_ids)) >= 0 ? 1 : 0;
1505 auto il2 = in_list(2, lcnt, Data(loc_node_ids)) >= 0 ? 1 : 0;
1506 auto il3 = in_list(3, lcnt, Data(loc_node_ids)) >= 0 ? 1 : 0;
1507 auto il4 = in_list(4, lcnt, Data(loc_node_ids)) >= 0 ? 1 : 0;
1508 auto il5 = in_list(5, lcnt, Data(loc_node_ids)) >= 0 ? 1 : 0;
1509 auto il6 = in_list(6, lcnt, Data(loc_node_ids)) >= 0 ? 1 : 0;
1510 auto il7 = in_list(7, lcnt, Data(loc_node_ids)) >= 0 ? 1 : 0;
1511 auto il8 = in_list(8, lcnt, Data(loc_node_ids)) >= 0 ? 1 : 0;
1512
1513 if (il1 + il2 + il5 + il6 > 2) {
1514 return 1;
1515 }
1516
1517 if (il2 + il3 + il6 + il7 > 2) {
1518 return 2;
1519 }
1520
1521 if (il3 + il4 + il7 + il8 > 2) {
1522 return 3;
1523 }
1524
1525 if (il1 + il4 + il5 + il8 > 2) {
1526 return 4;
1527 }
1528
1529 if (il1 + il2 + il3 + il4 > 2) {
1530 return 5;
1531 }
1532
1533 if (il5 + il6 + il7 + il8 > 2) {
1534 return 6;
1535 }
1536 } break;
1537
1538 default: {
1539 std::string err_buff;
1540 err_buff = fmt::format("fatal: unknown element type {} in function {}", static_cast<int>(etype),
1541 __func__);
1542 Gen_Error(0, err_buff);
1543 error_report();
1544 exit(1);
1545 }
1546
1547 } /* End "switch(etype)" */
1548
1549 return 0;
1550 } /*-------------------------End get_side_id_hex()---------------------------*/
1551
1552 /*****************************************************************************/
1553 /*****************************************************************************/
1554 /*****************************************************************************/
1555 /* Function ss_to_node_list() begins:
1556 *----------------------------------------------------------------------------
1557 * This function returns the list of nodes in a side of an element given
1558 * the element type, and the side id. It also returns the number of nodes
1559 * in that side.
1560 *****************************************************************************/
1561 template int ss_to_node_list(const ElementType etype, const int *connect, int side_num,
1562 int ss_node_list[]);
1563 template int ss_to_node_list(const ElementType etype, const int64_t *connect, int side_num,
1564 int64_t ss_node_list[]);
1565
1566 template <typename INT>
1567 int ss_to_node_list(const ElementType etype, /* The element type */
1568 const INT *connect, /* The element connectivity */
1569 int side_num, /* The element side number */
1570 INT ss_node_list[]) /* The list of side node IDs */
1571 {
1572 int i = 0;
1573
1574 /*
1575 * This function returns a list of global node numbers forming a
1576 * side set.
1577 */
1578
1579 /* triangle */
1580 static int tri_table[3][3] = {
1581 {1, 2, 4}, // side 1
1582 {2, 3, 5}, // side 2
1583 {3, 1, 6} // side 3
1584 };
1585
1586 /* tshell */
1587 static int tshell_table[2][7] = {
1588 {1, 2, 3, 4, 5, 6, 7}, // side 1
1589 {1, 3, 2, 6, 5, 4, 7} // side 2
1590 };
1591
1592 /* quad */
1593 static int quad_table[4][3] = {
1594 {1, 2, 5}, // side 1
1595 {2, 3, 6}, // side 2
1596 {3, 4, 7}, // side 3
1597 {4, 1, 8} // side 4
1598 };
1599
1600 /* shell */
1601 static int shell_table[2][9] = {
1602 {1, 2, 3, 4, 5, 6, 7, 8, 9}, // side 1
1603 {1, 4, 3, 2, 8, 7, 6, 5, 9} // side 2
1604 };
1605
1606 /* tetra */
1607 static int tetra_table[4][7] = {
1608 {1, 2, 4, 5, 9, 8, 14}, /* Side 1 nodes */
1609 {2, 3, 4, 6, 10, 9, 12}, /* Side 2 nodes */
1610 {1, 4, 3, 8, 10, 7, 13}, /* Side 3 nodes */
1611 {1, 3, 2, 7, 6, 5, 11} /* Side 4 nodes */
1612 };
1613
1614 /* wedge */
1615 /* wedge 6 or 7 */
1616 static int wedge6_table[5][4] = {
1617 {1, 2, 5, 4}, /* Side 1 nodes -- quad */
1618 {2, 3, 6, 5}, /* Side 2 nodes -- quad */
1619 {1, 4, 6, 3}, /* Side 3 nodes -- quad */
1620 {1, 3, 2, 0}, /* Side 4 nodes -- triangle */
1621 {4, 5, 6, 0} /* Side 5 nodes -- triangle */
1622 };
1623
1624 /* wedge 12 */
1625 static int wedge12_table[5][6] = {
1626 {1, 2, 5, 4, 7, 10}, /* Side 1 nodes -- quad4 */
1627 {2, 3, 6, 5, 8, 11}, /* Side 2 nodes -- quad4 */
1628 {3, 1, 4, 6, 9, 12}, /* Side 3 nodes -- quad4 */
1629 {1, 3, 2, 9, 8, 7}, /* Side 4 nodes -- triangle6 */
1630 {4, 5, 6, 10, 11, 12} /* Side 5 nodes -- triangle6 */
1631 };
1632
1633 /* wedge 15 or 16 */
1634 static int wedge15_table[5][8] = {
1635 {1, 2, 5, 4, 7, 11, 13, 10}, /* Side 1 nodes -- quad */
1636 {2, 3, 6, 5, 8, 12, 14, 11}, /* Side 2 nodes -- quad */
1637 {1, 4, 6, 3, 10, 15, 12, 9}, /* Side 3 nodes -- quad */
1638 {1, 3, 2, 9, 8, 7, 0, 0}, /* Side 4 nodes -- triangle */
1639 {4, 5, 6, 13, 14, 15, 0, 0} /* Side 5 nodes -- triangle */
1640 };
1641
1642 /* wedge 20 */
1643 static int wedge20_table[5][9] = {
1644 {1, 2, 5, 4, 7, 11, 13, 10, 20}, /* Side 1 nodes -- quad */
1645 {2, 3, 6, 5, 8, 12, 14, 11, 18}, /* Side 2 nodes -- quad */
1646 {1, 4, 6, 3, 10, 15, 12, 9, 19}, /* Side 3 nodes -- quad */
1647 {1, 3, 2, 9, 8, 7, 16, 0, 0}, /* Side 4 nodes -- triangle */
1648 {4, 5, 6, 13, 14, 15, 17, 0, 0} /* Side 5 nodes -- triangle */
1649 };
1650
1651 /* wedge 21 */
1652 static int wedge21_table[5][9] = {
1653 {1, 2, 5, 4, 7, 11, 13, 10, 21}, /* Side 1 nodes -- quad */
1654 {2, 3, 6, 5, 8, 12, 14, 11, 19}, /* Side 2 nodes -- quad */
1655 {1, 4, 6, 3, 10, 15, 12, 9, 20}, /* Side 3 nodes -- quad */
1656 {1, 3, 2, 9, 8, 7, 17, 0, 0}, /* Side 4 nodes -- triangle */
1657 {4, 5, 6, 13, 14, 15, 18, 0, 0} /* Side 5 nodes -- triangle */
1658 };
1659
1660 /* hex */
1661 static int hex_table[6][9] = {
1662 {1, 2, 6, 5, 9, 14, 17, 13, 26}, /* side 1 */
1663 {2, 3, 7, 6, 10, 15, 18, 14, 25}, /* side 2 */
1664 {3, 4, 8, 7, 11, 16, 19, 15, 27}, /* side 3 */
1665 {1, 5, 8, 4, 13, 20, 16, 12, 24}, /* side 4 */
1666 {1, 4, 3, 2, 12, 11, 10, 9, 22}, /* side 5 */
1667 {5, 6, 7, 8, 17, 18, 19, 20, 23} /* side 6 */
1668 };
1669
1670 /* hex16 */
1671 static int hex16_table[6][9] = {
1672 {1, 2, 6, 5, 9, 13, 0, 0}, /* side 1 */
1673 {2, 3, 7, 6, 10, 14, 0, 0}, /* side 2 */
1674 {3, 4, 8, 7, 11, 15, 0, 0}, /* side 3 */
1675 {4, 1, 5, 8, 4, 12, 16, 0}, /* side 4 */
1676 {1, 4, 3, 2, 12, 11, 10, 9}, /* side 5 */
1677 {5, 6, 7, 8, 13, 14, 15, 16} /* side 6 */
1678 };
1679
1680 /* hexshell */
1681 static int hexshell_table[6][6] = {
1682 {1, 2, 6, 5, 10, 9}, // side 1
1683 {2, 3, 7, 6, 11, 10}, // side 2
1684 {3, 4, 8, 7, 12, 11}, // side 3
1685 {4, 1, 5, 8, 9, 12}, // side 4
1686 {1, 4, 3, 2, 0, 0}, // side 5
1687 {5, 6, 7, 8, 0, 0} // side 6
1688 };
1689
1690 /* pyramid */
1691 static int pyramid_table[5][9] = {
1692 {1, 2, 5, 6, 11, 10, 15, 0, 0}, // side 1 (tri)
1693 {2, 3, 5, 7, 12, 11, 16, 0, 0}, // side 2 (tri)
1694 {3, 4, 5, 8, 13, 12, 17, 0, 0}, // side 3 (tri)
1695 {4, 1, 5, 9, 10, 13, 18, 0, 0}, // side 4 (tri)
1696 {1, 4, 3, 2, 9, 8, 7, 6, 14} // side 5 (quad)
1697 };
1698
1699 static int bar_table[1][3] = {{1, 2, 3}};
1700
1701 /* Locally decrement side_num */
1702 side_num--;
1703
1704 /* Switch over the element type. */
1705 switch (etype) {
1706 case ElementType::BAR1D2:
1707 case ElementType::BAR1D3:
1708 ss_node_list[0] = connect[side_num];
1709 i = 1;
1710 break;
1711
1712 case ElementType::BAR2:
1713 case ElementType::SHELL2:
1714 /* Bar1 has 1 side */
1715 for (i = 0; i < 2; i++) {
1716 ss_node_list[i] = connect[bar_table[side_num][i] - 1];
1717 }
1718 break;
1719
1720 case ElementType::BAR3:
1721 case ElementType::SHELL3:
1722 /* Bar has 1 side */
1723 for (i = 0; i < 3; i++) {
1724 ss_node_list[i] = connect[bar_table[side_num][i] - 1];
1725 }
1726 break;
1727
1728 case ElementType::QUAD4:
1729 for (i = 0; i < 2; i++) {
1730 ss_node_list[i] = connect[quad_table[side_num][i] - 1];
1731 }
1732 break;
1733
1734 case ElementType::QUAD8:
1735 case ElementType::QUAD9:
1736 for (i = 0; i < 3; i++) {
1737 ss_node_list[i] = connect[quad_table[side_num][i] - 1];
1738 }
1739 break;
1740
1741 case ElementType::SHELL4:
1742 if (side_num == 0 || side_num == 1) {
1743 for (i = 0; i < 4; i++) {
1744 ss_node_list[i] = connect[shell_table[side_num][i] - 1];
1745 }
1746 }
1747 else {
1748 /*
1749 * sides 3, 4, 5, & 6 correspond to sides 1, 2, 3, & 4
1750 * of the quad element.
1751 */
1752 for (i = 0; i < 2; i++) {
1753 ss_node_list[i] = connect[quad_table[side_num - 2][i] - 1];
1754 }
1755 }
1756 break;
1757
1758 case ElementType::SHELL8:
1759 if (side_num == 0 || side_num == 1) {
1760 for (i = 0; i < 8; i++) {
1761 ss_node_list[i] = connect[shell_table[side_num][i] - 1];
1762 }
1763 }
1764 else {
1765 /*
1766 * sides 3, 4, 5, & 6 correspond to sides 1, 2, 3, & 4
1767 * of the quad element.
1768 */
1769 for (i = 0; i < 3; i++) {
1770 ss_node_list[i] = connect[quad_table[side_num - 2][i] - 1];
1771 }
1772 }
1773 break;
1774
1775 case ElementType::SHELL9:
1776 if (side_num == 0 || side_num == 1) {
1777 for (i = 0; i < 9; i++) {
1778 ss_node_list[i] = connect[shell_table[side_num][i] - 1];
1779 }
1780 }
1781 else {
1782 /*
1783 * sides 3, 4, 5, & 6 correspond to sides 1, 2, 3, & 4
1784 * of the quad element.
1785 */
1786 for (i = 0; i < 3; i++) {
1787 ss_node_list[i] = connect[quad_table[(side_num - 2)][i] - 1];
1788 }
1789 }
1790 break;
1791
1792 case ElementType::TRI3:
1793 case ElementType::TRI4:
1794 for (i = 0; i < 2; i++) {
1795 ss_node_list[i] = connect[tri_table[side_num][i] - 1];
1796 }
1797 break;
1798
1799 case ElementType::TRI6:
1800 case ElementType::TRI7:
1801 for (i = 0; i < 3; i++) {
1802 ss_node_list[i] = connect[tri_table[side_num][i] - 1];
1803 }
1804 break;
1805
1806 case ElementType::TSHELL3:
1807 case ElementType::TSHELL4:
1808 if (side_num == 0 || side_num == 1) {
1809 for (i = 0; i < 3; i++) {
1810 ss_node_list[i] = connect[tshell_table[side_num][i] - 1];
1811 }
1812 }
1813 else {
1814 /*
1815 * sides 3, 4 & 5 correspond to sides 1, 2 & 3
1816 * of the tri element.
1817 */
1818 for (i = 0; i < 2; i++) {
1819 ss_node_list[i] = connect[tri_table[(side_num - 2)][i] - 1];
1820 }
1821 }
1822 break;
1823
1824 case ElementType::TSHELL6:
1825 case ElementType::TSHELL7:
1826 if (side_num == 0 || side_num == 1) {
1827 for (i = 0; i < 6; i++) {
1828 ss_node_list[i] = connect[tshell_table[side_num][i] - 1];
1829 }
1830 }
1831 else {
1832 /*
1833 * sides 3, 4 & 5 correspond to sides 1, 2 & 3
1834 * of the tri element.
1835 */
1836 for (i = 0; i < 3; i++) {
1837 ss_node_list[i] = connect[tri_table[(side_num - 2)][i] - 1];
1838 }
1839 }
1840 break;
1841
1842 case ElementType::HEX8:
1843 for (i = 0; i < 4; i++) {
1844 ss_node_list[i] = connect[hex_table[side_num][i] - 1];
1845 }
1846 break;
1847
1848 case ElementType::HEX16:
1849 if (side_num == 4 || side_num == 5) {
1850 for (i = 0; i < 8; i++) {
1851 ss_node_list[i] = connect[hex16_table[side_num][i] - 1];
1852 }
1853 }
1854 else {
1855 for (i = 0; i < 6; i++) {
1856 ss_node_list[i] = connect[hex16_table[side_num][i] - 1];
1857 }
1858 }
1859 break;
1860
1861 case ElementType::HEX20:
1862 for (i = 0; i < 8; i++) {
1863 ss_node_list[i] = connect[hex_table[side_num][i] - 1];
1864 }
1865 break;
1866
1867 case ElementType::HEX27:
1868 for (i = 0; i < 9; i++) {
1869 ss_node_list[i] = connect[hex_table[side_num][i] - 1];
1870 }
1871 break;
1872
1873 case ElementType::TET4:
1874 for (i = 0; i < 3; i++) {
1875 ss_node_list[i] = connect[tetra_table[side_num][i] - 1];
1876 }
1877 break;
1878
1879 case ElementType::TET10:
1880 for (i = 0; i < 6; i++) {
1881 ss_node_list[i] = connect[tetra_table[side_num][i] - 1];
1882 }
1883 break;
1884
1885 case ElementType::TET14:
1886 case ElementType::TET15:
1887 for (i = 0; i < 7; i++) {
1888 ss_node_list[i] = connect[tetra_table[side_num][i] - 1];
1889 }
1890 break;
1891
1892 case ElementType::TET8:
1893 for (i = 0; i < 4; i++) {
1894 ss_node_list[i] = connect[tetra_table[side_num][i] - 1];
1895 }
1896 break;
1897
1898 case ElementType::WEDGE6:
1899 if (side_num == 3 || side_num == 4) {
1900 for (i = 0; i < 3; i++) {
1901 ss_node_list[i] = connect[wedge6_table[side_num][i] - 1];
1902 }
1903 }
1904 else {
1905 for (i = 0; i < 4; i++) {
1906 ss_node_list[i] = connect[wedge6_table[side_num][i] - 1];
1907 }
1908 }
1909 break;
1910
1911 case ElementType::WEDGE12:
1912 for (i = 0; i < 6; i++) {
1913 ss_node_list[i] = connect[wedge12_table[side_num][i] - 1];
1914 }
1915 break;
1916
1917 case ElementType::WEDGE15:
1918 case ElementType::WEDGE16:
1919 if (side_num == 3 || side_num == 4) {
1920 for (i = 0; i < 6; i++) {
1921 ss_node_list[i] = connect[wedge15_table[side_num][i] - 1];
1922 }
1923 }
1924 else {
1925 for (i = 0; i < 8; i++) {
1926 ss_node_list[i] = connect[wedge15_table[side_num][i] - 1];
1927 }
1928 }
1929 break;
1930
1931 case ElementType::WEDGE20:
1932 if (side_num == 3 || side_num == 4) {
1933 for (i = 0; i < 7; i++) {
1934 ss_node_list[i] = connect[wedge20_table[side_num][i] - 1];
1935 }
1936 }
1937 else {
1938 for (i = 0; i < 9; i++) {
1939 ss_node_list[i] = connect[wedge20_table[side_num][i] - 1];
1940 }
1941 }
1942 break;
1943
1944 case ElementType::WEDGE21:
1945 if (side_num == 3 || side_num == 4) {
1946 for (i = 0; i < 7; i++) {
1947 ss_node_list[i] = connect[wedge21_table[side_num][i] - 1];
1948 }
1949 }
1950 else {
1951 for (i = 0; i < 9; i++) {
1952 ss_node_list[i] = connect[wedge21_table[side_num][i] - 1];
1953 }
1954 }
1955 break;
1956
1957 case ElementType::HEXSHELL:
1958 if (side_num == 4 || side_num == 5) {
1959 for (i = 0; i < 4; i++) {
1960 ss_node_list[i] = connect[hexshell_table[side_num][i] - 1];
1961 }
1962 }
1963 else {
1964 for (i = 0; i < 6; i++) {
1965 ss_node_list[i] = connect[hexshell_table[side_num][i] - 1];
1966 }
1967 }
1968 break;
1969
1970 case ElementType::PYRAMID5:
1971 if (side_num == 4) {
1972 for (i = 0; i < 4; i++) {
1973 ss_node_list[i] = connect[pyramid_table[side_num][i] - 1];
1974 }
1975 }
1976 else {
1977 for (i = 0; i < 3; i++) {
1978 ss_node_list[i] = connect[pyramid_table[side_num][i] - 1];
1979 }
1980 }
1981 break;
1982
1983 case ElementType::PYRAMID13:
1984 if (side_num == 4) {
1985 for (i = 0; i < 8; i++) {
1986 ss_node_list[i] = connect[pyramid_table[side_num][i] - 1];
1987 }
1988 }
1989 else {
1990 for (i = 0; i < 6; i++) {
1991 ss_node_list[i] = connect[pyramid_table[side_num][i] - 1];
1992 }
1993 }
1994 break;
1995
1996 case ElementType::PYRAMID14:
1997 if (side_num == 4) {
1998 for (i = 0; i < 9; i++) {
1999 ss_node_list[i] = connect[pyramid_table[side_num][i] - 1];
2000 }
2001 }
2002 else {
2003 for (i = 0; i < 6; i++) {
2004 ss_node_list[i] = connect[pyramid_table[side_num][i] - 1];
2005 }
2006 }
2007 break;
2008
2009 case ElementType::PYRAMID18:
2010 case ElementType::PYRAMID19: /* Pyramid18 with mid-volume node */
2011 if (side_num == 4) {
2012 for (i = 0; i < 9; i++) {
2013 ss_node_list[i] = connect[pyramid_table[side_num][i] - 1];
2014 }
2015 }
2016 else {
2017 for (i = 0; i < 7; i++) {
2018 ss_node_list[i] = connect[pyramid_table[side_num][i] - 1];
2019 }
2020 }
2021 break;
2022
2023 case ElementType::SPHERE: /* SHPERE's have no side sets */
2024 case ElementType::NULL_EL: i = 0; break;
2025
2026 } /* End "switch (etype)" */
2027
2028 /* the variable "i" should be the number of positions that I filled */
2029 return i;
2030
2031 } /*-------------------------End ss_to_node_list()---------------------------*/
2032
2033 /*****************************************************************************/
2034 /*****************************************************************************/
2035 /*****************************************************************************/
2036 /* Function get_ss_mirror() begins:
2037 *----------------------------------------------------------------------------
2038 * This function returns the node list for the mirror of the list
2039 * given. This will be the node list of a face that is connected
2040 * to this element on this face.
2041 *****************************************************************************/
2042 template int get_ss_mirror(const ElementType etype, const int *ss_node_list, int side_num,
2043 int mirror_node_list[]);
2044 template int get_ss_mirror(const ElementType etype, const int64_t *ss_node_list, int side_num,
2045 int64_t mirror_node_list[]);
2046
2047 template <typename INT>
2048 int get_ss_mirror(const ElementType etype, /* The element type */
2049 const INT *ss_node_list, /* The list of side node IDs */
2050 int side_num, /* The element side number */
2051 INT mirror_node_list[] /* The list of the mirror side node IDs */
2052 )
2053 {
2054 int i = 0;
2055
2056 /*
2057 * the following arrays are the conversion from the side to
2058 * an opposing face
2059 */
2060
2061 /* line (1-d) */
2062 static const int line_table[3] = {1, 0, 2};
2063
2064 /* square (2-d) */
2065 static const int sqr_table[9] = {0, 3, 2, 1, 7, 6, 5, 4, 8};
2066
2067 /* square hexshell (2-d) */
2068 static const int hs_table[6] = {0, 3, 2, 1, 5, 4};
2069
2070 /* triangle (2-d) */
2071 static const int tri_table[7] = {1, 0, 2, 3, 5, 4, 6};
2072
2073 /***************************** execution begins ******************************/
2074
2075 /* Switch over the element type. */
2076 switch (etype) {
2077 case ElementType::BAR1D2:
2078 case ElementType::BAR1D3:
2079 // Side is a single node...
2080 mirror_node_list[0] = ss_node_list[0];
2081 i = 1;
2082 break;
2083
2084 case ElementType::BAR2:
2085 case ElementType::SHELL2:
2086 for (i = 0; i < 2; i++) {
2087 mirror_node_list[i] = ss_node_list[line_table[i]];
2088 }
2089 break;
2090 case ElementType::BAR3:
2091 case ElementType::SHELL3:
2092 for (i = 0; i < 3; i++) {
2093 mirror_node_list[i] = ss_node_list[line_table[i]];
2094 }
2095 break;
2096 case ElementType::QUAD4:
2097 for (i = 0; i < 2; i++) {
2098 mirror_node_list[i] = ss_node_list[line_table[i]];
2099 }
2100 break;
2101
2102 case ElementType::QUAD8:
2103 case ElementType::QUAD9:
2104 for (i = 0; i < 3; i++) {
2105 mirror_node_list[i] = ss_node_list[line_table[i]];
2106 }
2107 break;
2108
2109 case ElementType::SHELL4:
2110 switch (side_num) {
2111 case 1:
2112 case 2:
2113 for (i = 0; i < 4; i++) {
2114 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2115 }
2116 break;
2117
2118 default:
2119 for (i = 0; i < 2; i++) {
2120 mirror_node_list[i] = ss_node_list[line_table[i]];
2121 }
2122 break;
2123 }
2124 break;
2125
2126 case ElementType::SHELL8:
2127 switch (side_num) {
2128 case 1:
2129 case 2:
2130 for (i = 0; i < 8; i++) {
2131 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2132 }
2133 break;
2134
2135 default:
2136 for (i = 0; i < 3; i++) {
2137 mirror_node_list[i] = ss_node_list[line_table[i]];
2138 }
2139 break;
2140 }
2141 break;
2142
2143 case ElementType::SHELL9:
2144 switch (side_num) {
2145 case 1:
2146 case 2:
2147 for (i = 0; i < 9; i++) {
2148 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2149 }
2150 break;
2151
2152 default:
2153 for (i = 0; i < 3; i++) {
2154 mirror_node_list[i] = ss_node_list[line_table[i]];
2155 }
2156 break;
2157 }
2158 break;
2159
2160 case ElementType::TRI3:
2161 case ElementType::TRI4:
2162 for (i = 0; i < 2; i++) {
2163 mirror_node_list[i] = ss_node_list[line_table[i]];
2164 }
2165 break;
2166
2167 case ElementType::TRI6:
2168 case ElementType::TRI7:
2169 for (i = 0; i < 3; i++) {
2170 mirror_node_list[i] = ss_node_list[line_table[i]];
2171 }
2172 break;
2173
2174 case ElementType::TSHELL3:
2175 switch (side_num) {
2176 case 1:
2177 case 2:
2178 for (i = 0; i < 3; i++) {
2179 mirror_node_list[i] = ss_node_list[tri_table[i]];
2180 }
2181 break;
2182
2183 default:
2184 for (i = 0; i < 2; i++) {
2185 mirror_node_list[i] = ss_node_list[line_table[i]];
2186 }
2187 break;
2188 }
2189 break;
2190
2191 case ElementType::TSHELL4:
2192 switch (side_num) {
2193 case 1:
2194 case 2:
2195 for (i = 0; i < 4; i++) {
2196 mirror_node_list[i] = ss_node_list[tri_table[i]];
2197 }
2198 break;
2199
2200 default:
2201 for (i = 0; i < 2; i++) {
2202 mirror_node_list[i] = ss_node_list[line_table[i]];
2203 }
2204 break;
2205 }
2206 break;
2207
2208 case ElementType::TSHELL6:
2209 switch (side_num) {
2210 case 1:
2211 case 2:
2212 for (i = 0; i < 6; i++) {
2213 mirror_node_list[i] = ss_node_list[tri_table[i]];
2214 }
2215 break;
2216
2217 default:
2218 for (i = 0; i < 3; i++) {
2219 mirror_node_list[i] = ss_node_list[line_table[i]];
2220 }
2221 break;
2222 }
2223 break;
2224
2225 case ElementType::TSHELL7:
2226 switch (side_num) {
2227 case 1:
2228 case 2:
2229 for (i = 0; i < 7; i++) {
2230 mirror_node_list[i] = ss_node_list[tri_table[i]];
2231 }
2232 break;
2233
2234 default:
2235 for (i = 0; i < 3; i++) {
2236 mirror_node_list[i] = ss_node_list[line_table[i]];
2237 }
2238 break;
2239 }
2240 break;
2241
2242 case ElementType::HEX8:
2243 for (i = 0; i < 4; i++) {
2244 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2245 }
2246 break;
2247
2248 case ElementType::HEX16:
2249 switch (side_num) {
2250 case 4:
2251 case 5:
2252 for (i = 0; i < 8; i++) {
2253 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2254 }
2255 break;
2256
2257 default:
2258 for (i = 0; i < 6; i++) {
2259 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2260 }
2261 }
2262 break;
2263
2264 case ElementType::HEX27:
2265 for (i = 0; i < 9; i++) {
2266 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2267 }
2268 break;
2269
2270 case ElementType::HEX20:
2271 for (i = 0; i < 8; i++) {
2272 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2273 }
2274 break;
2275
2276 case ElementType::TET4:
2277 for (i = 0; i < 3; i++) {
2278 mirror_node_list[i] = ss_node_list[tri_table[i]];
2279 }
2280 break;
2281
2282 case ElementType::TET8:
2283 for (i = 0; i < 4; i++) {
2284 mirror_node_list[i] = ss_node_list[tri_table[i]];
2285 }
2286 break;
2287
2288 case ElementType::TET10:
2289 for (i = 0; i < 6; i++) {
2290 mirror_node_list[i] = ss_node_list[tri_table[i]];
2291 }
2292 break;
2293
2294 case ElementType::TET14:
2295 case ElementType::TET15:
2296 for (i = 0; i < 7; i++) {
2297 mirror_node_list[i] = ss_node_list[tri_table[i]];
2298 }
2299 break;
2300
2301 case ElementType::WEDGE6:
2302 switch (side_num) {
2303 case 4:
2304 case 5:
2305 for (i = 0; i < 3; i++) {
2306 mirror_node_list[i] = ss_node_list[tri_table[i]];
2307 }
2308 break;
2309
2310 default:
2311 for (i = 0; i < 4; i++) {
2312 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2313 }
2314 break;
2315 }
2316 break;
2317
2318 case ElementType::WEDGE12:
2319 for (i = 0; i < 6; i++) {
2320 mirror_node_list[i] = ss_node_list[tri_table[i]];
2321 }
2322 break;
2323
2324 case ElementType::WEDGE15:
2325 case ElementType::WEDGE16:
2326 switch (side_num) {
2327 case 4:
2328 case 5:
2329 for (i = 0; i < 6; i++) {
2330 mirror_node_list[i] = ss_node_list[tri_table[i]];
2331 }
2332 break;
2333
2334 default:
2335 for (i = 0; i < 8; i++) {
2336 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2337 }
2338 break;
2339 }
2340 break;
2341
2342 case ElementType::WEDGE20:
2343 case ElementType::WEDGE21:
2344 switch (side_num) {
2345 case 4:
2346 case 5:
2347 for (i = 0; i < 7; i++) {
2348 mirror_node_list[i] = ss_node_list[tri_table[i]];
2349 }
2350 break;
2351
2352 default:
2353 for (i = 0; i < 9; i++) {
2354 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2355 }
2356 break;
2357 }
2358 break;
2359
2360 case ElementType::HEXSHELL:
2361 switch (side_num) {
2362 case 5:
2363 case 6:
2364 for (i = 0; i < 4; i++) {
2365 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2366 }
2367 break;
2368
2369 default:
2370 for (i = 0; i < 6; i++) {
2371 mirror_node_list[i] = ss_node_list[hs_table[i]];
2372 }
2373 break;
2374 }
2375 break;
2376
2377 case ElementType::PYRAMID5:
2378 switch (side_num) {
2379 case 5:
2380 for (i = 0; i < 4; i++) {
2381 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2382 }
2383 break;
2384
2385 default:
2386 for (i = 0; i < 3; i++) {
2387 mirror_node_list[i] = ss_node_list[tri_table[i]];
2388 }
2389 break;
2390 }
2391 break;
2392
2393 case ElementType::PYRAMID13:
2394 switch (side_num) {
2395 case 5:
2396 for (i = 0; i < 8; i++) {
2397 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2398 }
2399 break;
2400
2401 default:
2402 for (i = 0; i < 6; i++) {
2403 mirror_node_list[i] = ss_node_list[tri_table[i]];
2404 }
2405 break;
2406 }
2407 break;
2408
2409 case ElementType::PYRAMID14:
2410 switch (side_num) {
2411 case 5:
2412 for (i = 0; i < 9; i++) {
2413 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2414 }
2415 break;
2416
2417 default:
2418 for (i = 0; i < 6; i++) {
2419 mirror_node_list[i] = ss_node_list[tri_table[i]];
2420 }
2421 break;
2422 }
2423 break;
2424
2425 case ElementType::PYRAMID18:
2426 case ElementType::PYRAMID19:
2427 switch (side_num) {
2428 case 5:
2429 for (i = 0; i < 9; i++) {
2430 mirror_node_list[i] = ss_node_list[sqr_table[i]];
2431 }
2432 break;
2433
2434 default:
2435 for (i = 0; i < 7; i++) {
2436 mirror_node_list[i] = ss_node_list[tri_table[i]];
2437 }
2438 break;
2439 }
2440 break;
2441
2442 case ElementType::SPHERE: /* SHPERE's have no side sets */
2443 case ElementType::NULL_EL: i = 0; break;
2444
2445 } /* End "switch (etype)" */
2446
2447 /* the variable "i" should be the number of positions that I filled */
2448 return i;
2449
2450 } /*-------------------------Ed get_ss_mirror()---------------------------*/