Line data Source code
1 : // The libMesh Finite Element Library.
2 : // Copyright (C) 2002-2025 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
3 :
4 : // This library is free software; you can redistribute it and/or
5 : // modify it under the terms of the GNU Lesser General Public
6 : // License as published by the Free Software Foundation; either
7 : // version 2.1 of the License, or (at your option) any later version.
8 :
9 : // This library is distributed in the hope that it will be useful,
10 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 : // Lesser General Public License for more details.
13 :
14 : // You should have received a copy of the GNU Lesser General Public
15 : // License along with this library; if not, write to the Free Software
16 : // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 :
18 :
19 :
20 : // Local includes
21 : #include "libmesh/libmesh_config.h"
22 :
23 : #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
24 :
25 : #include "libmesh/fe_interface.h"
26 : #include "libmesh/fe_interface_macros.h"
27 : #include "libmesh/inf_fe.h"
28 : #include "libmesh/elem.h"
29 : #include "libmesh/enum_to_string.h"
30 :
31 : namespace libMesh
32 : {
33 :
34 : //------------------------------------------------------------
35 : //FEInterface class members handling calls to InfFE
36 :
37 :
38 :
39 : #ifdef LIBMESH_ENABLE_DEPRECATED
40 0 : unsigned int FEInterface::ifem_n_shape_functions(const unsigned int dim,
41 : const FEType & fe_t,
42 : const ElemType t)
43 : {
44 : libmesh_deprecated();
45 :
46 0 : switch (dim)
47 : {
48 : // 1D
49 0 : case 1:
50 : /*
51 : * Since InfFE<Dim,T_radial,T_map>::n_shape_functions(...)
52 : * is actually independent of T_radial and T_map, we can use
53 : * just any T_radial and T_map
54 : */
55 0 : return InfFE<1,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
56 :
57 : // 2D
58 0 : case 2:
59 0 : return InfFE<2,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
60 :
61 : // 3D
62 0 : case 3:
63 0 : return InfFE<3,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
64 :
65 0 : default:
66 0 : libmesh_error_msg("Unsupported dim = " << dim);
67 : }
68 : }
69 : #endif // LIBMESH_ENABLE_DEPRECATED
70 :
71 :
72 :
73 0 : unsigned int FEInterface::ifem_n_shape_functions(const FEType & fe_t,
74 : const Elem * elem)
75 : {
76 0 : switch (elem->dim())
77 : {
78 : // 1D
79 0 : case 1:
80 : /*
81 : * Since InfFE<Dim,T_radial,T_map>::n_shape_functions(...)
82 : * is actually independent of T_radial and T_map, we can use
83 : * just any T_radial and T_map
84 : */
85 0 : return InfFE<1,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, elem);
86 :
87 : // 2D
88 0 : case 2:
89 0 : return InfFE<2,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, elem);
90 :
91 : // 3D
92 0 : case 3:
93 0 : return InfFE<3,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, elem);
94 :
95 0 : default:
96 0 : libmesh_error_msg("Unsupported dim = " << elem->dim());
97 : }
98 : }
99 :
100 :
101 :
102 : #ifdef LIBMESH_ENABLE_DEPRECATED
103 0 : unsigned int FEInterface::ifem_n_dofs(const unsigned int dim,
104 : const FEType & fe_t,
105 : const ElemType t)
106 : {
107 : libmesh_deprecated();
108 :
109 0 : switch (dim)
110 : {
111 : // 1D
112 0 : case 1:
113 : /*
114 : * Since InfFE<Dim,T_radial,T_map>::n_dofs(...)
115 : * is actually independent of T_radial and T_map, we can use
116 : * just any T_radial and T_map
117 : */
118 0 : return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
119 :
120 : // 2D
121 0 : case 2:
122 0 : return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
123 :
124 : // 3D
125 0 : case 3:
126 0 : return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
127 :
128 0 : default:
129 0 : libmesh_error_msg("Unsupported dim = " << dim);
130 : }
131 : }
132 : #endif // LIBMESH_ENABLE_DEPRECATED
133 :
134 :
135 :
136 : unsigned int
137 227358 : FEInterface::ifem_n_dofs(const FEType & fe_t,
138 : const Elem * elem)
139 : {
140 227358 : switch (elem->dim())
141 : {
142 : // 1D
143 0 : case 1:
144 : /*
145 : * Since InfFE<Dim,T_radial,T_map>::n_dofs(...)
146 : * is actually independent of T_radial and T_map, we can use
147 : * just any T_radial and T_map
148 : */
149 0 : return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, elem);
150 :
151 : // 2D
152 0 : case 2:
153 0 : return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, elem);
154 :
155 : // 3D
156 227358 : case 3:
157 227358 : return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, elem);
158 :
159 0 : default:
160 0 : libmesh_error_msg("Unsupported dim = " << elem->dim());
161 : }
162 : }
163 :
164 :
165 :
166 : #ifdef LIBMESH_ENABLE_DEPRECATED
167 0 : unsigned int FEInterface::ifem_n_dofs_at_node(const unsigned int dim,
168 : const FEType & fe_t,
169 : const ElemType t,
170 : const unsigned int n)
171 : {
172 : libmesh_deprecated();
173 :
174 0 : switch (dim)
175 : {
176 : // 1D
177 0 : case 1:
178 : /*
179 : * Since InfFE<Dim,T_radial,T_map>::n_dofs_at_node(...)
180 : * is actually independent of T_radial and T_map, we can use
181 : * just any T_radial and T_map
182 : */
183 0 : return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
184 :
185 : // 2D
186 0 : case 2:
187 0 : return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
188 :
189 : // 3D
190 0 : case 3:
191 0 : return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
192 :
193 0 : default:
194 0 : libmesh_error_msg("Unsupported dim = " << dim);
195 : }
196 : }
197 : #endif // LIBMESH_ENABLE_DEPRECATED
198 :
199 :
200 :
201 259000 : unsigned int FEInterface::ifem_n_dofs_at_node(const FEType & fe_t,
202 : const Elem * elem,
203 : const unsigned int n)
204 : {
205 259000 : switch (elem->dim())
206 : {
207 : // 1D
208 0 : case 1:
209 : /*
210 : * Since InfFE<Dim,T_radial,T_map>::n_dofs_at_node(...)
211 : * is actually independent of T_radial and T_map, we can use
212 : * just any T_radial and T_map
213 : */
214 0 : return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, elem, n);
215 :
216 : // 2D
217 0 : case 2:
218 0 : return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, elem, n);
219 :
220 : // 3D
221 259000 : case 3:
222 259000 : return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, elem, n);
223 :
224 0 : default:
225 0 : libmesh_error_msg("Unsupported dim = " << elem->dim());
226 : }
227 : }
228 :
229 :
230 :
231 :
232 :
233 : #ifdef LIBMESH_ENABLE_DEPRECATED
234 0 : unsigned int FEInterface::ifem_n_dofs_per_elem(const unsigned int dim,
235 : const FEType & fe_t,
236 : const ElemType t)
237 : {
238 : libmesh_deprecated();
239 :
240 0 : switch (dim)
241 : {
242 : // 1D
243 0 : case 1:
244 : /*
245 : * Since InfFE<Dim,T_radial,T_map>::n_dofs(...)
246 : * is actually independent of T_radial and T_map, we can use
247 : * just any T_radial and T_map
248 : */
249 0 : return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
250 :
251 : // 2D
252 0 : case 2:
253 0 : return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
254 :
255 : // 3D
256 0 : case 3:
257 0 : return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
258 :
259 0 : default:
260 0 : libmesh_error_msg("Unsupported dim = " << dim);
261 : }
262 : }
263 : #endif // LIBMESH_ENABLE_DEPRECATED
264 :
265 :
266 :
267 22806 : unsigned int FEInterface::ifem_n_dofs_per_elem(const FEType & fe_t,
268 : const Elem * elem)
269 : {
270 22806 : switch (elem->dim())
271 : {
272 : // 1D
273 0 : case 1:
274 : /*
275 : * Since InfFE<Dim,T_radial,T_map>::n_dofs(...)
276 : * is actually independent of T_radial and T_map, we can use
277 : * just any T_radial and T_map
278 : */
279 0 : return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, elem);
280 :
281 : // 2D
282 0 : case 2:
283 0 : return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, elem);
284 :
285 : // 3D
286 22806 : case 3:
287 22806 : return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, elem);
288 :
289 0 : default:
290 0 : libmesh_error_msg("Unsupported dim = " << elem->dim());
291 : }
292 : }
293 :
294 :
295 :
296 :
297 0 : void FEInterface::ifem_nodal_soln(const unsigned int dim,
298 : const FEType & fe_t,
299 : const Elem * elem,
300 : const std::vector<Number> & elem_soln,
301 : std::vector<Number> & nodal_soln)
302 : {
303 0 : switch (dim)
304 : {
305 :
306 : // 1D
307 0 : case 1:
308 : {
309 0 : switch (fe_t.radial_family)
310 : {
311 0 : case INFINITE_MAP:
312 0 : libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
313 :
314 0 : case JACOBI_20_00:
315 : {
316 0 : switch (fe_t.inf_map)
317 : {
318 0 : case CARTESIAN:
319 : {
320 0 : InfFE<1,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
321 0 : break;
322 : }
323 0 : default:
324 0 : libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
325 : }
326 0 : break;
327 : }
328 :
329 0 : case JACOBI_30_00:
330 : {
331 0 : switch (fe_t.inf_map)
332 : {
333 0 : case CARTESIAN:
334 : {
335 0 : InfFE<1,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
336 0 : break;
337 : }
338 0 : default:
339 0 : libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
340 : }
341 0 : break;
342 : }
343 :
344 0 : case LEGENDRE:
345 : {
346 0 : switch (fe_t.inf_map)
347 : {
348 0 : case CARTESIAN:
349 : {
350 0 : InfFE<1,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
351 0 : break;
352 : }
353 0 : default:
354 0 : libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
355 : }
356 0 : break;
357 : }
358 :
359 0 : case LAGRANGE:
360 : {
361 0 : switch (fe_t.inf_map)
362 : {
363 0 : case CARTESIAN:
364 : {
365 0 : InfFE<1,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
366 0 : break;
367 : }
368 0 : default:
369 0 : libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
370 : }
371 0 : break;
372 : }
373 :
374 0 : default:
375 0 : libmesh_error_msg("ERROR: Bad FEType.radial_family == " << Utility::enum_to_string(fe_t.radial_family));
376 : }
377 :
378 0 : break;
379 : }
380 :
381 :
382 :
383 :
384 : // 2D
385 0 : case 2:
386 : {
387 0 : switch (fe_t.radial_family)
388 : {
389 0 : case INFINITE_MAP:
390 0 : libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
391 :
392 0 : case JACOBI_20_00:
393 : {
394 0 : switch (fe_t.inf_map)
395 : {
396 0 : case CARTESIAN:
397 : {
398 0 : InfFE<2,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
399 0 : break;
400 : }
401 0 : default:
402 0 : libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
403 : }
404 0 : break;
405 : }
406 :
407 0 : case JACOBI_30_00:
408 : {
409 0 : switch (fe_t.inf_map)
410 : {
411 0 : case CARTESIAN:
412 : {
413 0 : InfFE<2,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
414 0 : break;
415 : }
416 0 : default:
417 0 : libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
418 : }
419 0 : break;
420 : }
421 :
422 0 : case LEGENDRE:
423 : {
424 0 : switch (fe_t.inf_map)
425 : {
426 0 : case CARTESIAN:
427 : {
428 0 : InfFE<2,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
429 0 : break;
430 : }
431 0 : default:
432 0 : libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
433 : }
434 0 : break;
435 : }
436 :
437 0 : case LAGRANGE:
438 : {
439 0 : switch (fe_t.inf_map)
440 : {
441 0 : case CARTESIAN:
442 : {
443 0 : InfFE<2,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
444 0 : break;
445 : }
446 0 : default:
447 0 : libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
448 : }
449 0 : break;
450 : }
451 :
452 0 : default:
453 0 : libmesh_error_msg("ERROR: Bad FEType.radial_family == " << Utility::enum_to_string(fe_t.radial_family));
454 : }
455 :
456 0 : break;
457 : }
458 :
459 :
460 :
461 :
462 : // 3D
463 0 : case 3:
464 : {
465 0 : switch (fe_t.radial_family)
466 : {
467 0 : case INFINITE_MAP:
468 0 : libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
469 :
470 0 : case JACOBI_20_00:
471 : {
472 0 : switch (fe_t.inf_map)
473 : {
474 0 : case CARTESIAN:
475 : {
476 0 : InfFE<3,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
477 0 : break;
478 : }
479 0 : default:
480 0 : libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
481 : }
482 0 : break;
483 : }
484 :
485 0 : case JACOBI_30_00:
486 : {
487 0 : switch (fe_t.inf_map)
488 : {
489 0 : case CARTESIAN:
490 : {
491 0 : InfFE<3,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
492 0 : break;
493 : }
494 0 : default:
495 0 : libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
496 : }
497 0 : break;
498 : }
499 :
500 0 : case LEGENDRE:
501 : {
502 0 : switch (fe_t.inf_map)
503 : {
504 0 : case CARTESIAN:
505 : {
506 0 : InfFE<3,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
507 0 : break;
508 : }
509 0 : default:
510 0 : libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
511 : }
512 0 : break;
513 : }
514 :
515 0 : case LAGRANGE:
516 : {
517 0 : switch (fe_t.inf_map)
518 : {
519 0 : case CARTESIAN:
520 : {
521 0 : InfFE<3,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
522 0 : break;
523 : }
524 0 : default:
525 0 : libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
526 : }
527 0 : break;
528 : }
529 :
530 :
531 :
532 0 : default:
533 0 : libmesh_error_msg("ERROR: Bad FEType.radial_family == " << Utility::enum_to_string(fe_t.radial_family));
534 : }
535 :
536 0 : break;
537 : }
538 :
539 0 : default:
540 0 : libmesh_error_msg("Invalid dim = " << dim);
541 : }
542 0 : }
543 :
544 :
545 :
546 :
547 0 : Point FEInterface::ifem_map (const unsigned int dim,
548 : const FEType & fe_t,
549 : const Elem * elem,
550 : const Point & p)
551 : {
552 0 : switch (fe_t.inf_map)
553 : {
554 0 : case CARTESIAN:
555 : {
556 0 : switch (dim)
557 : {
558 0 : case 1:
559 0 : return InfFE<1,JACOBI_20_00,CARTESIAN>::map(elem, p);
560 0 : case 2:
561 0 : return InfFE<2,JACOBI_20_00,CARTESIAN>::map(elem, p);
562 0 : case 3:
563 0 : return InfFE<3,JACOBI_20_00,CARTESIAN>::map(elem, p);
564 0 : default:
565 0 : libmesh_error_msg("Invalid dim = " << dim);
566 : }
567 : }
568 0 : case SPHERICAL:
569 : case ELLIPSOIDAL:
570 0 : libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
571 0 : default:
572 0 : libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
573 : }
574 : }
575 :
576 :
577 :
578 0 : Point FEInterface::ifem_inverse_map (const unsigned int dim,
579 : const FEType & fe_t,
580 : const Elem * elem,
581 : const Point & p,
582 : const Real tolerance,
583 : const bool secure)
584 : {
585 0 : switch (dim)
586 : {
587 : // 1D
588 0 : case 1:
589 : {
590 0 : switch (fe_t.inf_map)
591 : {
592 0 : case CARTESIAN:
593 0 : return InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
594 :
595 0 : case SPHERICAL:
596 : case ELLIPSOIDAL:
597 0 : libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
598 :
599 : /*
600 : case SPHERICAL:
601 : return InfFE<1,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance);
602 :
603 : case ELLIPSOIDAL:
604 : return InfFE<1,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance);
605 : */
606 :
607 0 : default:
608 0 : libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
609 : }
610 : }
611 :
612 :
613 : // 2D
614 0 : case 2:
615 : {
616 0 : switch (fe_t.inf_map)
617 : {
618 0 : case CARTESIAN:
619 0 : return InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
620 :
621 0 : case SPHERICAL:
622 : case ELLIPSOIDAL:
623 0 : libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
624 :
625 : /*
626 : case SPHERICAL:
627 : return InfFE<2,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance);
628 :
629 : case ELLIPSOIDAL:
630 : return InfFE<2,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance);
631 : */
632 :
633 0 : default:
634 0 : libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
635 : }
636 : }
637 :
638 :
639 : // 3D
640 0 : case 3:
641 : {
642 0 : switch (fe_t.inf_map)
643 : {
644 0 : case CARTESIAN:
645 0 : return InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
646 :
647 0 : case SPHERICAL:
648 : case ELLIPSOIDAL:
649 0 : libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
650 :
651 : /*
652 : case SPHERICAL:
653 : return InfFE<3,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance);
654 :
655 : case ELLIPSOIDAL:
656 : return InfFE<3,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance);
657 : */
658 :
659 0 : default:
660 0 : libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
661 : }
662 : }
663 :
664 0 : default:
665 0 : libmesh_error_msg("Invalid dim = " << dim);
666 : }
667 : }
668 :
669 :
670 :
671 0 : void FEInterface::ifem_inverse_map (const unsigned int dim,
672 : const FEType & fe_t,
673 : const Elem * elem,
674 : const std::vector<Point> & physical_points,
675 : std::vector<Point> & reference_points,
676 : const Real tolerance,
677 : const bool secure)
678 : {
679 0 : switch (dim)
680 : {
681 : // 1D
682 0 : case 1:
683 : {
684 0 : switch (fe_t.inf_map)
685 : {
686 0 : case CARTESIAN:
687 0 : InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
688 0 : return;
689 :
690 0 : default:
691 0 : libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
692 : }
693 : }
694 :
695 :
696 : // 2D
697 0 : case 2:
698 : {
699 0 : switch (fe_t.inf_map)
700 : {
701 0 : case CARTESIAN:
702 0 : InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
703 0 : return;
704 :
705 0 : default:
706 0 : libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
707 : }
708 : }
709 :
710 :
711 : // 3D
712 0 : case 3:
713 : {
714 0 : switch (fe_t.inf_map)
715 : {
716 0 : case CARTESIAN:
717 0 : InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
718 0 : return;
719 :
720 0 : default:
721 0 : libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
722 : }
723 : }
724 :
725 0 : default:
726 0 : libmesh_error_msg("Invalid dim = " << dim);
727 : }
728 : }
729 :
730 :
731 :
732 : #ifdef LIBMESH_ENABLE_DEPRECATED
733 0 : bool FEInterface::ifem_on_reference_element(const Point & p,
734 : const ElemType t,
735 : const Real eps)
736 : {
737 0 : return FEBase::on_reference_element(p,t,eps);
738 : }
739 :
740 :
741 :
742 0 : Real FEInterface::ifem_shape(const unsigned int dim,
743 : const FEType & fe_t,
744 : const ElemType t,
745 : const unsigned int i,
746 : const Point & p)
747 : {
748 : libmesh_deprecated();
749 :
750 0 : inf_fe_switch(shape(fe_t, t, i, p));
751 : }
752 :
753 :
754 :
755 0 : Real FEInterface::ifem_shape(const unsigned int dim,
756 : const FEType & fe_t,
757 : const Elem * elem,
758 : const unsigned int i,
759 : const Point & p)
760 : {
761 : libmesh_deprecated();
762 :
763 0 : inf_fe_switch( shape(fe_t, elem, i, p));
764 : }
765 : #endif // LIBMESH_ENABLE_DEPRECATED
766 :
767 :
768 :
769 0 : Real FEInterface::ifem_shape(const FEType & fe_t,
770 : const Elem * elem,
771 : const unsigned int i,
772 : const Point & p)
773 : {
774 : // The inf_fe_switch macro requires a "dim" parameter.
775 0 : auto dim = elem->dim();
776 :
777 0 : inf_fe_switch( shape(fe_t, elem, i, p));
778 : }
779 :
780 :
781 :
782 : #ifdef LIBMESH_ENABLE_DEPRECATED
783 0 : Real FEInterface::ifem_shape_deriv (const unsigned int dim,
784 : const FEType & fe_t,
785 : const Elem * elem,
786 : const unsigned int i,
787 : const unsigned int j,
788 : const Point & p)
789 : {
790 : libmesh_deprecated();
791 :
792 0 : inf_fe_switch(shape_deriv(fe_t, elem, i, j, p));
793 : }
794 :
795 :
796 :
797 0 : Real FEInterface::ifem_shape_deriv(const unsigned int dim,
798 : const FEType & fe_t,
799 : const ElemType t,
800 : const unsigned int i,
801 : const unsigned int j,
802 : const Point & p)
803 : {
804 : libmesh_deprecated();
805 :
806 0 : inf_fe_switch(shape_deriv(fe_t, t, i, j, p));
807 : }
808 : #endif // LIBMESH_ENABLE_DEPRECATED
809 :
810 :
811 :
812 0 : Real FEInterface::ifem_shape_deriv (const FEType & fe_t,
813 : const Elem * elem,
814 : const unsigned int i,
815 : const unsigned int j,
816 : const Point & p)
817 : {
818 : // The inf_fe_switch macro requires a "dim" parameter.
819 0 : auto dim = elem->dim();
820 :
821 0 : inf_fe_switch(shape_deriv(fe_t, elem, i, j, p));
822 : }
823 :
824 :
825 0 : void FEInterface::ifem_compute_data(const unsigned int dim,
826 : const FEType & fe_t,
827 : const Elem * elem,
828 : FEComputeData & data)
829 : {
830 0 : switch (dim)
831 : {
832 0 : case 1:
833 : {
834 0 : inf_fe_family_mapping_switch(1, compute_data(fe_t, elem,data), , ;break;);
835 0 : break;
836 : }
837 0 : case 2:
838 : {
839 0 : inf_fe_family_mapping_switch(2, compute_data(fe_t, elem,data), , ;break;);
840 0 : break;
841 : }
842 0 : case 3:
843 : {
844 0 : inf_fe_family_mapping_switch(3, compute_data(fe_t, elem,data), , ;break;);
845 0 : break;
846 : }
847 :
848 :
849 0 : default:
850 0 : libmesh_error_msg("Invalid dim = " << dim);
851 : break;
852 : }
853 0 : }
854 :
855 : } // namespace libMesh
856 :
857 : #endif // ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
|
