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