Debian Codegraph @

packages/seacas/applications/nem_spread/el_elm_info.C

raw
1 /*
2 * Copyright(C) 1999-2020 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 "el_elm.h"
10 #include <cstdio>
11 #include <cstdlib>
12 #include <cstring>
13 #include <fmt/ostream.h>
14
15 #define LINEAR 1
16 #define QUADRATIC 2
17
18 /*************** R O U T I N E S I N T H I S F I L E ********************
19 *
20 * NAME TYPE CALL_BY
21 * --------------- ------- ------------------------
22 * elem_info () int "rf_fill.c" matrix_fill
23 * get_type () int
24 * calc_elem_vol() double multiple routines
25 *
26 ******************************************************************************/
27 /*****************************************************************************/
28 /*****************************************************************************/
29
30 int elem_info(int info, int ielem_type, int supp)
31
32 /*
33 * Function which returns the various parameters * for the elements, e.g.,
34 * polynomial order, number of * Gaussian-quadrature points, etc, based upon
35 * what a code * passed from the calling routine.
36 *
37 * Author: Scott Hutchinson (1421)
38 * Date: 15 May 1992
39 *
40 * The routine currently handles the following requests for information
41 * about element type, ielem_type:
42 *
43 * NNODES = Number of nodes in the element
44 * NDIM = Dimension of the element
45 * NN_SIDE = Number of nodes on a side/face of the element.
46 */
47
48 {
49
50 int answer = 0;
51
52 /* return desired element information */
53
54 switch (ielem_type) { /* select type of element */
55
56 case SPHERE:
57 switch (info) {
58 case NNODES: answer = 1; break;
59 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
60 }
61 break;
62
63 case SHELL4:
64 switch (info) {
65 case NNODES: answer = 4; break;
66 case NDIM: answer = 3; break;
67 case NN_SIDE:
68 switch (supp) {
69 case 1:
70 case 2: answer = 4; break;
71 default: answer = 2; break;
72 }
73 break;
74
75 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
76 }
77 break;
78
79 case SHELL8:
80 switch (info) {
81 case NNODES: answer = 8; break;
82 case NDIM: answer = 3; break;
83 case NN_SIDE:
84 switch (supp) {
85 case 1:
86 case 2: answer = 8; break;
87 default: answer = 3; break;
88 }
89 break;
90
91 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
92 }
93 break;
94
95 case SHELL9:
96 switch (info) {
97 case NNODES: answer = 9; break;
98 case NDIM: answer = 3; break;
99 case NN_SIDE:
100 switch (supp) {
101 case 1:
102 case 2: answer = 9; break;
103 default: answer = 3; break;
104 }
105 break;
106
107 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
108 }
109 break;
110
111 case TSHELL3:
112 switch (info) {
113 case NNODES: answer = 3; break;
114 case NDIM: answer = 3; break;
115 case NN_SIDE:
116 switch (supp) {
117 case 1:
118 case 2: answer = 3; break;
119 default: answer = 2; break;
120 }
121 break;
122
123 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
124 }
125 break;
126
127 case TSHELL4:
128 switch (info) {
129 case NNODES: answer = 4; break;
130 case NDIM: answer = 3; break;
131 case NN_SIDE:
132 switch (supp) {
133 case 1:
134 case 2: answer = 4; break;
135 default: answer = 2; break;
136 }
137 break;
138
139 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
140 }
141 break;
142
143 case TSHELL6:
144 switch (info) {
145 case NNODES: answer = 6; break;
146 case NDIM: answer = 3; break;
147 case NN_SIDE:
148 switch (supp) {
149 case 1:
150 case 2: answer = 6; break;
151 default: answer = 3; break;
152 }
153 break;
154
155 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
156 }
157 break;
158
159 case TSHELL7:
160 switch (info) {
161 case NNODES: answer = 7; break;
162 case NDIM: answer = 3; break;
163 case NN_SIDE:
164 switch (supp) {
165 case 1:
166 case 2: answer = 7; break;
167 default: answer = 3; break;
168 }
169 break;
170
171 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
172 }
173 break;
174
175 case BAR2:
176 case SHELL2:
177 switch (info) { /* select type of information required */
178 case NNODES: answer = 2; break;
179 case NDIM: answer = 1; break;
180 case NN_SIDE: answer = 1; break;
181 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
182 }
183 break;
184
185 case BAR3:
186 case SHELL3:
187 switch (info) { /* select type of information required */
188 case NNODES: answer = 3; break;
189 case NDIM: answer = 1; break;
190 case NN_SIDE: answer = 1; break;
191 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
192 }
193 break;
194
195 case QUAD4: /* bilinear quadrilateral */
196 switch (info) { /* select type of information required */
197 case NNODES: answer = 4; break;
198 case NDIM: answer = 2; break;
199 case NN_SIDE: answer = 2; break;
200 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
201 }
202 break;
203
204 case QUAD8: /* biquadratic serendipity quadrilateral */
205 switch (info) { /* select type of information required */
206 case NNODES: answer = 8; break;
207 case NDIM: answer = 2; break;
208 case NN_SIDE: answer = 3; break;
209 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
210 }
211 break;
212
213 case QUAD9: /* biquadratic quadrilateral */
214 switch (info) { /* select type of information required */
215 case NNODES: answer = 9; break;
216 case NDIM: answer = 2; break;
217 case NN_SIDE: answer = 3; break;
218 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
219 }
220 break;
221
222 case TRI3:
223 switch (info) { /* select type of information required */
224 case NNODES: answer = 3; break;
225 case NDIM: answer = 2; break;
226 case NN_SIDE: answer = 2; break;
227 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
228 }
229 break;
230
231 case TRI4:
232 switch (info) { /* select type of information required */
233 case NNODES: answer = 4; break;
234 case NDIM: answer = 2; break;
235 case NN_SIDE: answer = 2; break;
236 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
237 }
238 break;
239
240 case TRI6:
241 switch (info) { /* select type of information required */
242 case NNODES: answer = 6; break;
243 case NDIM: answer = 2; break;
244 case NN_SIDE: answer = 3; break;
245 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
246 }
247 break;
248
249 case TRI7:
250 switch (info) { /* select type of information required */
251 case NNODES: answer = 7; break;
252 case NDIM: answer = 2; break;
253 case NN_SIDE: answer = 3; break;
254 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
255 }
256 break;
257
258 case HEX8: /* trilinear hexahedron */
259 switch (info) { /* select type of information required */
260 case NNODES: answer = 8; break;
261 case NDIM: answer = 3; break;
262 case NN_SIDE: answer = 4; break;
263 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
264 }
265 break;
266
267 case HEX16: /* localization element */
268 switch (info) {
269 case NNODES: answer = 16; break;
270 case NDIM: answer = 3; break;
271 case NN_SIDE:
272 switch (supp) {
273 case 5:
274 case 6: answer = 8; break;
275 default: answer = 6; break;
276 }
277 break;
278
279 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
280 }
281 break;
282
283 case HEX20: /* serendipity triquadratic hexahedron */
284 switch (info) { /* select type of information required */
285 case NNODES: answer = 20; break;
286 case NDIM: answer = 3; break;
287 case NN_SIDE: answer = 8; break;
288 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
289 }
290 break;
291
292 case HEX27: /* triquadratic hexahedron */
293 switch (info) { /* select type of information required */
294 case NNODES: answer = 27; break;
295 case NDIM: answer = 3; break;
296 case NN_SIDE: answer = 9; break;
297 default: fmt::print(stderr, "{}ERROR: Unknown quantity.\n", __func__); exit(1);
298 }
299 break;
300
301 case TET4: /* trilinear tetrahedron */
302 switch (info) { /* select type of information required */
303 case NNODES: answer = 4; break;
304 case NDIM: answer = 3; break;
305 case NN_SIDE: answer = 3; break;
306 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
307 }
308 break;
309
310 case TET10: /* triquadradic tetrahedron */
311 switch (info) { /* select type of information required */
312 case NNODES: answer = 10; break;
313 case NDIM: answer = 3; break;
314 case NN_SIDE: answer = 6; break;
315 default: fmt::print(stderr, "{}ERROR: Unknown quantity.\n", __func__); exit(1);
316 }
317 break;
318
319 case TET14: /* triquadradic tetrahedron */
320 switch (info) { /* select type of information required */
321 case NNODES: answer = 14; break;
322 case NDIM: answer = 3; break;
323 case NN_SIDE: answer = 7; break;
324 default: fmt::print(stderr, "{}ERROR: Unknown quantity.\n", __func__); exit(1);
325 }
326 break;
327
328 case TET15: /* triquadradic tetrahedron */
329 switch (info) { /* select type of information required */
330 case NNODES: answer = 15; break;
331 case NDIM: answer = 3; break;
332 case NN_SIDE: answer = 7; break;
333 default: fmt::print(stderr, "{}ERROR: Unknown quantity.\n", __func__); exit(1);
334 }
335 break;
336
337 case TET8: /* triquadradic tetrahedron */
338 switch (info) { /* select type of information required */
339 case NNODES: answer = 8; break;
340 case NDIM: answer = 3; break;
341 case NN_SIDE: answer = 4; break;
342 default: fmt::print(stderr, "{}ERROR: Unknown quantity.\n", __func__); exit(1);
343 }
344 break;
345
346 case WEDGE6:
347 switch (info) {
348 case NNODES: answer = 6; break;
349 case NDIM: answer = 3; break;
350 case NN_SIDE:
351 switch (supp) {
352 case 4:
353 case 5: answer = 3; break;
354 default: answer = 4; break;
355 }
356 break;
357
358 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
359 }
360 break;
361
362 case WEDGE12:
363 switch (info) {
364 case NNODES: answer = 12; break;
365 case NDIM: answer = 3; break;
366 case NN_SIDE: answer = 6; break;
367 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
368 }
369 break;
370
371 case WEDGE16:
372 switch (info) {
373 case NNODES: answer = 16; break;
374 case NDIM: answer = 3; break;
375 case NN_SIDE:
376 switch (supp) {
377 case 4:
378 case 5: answer = 6; break;
379 default: answer = 8; break;
380 }
381 break;
382
383 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
384 }
385 break;
386
387 case WEDGE15:
388 switch (info) {
389 case NNODES: answer = 15; break;
390 case NDIM: answer = 3; break;
391 case NN_SIDE:
392 switch (supp) {
393 case 4:
394 case 5: answer = 6; break;
395
396 default: answer = 8; break;
397 }
398 break;
399
400 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
401 }
402 break;
403
404 case WEDGE20:
405 switch (info) {
406 case NNODES: answer = 20; break;
407 case NDIM: answer = 3; break;
408 case NN_SIDE:
409 switch (supp) {
410 case 4:
411 case 5: answer = 7; break;
412
413 default: answer = 9; break;
414 }
415 break;
416
417 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
418 }
419 break;
420
421 case WEDGE21:
422 switch (info) {
423 case NNODES: answer = 21; break;
424 case NDIM: answer = 3; break;
425 case NN_SIDE:
426 switch (supp) {
427 case 4:
428 case 5: answer = 7; break;
429
430 default: answer = 9; break;
431 }
432 break;
433
434 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
435 }
436 break;
437
438 case HEXSHELL:
439 switch (info) {
440 case NNODES: answer = 12; break;
441 case NDIM: answer = 3; break;
442 case NN_SIDE:
443 switch (supp) {
444 case 5:
445 case 6: answer = 4; break;
446 default: answer = 6; break;
447 }
448 break;
449
450 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
451 }
452 break;
453
454 case PYRAMID5:
455 switch (info) {
456 case NNODES: answer = 5; break;
457 case NDIM: answer = 3; break;
458 case NN_SIDE:
459 switch (supp) {
460 case 5: answer = 4; break;
461 default: answer = 3; break;
462 }
463 break;
464
465 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
466 }
467 break;
468
469 case PYRAMID13:
470 switch (info) {
471 case NNODES: answer = 13; break;
472 case NDIM: answer = 3; break;
473 case NN_SIDE:
474 switch (supp) {
475 case 5: answer = 8; break;
476 default: answer = 6; break;
477 }
478 break;
479
480 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
481 }
482 break;
483
484 case PYRAMID14:
485 switch (info) {
486 case NNODES: answer = 14; break;
487 case NDIM: answer = 3; break;
488 case NN_SIDE:
489 switch (supp) {
490 case 5: answer = 9; break;
491 default: answer = 6; break;
492 }
493 break;
494
495 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
496 }
497 break;
498
499 case PYRAMID18:
500 switch (info) {
501 case NNODES: answer = 18; break;
502 case NDIM: answer = 3; break;
503 case NN_SIDE:
504 switch (supp) {
505 case 5: answer = 9; break;
506 default: answer = 7; break;
507 }
508 break;
509
510 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
511 }
512 break;
513
514 case PYRAMID19:
515 switch (info) {
516 case NNODES: answer = 19; break;
517 case NDIM: answer = 3; break;
518 case NN_SIDE:
519 switch (supp) {
520 case 5: answer = 9; break;
521 default: answer = 7; break;
522 }
523 break;
524
525 default: fmt::print(stderr, "{}ERROR: Unknown quantity\n", __func__); exit(1);
526 }
527 break;
528
529 default: fmt::print(stderr, "{}ERROR: Unimplemented element type.\n", __func__); exit(1);
530 }
531
532 return answer;
533
534 } /* elem_info */
535
536 /*****************************************************************************/
537 /*****************************************************************************/
538 /*****************************************************************************/
539
540 /*****************************************************************************/
541 /*****************************************************************************/
542 /*****************************************************************************/
543
544 int get_type(const char string[], int nodes, int num_dim)
545
546 /*
547 * Function which returns the element type according to this analysis code
548 * based on the EXODUS element type string and the number of nodes in the
549 * element.
550 *
551 * Author: Scott Hutchinson (1421)
552 * Date: 29 June 1992
553 */
554
555 {
556
557 int answer = 0;
558
559 /* Precondition: string is lower case */
560 switch (string[0]) {
561 case 'q':
562
563 if (strncmp(string, "quad", 4) == 0) { /* select element shape */
564 switch (nodes) { /* select number of nodes in this element */
565 case 4: /* bilinear quadralateral */ answer = QUAD4; break;
566 case 8: /* serendipity biquadratic quadralateral */ answer = QUAD8; break;
567 case 9: /* biquadratic quadrilateral */ answer = QUAD9; break;
568 default:
569 fmt::print(stderr,
570 "{}ERROR: Quadrilateral element with {} nodes "
571 "not valid.\n",
572 __func__, nodes);
573 exit(1);
574 }
575 }
576 break;
577
578 case 's':
579 if (strncmp(string, "sphere", 6) == 0) {
580 answer = SPHERE;
581 }
582 else if (strncmp(string, "shell", 5) == 0) {
583 switch (nodes) {
584 case 2:
585 if (num_dim == 2) {
586 answer = SHELL2;
587 }
588 else {
589 fmt::print(stderr,
590 "{}ERROR: Shell element with {} nodes "
591 "only valid in 2D.\n",
592 __func__, nodes);
593 exit(1);
594 }
595 break;
596 case 3:
597 if (num_dim == 2) {
598 answer = SHELL3;
599 }
600 else {
601 fmt::print(stderr,
602 "{}ERROR: Shell element with {} nodes "
603 "only valid in 2D.\n",
604 __func__, nodes);
605 exit(1);
606 }
607 break;
608 case 4: answer = SHELL4; break;
609 case 8: answer = SHELL8; break;
610 case 9: answer = SHELL9; break;
611 default:
612 fmt::print(stderr, "{}ERROR: Shell element with {} nodes unknown.\n", __func__, nodes);
613 exit(1);
614 }
615 }
616 break;
617
618 case 'c':
619 if (strncmp(string, "circle", 6) == 0) {
620 answer = SPHERE;
621 }
622 break;
623
624 case 'b':
625 case 't':
626 case 'r':
627 if (strncmp(string, "bar", 3) == 0 || strncmp(string, "beam", 4) == 0 ||
628 strncmp(string, "rod", 3) == 0 || strncmp(string, "truss", 5) == 0) {
629 switch (nodes) {
630 case 2: answer = BAR2; break;
631 case 3: answer = BAR3; break;
632 default:
633 fmt::print(stderr, "{}ERROR: Bar/beam/truss elements with {} nodes unknown.\n", __func__,
634 nodes);
635 exit(1);
636 }
637 }
638 else if (strncmp(string, "tri", 3) == 0) { /* select element shape */
639 switch (nodes) { /* select number of nodes in this element */
640 case 3: /* bilinear triangle */
641 if (num_dim == 2) {
642 answer = TRI3;
643 }
644 else {
645 answer = TSHELL3;
646 }
647 break;
648 case 4: /* bilinear triangle */
649 if (num_dim == 2) {
650 answer = TRI4;
651 }
652 else {
653 answer = TSHELL4;
654 }
655 break;
656 case 6: /* biquadratic triangle */
657 if (num_dim == 2) {
658 answer = TRI6;
659 }
660 else {
661 answer = TSHELL6;
662 }
663 break;
664 case 7: /* biquadratic triangle */
665 if (num_dim == 2) {
666 answer = TRI7;
667 }
668 else {
669 answer = TSHELL7;
670 }
671 break;
672 default:
673 if (num_dim == 2) {
674 fmt::print(stderr, "{}ERROR: triangle element with {} nodes not valid.\n", __func__,
675 nodes);
676 }
677 else {
678 fmt::print(stderr, "{}ERROR: triangle shell element with {} nodes not valid.\n", __func__,
679 nodes);
680 }
681 exit(1);
682 }
683 }
684
685 else if (strncmp(string, "tet", 3) == 0) { /* select element shape */
686 switch (nodes) { /* select number of nodes in this element */
687 case 4: /* trilinear tetrahedron */ answer = TET4; break;
688 case 8: /* 8-node (mid-face) tetrahedron */ answer = TET8; break;
689 case 10: /* triquadratic tetrahedron */ answer = TET10; break;
690 default:
691 fmt::print(stderr, "{}ERROR: tetrahedral element with {} nodes not valid.\n", __func__,
692 nodes);
693 exit(1);
694 }
695 }
696
697 break;
698
699 case 'h':
700 /* must check for this before checking for HEX */
701 if (strncmp(string, "hexshell", 8) == 0) { /* select element shape */
702 switch (nodes) { /* select number of nodes in this element */
703 case 12: /* only one hexshell */ answer = HEXSHELL; break;
704 default:
705 fmt::print(stderr, "{}ERROR: hexshell element with {} nodes not valid.\n", __func__, nodes);
706 exit(1);
707 }
708 }
709
710 else if (strncmp(string, "hex", 3) == 0) { /* select element shape */
711 switch (nodes) { /* select number of nodes in this element */
712 case 8: /* trilinear hexahedron */ answer = HEX8; break;
713 case 16: /* localization element */ answer = HEX16; break;
714 case 20: /* serendipity triquadratic hexahedron */ answer = HEX20; break;
715 case 27: /* triquadratic hexahedron */ answer = HEX27; break;
716 default:
717 fmt::print(stderr, "{}ERROR: Hexahedron element with {} nodes not valid.\n", __func__,
718 nodes);
719 exit(1);
720 }
721 }
722 break;
723
724 case 'p':
725 if (strncmp(string, "pyra", 4) == 0) { /* select element shape */
726 switch (nodes) { /* select number of nodes in this element */
727 case 5: answer = PYRAMID5; break;
728 case 13: answer = PYRAMID13; break;
729 case 14: answer = PYRAMID14; break;
730 case 18: answer = PYRAMID18; break;
731 case 19: answer = PYRAMID19; break;
732 default:
733 fmt::print(stderr, "{}ERROR: pyramid element with {} nodes not valid.\n", __func__, nodes);
734 exit(1);
735 }
736 }
737 break;
738
739 case 'w':
740 if (strncmp(string, "wedge", 5) == 0) { /* select element shape */
741 switch (nodes) { /* select number of nodes in this element */
742 case 6: /* trilinear wedge */ answer = WEDGE6; break;
743 case 12: /* localization element */ answer = WEDGE12; break;
744 case 15: /* triquadratic wedge */ answer = WEDGE15; break;
745 case 16: /* triquadratic wedge */ answer = WEDGE16; break;
746 default:
747 fmt::print(stderr, "{}ERROR: wedge element with {} nodes not valid.\n", __func__, nodes);
748 exit(1);
749 }
750 }
751 break;
752
753 default:
754 fmt::print(stderr, "{}ERROR: Element type {} not supported!\n", __func__, string);
755 exit(1);
756 }
757 /* return desired element information */
758 return answer;
759
760 } /* get_type */
761
762 /*****************************************************************************/
763 /* END of el_elm_info.c */
764 /*****************************************************************************/