libMesh
fe_interface_inf_fe.C
Go to the documentation of this file.
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 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  switch (dim)
47  {
48  // 1D
49  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  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
56 
57  // 2D
58  case 2:
59  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
60 
61  // 3D
62  case 3:
63  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
64 
65  default:
66  libmesh_error_msg("Unsupported dim = " << dim);
67  }
68 }
69 #endif // LIBMESH_ENABLE_DEPRECATED
70 
71 
72 
73 unsigned int FEInterface::ifem_n_shape_functions(const FEType & fe_t,
74  const Elem * elem)
75 {
76  switch (elem->dim())
77  {
78  // 1D
79  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  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, elem);
86 
87  // 2D
88  case 2:
89  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, elem);
90 
91  // 3D
92  case 3:
93  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, elem);
94 
95  default:
96  libmesh_error_msg("Unsupported dim = " << elem->dim());
97  }
98 }
99 
100 
101 
102 #ifdef LIBMESH_ENABLE_DEPRECATED
103 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  switch (dim)
110  {
111  // 1D
112  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  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
119 
120  // 2D
121  case 2:
122  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
123 
124  // 3D
125  case 3:
126  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
127 
128  default:
129  libmesh_error_msg("Unsupported dim = " << dim);
130  }
131 }
132 #endif // LIBMESH_ENABLE_DEPRECATED
133 
134 
135 
136 unsigned int
137 FEInterface::ifem_n_dofs(const FEType & fe_t,
138  const Elem * elem)
139 {
140  switch (elem->dim())
141  {
142  // 1D
143  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  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, elem);
150 
151  // 2D
152  case 2:
153  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, elem);
154 
155  // 3D
156  case 3:
157  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, elem);
158 
159  default:
160  libmesh_error_msg("Unsupported dim = " << elem->dim());
161  }
162 }
163 
164 
165 
166 #ifdef LIBMESH_ENABLE_DEPRECATED
167 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  switch (dim)
175  {
176  // 1D
177  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  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
184 
185  // 2D
186  case 2:
187  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
188 
189  // 3D
190  case 3:
191  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
192 
193  default:
194  libmesh_error_msg("Unsupported dim = " << dim);
195  }
196 }
197 #endif // LIBMESH_ENABLE_DEPRECATED
198 
199 
200 
201 unsigned int FEInterface::ifem_n_dofs_at_node(const FEType & fe_t,
202  const Elem * elem,
203  const unsigned int n)
204 {
205  switch (elem->dim())
206  {
207  // 1D
208  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  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, elem, n);
215 
216  // 2D
217  case 2:
218  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, elem, n);
219 
220  // 3D
221  case 3:
222  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, elem, n);
223 
224  default:
225  libmesh_error_msg("Unsupported dim = " << elem->dim());
226  }
227 }
228 
229 
230 
231 
232 
233 #ifdef LIBMESH_ENABLE_DEPRECATED
234 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  switch (dim)
241  {
242  // 1D
243  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  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
250 
251  // 2D
252  case 2:
253  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
254 
255  // 3D
256  case 3:
257  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
258 
259  default:
260  libmesh_error_msg("Unsupported dim = " << dim);
261  }
262 }
263 #endif // LIBMESH_ENABLE_DEPRECATED
264 
265 
266 
267 unsigned int FEInterface::ifem_n_dofs_per_elem(const FEType & fe_t,
268  const Elem * elem)
269 {
270  switch (elem->dim())
271  {
272  // 1D
273  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  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, elem);
280 
281  // 2D
282  case 2:
283  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, elem);
284 
285  // 3D
286  case 3:
287  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, elem);
288 
289  default:
290  libmesh_error_msg("Unsupported dim = " << elem->dim());
291  }
292 }
293 
294 
295 
296 
297 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  switch (dim)
304  {
305 
306  // 1D
307  case 1:
308  {
309  switch (fe_t.radial_family)
310  {
311  case INFINITE_MAP:
312  libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
313 
314  case JACOBI_20_00:
315  {
316  switch (fe_t.inf_map)
317  {
318  case CARTESIAN:
319  {
320  InfFE<1,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
321  break;
322  }
323  default:
324  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
325  }
326  break;
327  }
328 
329  case JACOBI_30_00:
330  {
331  switch (fe_t.inf_map)
332  {
333  case CARTESIAN:
334  {
335  InfFE<1,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
336  break;
337  }
338  default:
339  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
340  }
341  break;
342  }
343 
344  case LEGENDRE:
345  {
346  switch (fe_t.inf_map)
347  {
348  case CARTESIAN:
349  {
350  InfFE<1,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
351  break;
352  }
353  default:
354  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
355  }
356  break;
357  }
358 
359  case LAGRANGE:
360  {
361  switch (fe_t.inf_map)
362  {
363  case CARTESIAN:
364  {
365  InfFE<1,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
366  break;
367  }
368  default:
369  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
370  }
371  break;
372  }
373 
374  default:
375  libmesh_error_msg("ERROR: Bad FEType.radial_family == " << Utility::enum_to_string(fe_t.radial_family));
376  }
377 
378  break;
379  }
380 
381 
382 
383 
384  // 2D
385  case 2:
386  {
387  switch (fe_t.radial_family)
388  {
389  case INFINITE_MAP:
390  libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
391 
392  case JACOBI_20_00:
393  {
394  switch (fe_t.inf_map)
395  {
396  case CARTESIAN:
397  {
398  InfFE<2,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
399  break;
400  }
401  default:
402  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
403  }
404  break;
405  }
406 
407  case JACOBI_30_00:
408  {
409  switch (fe_t.inf_map)
410  {
411  case CARTESIAN:
412  {
413  InfFE<2,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
414  break;
415  }
416  default:
417  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
418  }
419  break;
420  }
421 
422  case LEGENDRE:
423  {
424  switch (fe_t.inf_map)
425  {
426  case CARTESIAN:
427  {
428  InfFE<2,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
429  break;
430  }
431  default:
432  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
433  }
434  break;
435  }
436 
437  case LAGRANGE:
438  {
439  switch (fe_t.inf_map)
440  {
441  case CARTESIAN:
442  {
443  InfFE<2,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
444  break;
445  }
446  default:
447  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
448  }
449  break;
450  }
451 
452  default:
453  libmesh_error_msg("ERROR: Bad FEType.radial_family == " << Utility::enum_to_string(fe_t.radial_family));
454  }
455 
456  break;
457  }
458 
459 
460 
461 
462  // 3D
463  case 3:
464  {
465  switch (fe_t.radial_family)
466  {
467  case INFINITE_MAP:
468  libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
469 
470  case JACOBI_20_00:
471  {
472  switch (fe_t.inf_map)
473  {
474  case CARTESIAN:
475  {
476  InfFE<3,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
477  break;
478  }
479  default:
480  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
481  }
482  break;
483  }
484 
485  case JACOBI_30_00:
486  {
487  switch (fe_t.inf_map)
488  {
489  case CARTESIAN:
490  {
491  InfFE<3,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
492  break;
493  }
494  default:
495  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
496  }
497  break;
498  }
499 
500  case LEGENDRE:
501  {
502  switch (fe_t.inf_map)
503  {
504  case CARTESIAN:
505  {
506  InfFE<3,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
507  break;
508  }
509  default:
510  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
511  }
512  break;
513  }
514 
515  case LAGRANGE:
516  {
517  switch (fe_t.inf_map)
518  {
519  case CARTESIAN:
520  {
521  InfFE<3,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
522  break;
523  }
524  default:
525  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
526  }
527  break;
528  }
529 
530 
531 
532  default:
533  libmesh_error_msg("ERROR: Bad FEType.radial_family == " << Utility::enum_to_string(fe_t.radial_family));
534  }
535 
536  break;
537  }
538 
539  default:
540  libmesh_error_msg("Invalid dim = " << dim);
541  }
542 }
543 
544 
545 
546 
547 Point FEInterface::ifem_map (const unsigned int dim,
548  const FEType & fe_t,
549  const Elem * elem,
550  const Point & p)
551 {
552  switch (fe_t.inf_map)
553  {
554  case CARTESIAN:
555  {
556  switch (dim)
557  {
558  case 1:
559  return InfFE<1,JACOBI_20_00,CARTESIAN>::map(elem, p);
560  case 2:
561  return InfFE<2,JACOBI_20_00,CARTESIAN>::map(elem, p);
562  case 3:
563  return InfFE<3,JACOBI_20_00,CARTESIAN>::map(elem, p);
564  default:
565  libmesh_error_msg("Invalid dim = " << dim);
566  }
567  }
568  case SPHERICAL:
569  case ELLIPSOIDAL:
570  libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
571  default:
572  libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
573  }
574 }
575 
576 
577 
578 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  switch (dim)
586  {
587  // 1D
588  case 1:
589  {
590  switch (fe_t.inf_map)
591  {
592  case CARTESIAN:
593  return InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
594 
595  case SPHERICAL:
596  case ELLIPSOIDAL:
597  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  default:
608  libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
609  }
610  }
611 
612 
613  // 2D
614  case 2:
615  {
616  switch (fe_t.inf_map)
617  {
618  case CARTESIAN:
619  return InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
620 
621  case SPHERICAL:
622  case ELLIPSOIDAL:
623  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  default:
634  libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
635  }
636  }
637 
638 
639  // 3D
640  case 3:
641  {
642  switch (fe_t.inf_map)
643  {
644  case CARTESIAN:
645  return InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
646 
647  case SPHERICAL:
648  case ELLIPSOIDAL:
649  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  default:
660  libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
661  }
662  }
663 
664  default:
665  libmesh_error_msg("Invalid dim = " << dim);
666  }
667 }
668 
669 
670 
671 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  switch (dim)
680  {
681  // 1D
682  case 1:
683  {
684  switch (fe_t.inf_map)
685  {
686  case CARTESIAN:
687  InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
688  return;
689 
690  default:
691  libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
692  }
693  }
694 
695 
696  // 2D
697  case 2:
698  {
699  switch (fe_t.inf_map)
700  {
701  case CARTESIAN:
702  InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
703  return;
704 
705  default:
706  libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
707  }
708  }
709 
710 
711  // 3D
712  case 3:
713  {
714  switch (fe_t.inf_map)
715  {
716  case CARTESIAN:
717  InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
718  return;
719 
720  default:
721  libmesh_error_msg("Invalid map = " << Utility::enum_to_string(fe_t.inf_map));
722  }
723  }
724 
725  default:
726  libmesh_error_msg("Invalid dim = " << dim);
727  }
728 }
729 
730 
731 
732 #ifdef LIBMESH_ENABLE_DEPRECATED
733 bool FEInterface::ifem_on_reference_element(const Point & p,
734  const ElemType t,
735  const Real eps)
736 {
737  return FEBase::on_reference_element(p,t,eps);
738 }
739 
740 
741 
742 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  inf_fe_switch(shape(fe_t, t, i, p));
751 }
752 
753 
754 
755 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  inf_fe_switch( shape(fe_t, elem, i, p));
764 }
765 #endif // LIBMESH_ENABLE_DEPRECATED
766 
767 
768 
769 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  auto dim = elem->dim();
776 
777  inf_fe_switch( shape(fe_t, elem, i, p));
778 }
779 
780 
781 
782 #ifdef LIBMESH_ENABLE_DEPRECATED
783 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  inf_fe_switch(shape_deriv(fe_t, elem, i, j, p));
793 }
794 
795 
796 
797 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  inf_fe_switch(shape_deriv(fe_t, t, i, j, p));
807 }
808 #endif // LIBMESH_ENABLE_DEPRECATED
809 
810 
811 
812 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  auto dim = elem->dim();
820 
821  inf_fe_switch(shape_deriv(fe_t, elem, i, j, p));
822 }
823 
824 
825 void FEInterface::ifem_compute_data(const unsigned int dim,
826  const FEType & fe_t,
827  const Elem * elem,
828  FEComputeData & data)
829 {
830  switch (dim)
831  {
832  case 1:
833  {
834  inf_fe_family_mapping_switch(1, compute_data(fe_t, elem,data), , ;break;);
835  break;
836  }
837  case 2:
838  {
839  inf_fe_family_mapping_switch(2, compute_data(fe_t, elem,data), , ;break;);
840  break;
841  }
842  case 3:
843  {
844  inf_fe_family_mapping_switch(3, compute_data(fe_t, elem,data), , ;break;);
845  break;
846  }
847 
848 
849  default:
850  libmesh_error_msg("Invalid dim = " << dim);
851  break;
852  }
853 }
854 
855 } // namespace libMesh
856 
857 #endif // ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
libMesh::FEType
class FEType hides (possibly multiple) FEFamily and approximation orders, thereby enabling specialize...
Definition: fe_type.h:196
libMesh::ElemType
ElemType
Defines an enum for geometric element types.
Definition: enum_elem_type.h:33
libMesh::InfFE::map
static Point map(const Elem *inf_elem, const Point &reference_point)
Definition: inf_fe.h:474
libMesh::InfFE::n_dofs_per_elem
static unsigned int n_dofs_per_elem(const FEType &fet, const ElemType inf_elem_type)
Definition: inf_fe_static.C:154
libMesh::FEInterface::ifem_n_shape_functions
static unsigned int ifem_n_shape_functions(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface_inf_fe.C:40
libMesh::InfFE::n_dofs_at_node
static unsigned int n_dofs_at_node(const FEType &fet, const ElemType inf_elem_type, const unsigned int n)
Definition: inf_fe_static.C:103
libMesh::FEInterface::ifem_on_reference_element
static bool ifem_on_reference_element(const Point &p, const ElemType t, const Real eps)
Definition: fe_interface_inf_fe.C:733
libMesh::FEInterface::shape_deriv
static Real shape_deriv(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const unsigned int j, const Point &p)
Definition: fe_interface.C:1380
libMesh::FEInterface::ifem_shape
static Real ifem_shape(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p)
Definition: fe_interface_inf_fe.C:742
dim
unsigned int dim
Definition: adaptivity_ex3.C:114
libMesh::FEComputeData
class FEComputeData hides arbitrary data to be passed to and from children of FEBase through the FEIn...
Definition: fe_compute_data.h:51
libMesh::Elem
This is the base class from which all geometric element types are derived.
Definition: elem.h:94
libMesh
The libMesh namespace provides an interface to certain functionality in the library.
libMesh::FEInterface::ifem_inverse_map
static Point ifem_inverse_map(const unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
Definition: fe_interface_inf_fe.C:578
libMesh::FEAbstract::on_reference_element
static bool on_reference_element(const Point &p, const ElemType t, const Real eps=TOLERANCE)
Definition: fe_abstract.C:637
libMesh::FEInterface::ifem_compute_data
static void ifem_compute_data(const unsigned int dim, const FEType &fe_t, const Elem *elem, FEComputeData &data)
Definition: fe_interface_inf_fe.C:825
libMesh::InfFE::n_dofs
static unsigned int n_dofs(const FEType &fet, const ElemType inf_elem_type)
Definition: inf_fe_static.C:67
libMesh::FEInterface::shape
static Real shape(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p)
Definition: fe_interface.C:760
libMesh::FEInterface::compute_data
static void compute_data(const unsigned int dim, const FEType &fe_t, const Elem *elem, FEComputeData &data)
Lets the appropriate child of FEBase compute the requested data for the input specified in data...
Definition: fe_interface.C:1889
libMesh::FEType::inf_map
InfMapType inf_map
The coordinate mapping type of the infinite element.
Definition: fe_type.h:275
libMesh::FEInterface::ifem_map
static Point ifem_map(const unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p)
Definition: fe_interface_inf_fe.C:547
libMesh::FEInterface::ifem_nodal_soln
static void ifem_nodal_soln(const unsigned int dim, const FEType &fe_t, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)
Definition: fe_interface_inf_fe.C:297
libMesh::FEInterface::ifem_n_dofs_per_elem
static unsigned int ifem_n_dofs_per_elem(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface_inf_fe.C:234
libMesh::FEType::radial_family
FEFamily radial_family
The type of approximation in radial direction.
Definition: fe_type.h:267
libMesh::Utility::enum_to_string
std::string enum_to_string(const T e)
libMesh::InfFE::inverse_map
static Point inverse_map(const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
Definition: inf_fe.h:482
libMesh::FEInterface::ifem_n_dofs
static unsigned int ifem_n_dofs(const unsigned int dim, const FEType &fe_t, const ElemType t)
Definition: fe_interface_inf_fe.C:103
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition: libmesh_common.h:144
libMesh::Elem::dim
virtual unsigned short dim() const =0
libMesh::InfFE::nodal_soln
static void nodal_soln(const FEType &fet, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)
Usually, this method would build the nodal soln from the element soln.
Definition: inf_fe_static.C:189
libMesh::FEInterface::nodal_soln
static void nodal_soln(const unsigned int dim, const FEType &fe_t, const Elem *elem, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln, const bool add_p_level=true, const unsigned int vdim=1)
Build the nodal soln from the element soln.
Definition: fe_interface.C:625
libMesh::FEInterface::ifem_shape_deriv
static Real ifem_shape_deriv(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const unsigned int j, const Point &p)
Definition: fe_interface_inf_fe.C:797
libMesh::Point
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition: point.h:39
libMesh::InfFE::n_shape_functions
virtual unsigned int n_shape_functions() const override
Definition: inf_fe.h:569
libMesh::FEInterface::ifem_n_dofs_at_node
static unsigned int ifem_n_dofs_at_node(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int n)
Definition: fe_interface_inf_fe.C:167
Generated on Thu Oct 30 2025 20:01:51 for libMesh by   doxygen 1.8.14