libMesh
fe_interface_inf_fe.C
Go to the documentation of this file.
1 // The libMesh Finite Element Library.
2 // Copyright (C) 2002-2017 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/inf_fe.h"
27 
28 namespace libMesh
29 {
30 
31 
32 
33 
34 //------------------------------------------------------------
35 //FEInterface class members handling calls to InfFE
36 
37 
38 
39 unsigned int FEInterface::ifem_n_shape_functions(const unsigned int dim,
40  const FEType & fe_t,
41  const ElemType t)
42 {
43  switch (dim)
44  {
45  // 1D
46  case 1:
47  /*
48  * Since InfFE<Dim,T_radial,T_map>::n_shape_functions(...)
49  * is actually independent of T_radial and T_map, we can use
50  * just any T_radial and T_map
51  */
53 
54  // 2D
55  case 2:
57 
58  // 3D
59  case 3:
61 
62  default:
63  libmesh_error_msg("Unsupported dim = " << dim);
64  }
65 
66  libmesh_error_msg("We'll never get here!");
67  return 0;
68 }
69 
70 
71 
72 
73 
74 unsigned int FEInterface::ifem_n_dofs(const unsigned int dim,
75  const FEType & fe_t,
76  const ElemType t)
77 {
78  switch (dim)
79  {
80  // 1D
81  case 1:
82  /*
83  * Since InfFE<Dim,T_radial,T_map>::n_dofs(...)
84  * is actually independent of T_radial and T_map, we can use
85  * just any T_radial and T_map
86  */
88 
89  // 2D
90  case 2:
92 
93  // 3D
94  case 3:
96 
97  default:
98  libmesh_error_msg("Unsupported dim = " << dim);
99  }
100 
101  libmesh_error_msg("We'll never get here!");
102  return 0;
103 }
104 
105 
106 
107 
108 unsigned int FEInterface::ifem_n_dofs_at_node(const unsigned int dim,
109  const FEType & fe_t,
110  const ElemType t,
111  const unsigned int n)
112 {
113  switch (dim)
114  {
115  // 1D
116  case 1:
117  /*
118  * Since InfFE<Dim,T_radial,T_map>::n_dofs_at_node(...)
119  * is actually independent of T_radial and T_map, we can use
120  * just any T_radial and T_map
121  */
123 
124  // 2D
125  case 2:
127 
128  // 3D
129  case 3:
131 
132  default:
133  libmesh_error_msg("Unsupported dim = " << dim);
134  }
135 
136  libmesh_error_msg("We'll never get here!");
137  return 0;
138 }
139 
140 
141 
142 
143 
144 unsigned int FEInterface::ifem_n_dofs_per_elem(const unsigned int dim,
145  const FEType & fe_t,
146  const ElemType t)
147 {
148  switch (dim)
149  {
150  // 1D
151  case 1:
152  /*
153  * Since InfFE<Dim,T_radial,T_map>::n_dofs(...)
154  * is actually independent of T_radial and T_map, we can use
155  * just any T_radial and T_map
156  */
158 
159  // 2D
160  case 2:
162 
163  // 3D
164  case 3:
166 
167  default:
168  libmesh_error_msg("Unsupported dim = " << dim);
169  }
170 
171  libmesh_error_msg("We'll never get here!");
172  return 0;
173 }
174 
175 
176 
177 
178 void FEInterface::ifem_nodal_soln(const unsigned int dim,
179  const FEType & fe_t,
180  const Elem * elem,
181  const std::vector<Number> & elem_soln,
182  std::vector<Number> & nodal_soln)
183 {
184  switch (dim)
185  {
186 
187  // 1D
188  case 1:
189  {
190  switch (fe_t.radial_family)
191  {
192  case INFINITE_MAP:
193  libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
194 
195  case JACOBI_20_00:
196  {
197  switch (fe_t.inf_map)
198  {
199  case CARTESIAN:
200  {
201  InfFE<1,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
202  break;
203  }
204  default:
205  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
206  }
207  break;
208  }
209 
210  case JACOBI_30_00:
211  {
212  switch (fe_t.inf_map)
213  {
214  case CARTESIAN:
215  {
216  InfFE<1,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
217  break;
218  }
219  default:
220  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
221  }
222  break;
223  }
224 
225  case LEGENDRE:
226  {
227  switch (fe_t.inf_map)
228  {
229  case CARTESIAN:
230  {
231  InfFE<1,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
232  break;
233  }
234  default:
235  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
236  }
237  break;
238  }
239 
240  case LAGRANGE:
241  {
242  switch (fe_t.inf_map)
243  {
244  case CARTESIAN:
245  {
246  InfFE<1,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
247  break;
248  }
249  default:
250  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
251  }
252  break;
253  }
254 
255  default:
256  libmesh_error_msg("ERROR: Bad FEType.radial_family= " << fe_t.radial_family);
257  }
258 
259  break;
260  }
261 
262 
263 
264 
265  // 2D
266  case 2:
267  {
268  switch (fe_t.radial_family)
269  {
270  case INFINITE_MAP:
271  libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
272 
273  case JACOBI_20_00:
274  {
275  switch (fe_t.inf_map)
276  {
277  case CARTESIAN:
278  {
279  InfFE<2,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
280  break;
281  }
282  default:
283  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
284  }
285  break;
286  }
287 
288  case JACOBI_30_00:
289  {
290  switch (fe_t.inf_map)
291  {
292  case CARTESIAN:
293  {
294  InfFE<2,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
295  break;
296  }
297  default:
298  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
299  }
300  break;
301  }
302 
303  case LEGENDRE:
304  {
305  switch (fe_t.inf_map)
306  {
307  case CARTESIAN:
308  {
309  InfFE<2,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
310  break;
311  }
312  default:
313  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
314  }
315  break;
316  }
317 
318  case LAGRANGE:
319  {
320  switch (fe_t.inf_map)
321  {
322  case CARTESIAN:
323  {
324  InfFE<2,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
325  break;
326  }
327  default:
328  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
329  }
330  break;
331  }
332 
333  default:
334  libmesh_error_msg("ERROR: Bad FEType.radial_family= " << fe_t.radial_family);
335  }
336 
337  break;
338  }
339 
340 
341 
342 
343  // 3D
344  case 3:
345  {
346  switch (fe_t.radial_family)
347  {
348  case INFINITE_MAP:
349  libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
350 
351  case JACOBI_20_00:
352  {
353  switch (fe_t.inf_map)
354  {
355  case CARTESIAN:
356  {
357  InfFE<3,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
358  break;
359  }
360  default:
361  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
362  }
363  break;
364  }
365 
366  case JACOBI_30_00:
367  {
368  switch (fe_t.inf_map)
369  {
370  case CARTESIAN:
371  {
372  InfFE<3,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
373  break;
374  }
375  default:
376  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
377  }
378  break;
379  }
380 
381  case LEGENDRE:
382  {
383  switch (fe_t.inf_map)
384  {
385  case CARTESIAN:
386  {
387  InfFE<3,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
388  break;
389  }
390  default:
391  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
392  }
393  break;
394  }
395 
396  case LAGRANGE:
397  {
398  switch (fe_t.inf_map)
399  {
400  case CARTESIAN:
401  {
402  InfFE<3,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
403  break;
404  }
405  default:
406  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
407  }
408  break;
409  }
410 
411 
412 
413  default:
414  libmesh_error_msg("ERROR: Bad FEType.radial_family= " << fe_t.radial_family);
415  }
416 
417  break;
418  }
419 
420  default:
421  libmesh_error_msg("Invalid dim = " << dim);
422  }
423 }
424 
425 
426 
427 
428 Point FEInterface::ifem_map (const unsigned int dim,
429  const FEType & fe_t,
430  const Elem * elem,
431  const Point & p)
432 {
433  switch (fe_t.inf_map)
434  {
435  case CARTESIAN:
436  {
437  switch (dim)
438  {
439  case 1:
440  return InfFE<1,JACOBI_20_00,CARTESIAN>::map(elem, p);
441  case 2:
442  return InfFE<2,JACOBI_20_00,CARTESIAN>::map(elem, p);
443  case 3:
444  return InfFE<3,JACOBI_20_00,CARTESIAN>::map(elem, p);
445  default:
446  libmesh_error_msg("Invalid dim = " << dim);
447  }
448  }
449  case SPHERICAL:
450  case ELLIPSOIDAL:
451  libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
452  default:
453  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
454  }
455 }
456 
457 
458 
460  const FEType & fe_t,
461  const Elem * elem,
462  const Point & p,
463  const Real tolerance,
464  const bool secure)
465 {
466  switch (dim)
467  {
468  // 1D
469  case 1:
470  {
471  switch (fe_t.inf_map)
472  {
473  case CARTESIAN:
474  return InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
475 
476  case SPHERICAL:
477  case ELLIPSOIDAL:
478  libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
479 
480  /*
481  case SPHERICAL:
482  return InfFE<1,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance);
483 
484  case ELLIPSOIDAL:
485  return InfFE<1,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance);
486  */
487 
488  default:
489  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
490  }
491  }
492 
493 
494  // 2D
495  case 2:
496  {
497  switch (fe_t.inf_map)
498  {
499  case CARTESIAN:
500  return InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
501 
502  case SPHERICAL:
503  case ELLIPSOIDAL:
504  libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
505 
506  /*
507  case SPHERICAL:
508  return InfFE<2,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance);
509 
510  case ELLIPSOIDAL:
511  return InfFE<2,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance);
512  */
513 
514  default:
515  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
516  }
517  }
518 
519 
520  // 3D
521  case 3:
522  {
523  switch (fe_t.inf_map)
524  {
525  case CARTESIAN:
526  return InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
527 
528  case SPHERICAL:
529  case ELLIPSOIDAL:
530  libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
531 
532  /*
533  case SPHERICAL:
534  return InfFE<3,JACOBI_20_00,SPHERICAL>::inverse_map(elem, p, tolerance);
535 
536  case ELLIPSOIDAL:
537  return InfFE<3,JACOBI_20_00,ELLIPSOIDAL>::inverse_map(elem, p, tolerance);
538  */
539 
540  default:
541  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
542  }
543  }
544 
545  default:
546  libmesh_error_msg("Invalid dim = " << dim);
547  }
548 
549  libmesh_error_msg("We'll never get here!");
550  Point pt;
551  return pt;
552 }
553 
554 
555 
556 void FEInterface::ifem_inverse_map (const unsigned int dim,
557  const FEType & fe_t,
558  const Elem * elem,
559  const std::vector<Point> & physical_points,
560  std::vector<Point> & reference_points,
561  const Real tolerance,
562  const bool secure)
563 {
564  switch (dim)
565  {
566  // 1D
567  case 1:
568  {
569  switch (fe_t.inf_map)
570  {
571  case CARTESIAN:
572  InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
573  return;
574 
575  default:
576  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
577  }
578  }
579 
580 
581  // 2D
582  case 2:
583  {
584  switch (fe_t.inf_map)
585  {
586  case CARTESIAN:
587  InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
588  return;
589 
590  default:
591  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
592  }
593  }
594 
595 
596  // 3D
597  case 3:
598  {
599  switch (fe_t.inf_map)
600  {
601  case CARTESIAN:
602  InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
603  return;
604 
605  default:
606  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
607  }
608  }
609 
610  default:
611  libmesh_error_msg("Invalid dim = " << dim);
612  }
613 }
614 
615 
616 
617 
619  const ElemType t,
620  const Real eps)
621 {
622  return FEBase::on_reference_element(p,t,eps);
623 }
624 
625 
626 
627 
628 Real FEInterface::ifem_shape(const unsigned int dim,
629  const FEType & fe_t,
630  const ElemType t,
631  const unsigned int i,
632  const Point & p)
633 {
634  switch (dim)
635  {
636  // 1D
637  case 1:
638  {
639  switch (fe_t.radial_family)
640  {
641  /*
642  * For no derivatives (and local coordinates, as
643  * given in \p p) the infinite element shapes
644  * are independent of mapping type
645  */
646  case INFINITE_MAP:
647  return InfFE<1,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p);
648 
649  case JACOBI_20_00:
650  return InfFE<1,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p);
651 
652  case JACOBI_30_00:
653  return InfFE<1,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p);
654 
655  case LEGENDRE:
656  return InfFE<1,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p);
657 
658  case LAGRANGE:
659  return InfFE<1,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p);
660 
661  default:
662  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
663  }
664  }
665 
666 
667  // 2D
668  case 2:
669  {
670  switch (fe_t.radial_family)
671  {
672  case INFINITE_MAP:
673  return InfFE<2,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p);
674 
675  case JACOBI_20_00:
676  return InfFE<2,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p);
677 
678  case JACOBI_30_00:
679  return InfFE<2,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p);
680 
681  case LEGENDRE:
682  return InfFE<2,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p);
683 
684  case LAGRANGE:
685  return InfFE<2,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p);
686 
687  default:
688  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
689  }
690  }
691 
692 
693  // 3D
694  case 3:
695  {
696  switch (fe_t.radial_family)
697  {
698  case INFINITE_MAP:
699  return InfFE<3,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p);
700 
701  case JACOBI_20_00:
702  return InfFE<3,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p);
703 
704  case JACOBI_30_00:
705  return InfFE<3,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p);
706 
707  case LEGENDRE:
708  return InfFE<3,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p);
709 
710  case LAGRANGE:
711  return InfFE<3,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p);
712 
713  default:
714  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
715  }
716  }
717 
718  default:
719  libmesh_error_msg("Invalid dim = " << dim);
720  }
721 
722  libmesh_error_msg("We'll never get here!");
723  return 0.;
724 }
725 
726 
727 
728 
729 Real FEInterface::ifem_shape(const unsigned int dim,
730  const FEType & fe_t,
731  const Elem * elem,
732  const unsigned int i,
733  const Point & p)
734 {
735  switch (dim)
736  {
737  // 1D
738  case 1:
739  {
740  switch (fe_t.radial_family)
741  {
742  /*
743  * For no derivatives (and local coordinates, as
744  * given in \p p) the infinite element shapes
745  * are independent of mapping type
746  */
747  case INFINITE_MAP:
748  return InfFE<1,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p);
749 
750  case JACOBI_20_00:
751  return InfFE<1,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p);
752 
753  case JACOBI_30_00:
754  return InfFE<1,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p);
755 
756  case LEGENDRE:
757  return InfFE<1,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p);
758 
759  case LAGRANGE:
760  return InfFE<1,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p);
761 
762  default:
763  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
764  }
765  }
766 
767 
768  // 2D
769  case 2:
770  {
771  switch (fe_t.radial_family)
772  {
773  case INFINITE_MAP:
774  return InfFE<2,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p);
775 
776  case JACOBI_20_00:
777  return InfFE<2,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p);
778 
779  case JACOBI_30_00:
780  return InfFE<2,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p);
781 
782  case LEGENDRE:
783  return InfFE<2,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p);
784 
785  case LAGRANGE:
786  return InfFE<2,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p);
787 
788  default:
789  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
790  }
791  }
792 
793 
794  // 3D
795  case 3:
796  {
797  switch (fe_t.radial_family)
798  {
799  case INFINITE_MAP:
800  return InfFE<3,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p);
801 
802  case JACOBI_20_00:
803  return InfFE<3,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p);
804 
805  case JACOBI_30_00:
806  return InfFE<3,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p);
807 
808  case LEGENDRE:
809  return InfFE<3,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p);
810 
811  case LAGRANGE:
812  return InfFE<3,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p);
813 
814  default:
815  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
816  }
817  }
818 
819  default:
820  libmesh_error_msg("Invalid dim = " << dim);
821  }
822 
823  libmesh_error_msg("We'll never get here!");
824  return 0.;
825 }
826 
827 
828 
829 
830 void FEInterface::ifem_compute_data(const unsigned int dim,
831  const FEType & fe_t,
832  const Elem * elem,
834 {
835  switch (dim)
836  {
837  // 1D
838  case 1:
839  {
840  switch (fe_t.radial_family)
841  {
842  /*
843  * For no derivatives (and local coordinates, as
844  * given in \p p) the infinite element shapes
845  * are independent of mapping type
846  */
847  case INFINITE_MAP:
849  break;
850 
851  case JACOBI_20_00:
853  break;
854 
855  case JACOBI_30_00:
857  break;
858 
859  case LEGENDRE:
861  break;
862 
863  case LAGRANGE:
865  break;
866 
867  default:
868  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
869  }
870 
871  break;
872  }
873 
874 
875  // 2D
876  case 2:
877  {
878  switch (fe_t.radial_family)
879  {
880  case INFINITE_MAP:
882  break;
883 
884  case JACOBI_20_00:
886  break;
887 
888  case JACOBI_30_00:
890  break;
891 
892  case LEGENDRE:
894  break;
895 
896  case LAGRANGE:
898  break;
899 
900  default:
901  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
902  }
903 
904  break;
905  }
906 
907 
908  // 3D
909  case 3:
910  {
911  switch (fe_t.radial_family)
912  {
913  case INFINITE_MAP:
915  break;
916 
917  case JACOBI_20_00:
919  break;
920 
921  case JACOBI_30_00:
923  break;
924 
925  case LEGENDRE:
927  break;
928 
929  case LAGRANGE:
931  break;
932 
933  default:
934  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
935  }
936 
937  break;
938  }
939 
940 
941  default:
942  libmesh_error_msg("Invalid dim = " << dim);
943  break;
944  }
945 }
946 
947 } // namespace libMesh
948 
949 #endif // ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
class FEType hides (possibly multiple) FEFamily and approximation orders, thereby enabling specialize...
Definition: fe_type.h:178
static unsigned int n_dofs_per_elem(const FEType &fet, const ElemType inf_elem_type)
static unsigned int ifem_n_shape_functions(const unsigned int dim, const FEType &fe_t, const ElemType t)
static unsigned int n_dofs_at_node(const FEType &fet, const ElemType inf_elem_type, const unsigned int n)
Definition: inf_fe_static.C:72
static bool ifem_on_reference_element(const Point &p, const ElemType t, const Real eps)
static Real ifem_shape(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int i, const Point &p)
unsigned int dim
class FEComputeData hides arbitrary data to be passed to and from children of FEBase through the FEIn...
ElemType
Defines an enum for geometric element types.
virtual unsigned int n_shape_functions() const libmesh_override
Definition: inf_fe.h:459
This is the base class from which all geometric element types are derived.
Definition: elem.h:89
static Real shape(const FEType &fet, const ElemType t, const unsigned int i, const Point &p)
The libMesh namespace provides an interface to certain functionality in the library.
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)
static bool on_reference_element(const Point &p, const ElemType t, const Real eps=TOLERANCE)
Definition: fe_abstract.C:557
static void ifem_compute_data(const unsigned int dim, const FEType &fe_t, const Elem *elem, FEComputeData &data)
static unsigned int n_dofs(const FEType &fet, const ElemType inf_elem_type)
Definition: inf_fe_static.C:55
InfMapType inf_map
The coordinate mapping type of the infinite element.
Definition: fe_type.h:257
static Point ifem_map(const unsigned int dim, const FEType &fe_t, const Elem *elem, const Point &p)
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)
static unsigned int ifem_n_dofs_per_elem(const unsigned int dim, const FEType &fe_t, const ElemType t)
FEFamily radial_family
For InfFE, family contains the radial shape family, while base_family contains the approximation type...
Definition: fe_type.h:249
static Point inverse_map(const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
Definition: inf_fe_map.C:89
static unsigned int ifem_n_dofs(const unsigned int dim, const FEType &fe_t, const ElemType t)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
static Point map(const Elem *inf_elem, const Point &reference_point)
Definition: inf_fe_map.C:40
static void compute_data(const FEType &fe_t, const Elem *inf_elem, FEComputeData &data)
Generalized version of shape(), takes an Elem *.
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)
Build the nodal soln from the element soln.
Definition: fe_interface.C:526
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.
IterBase * data
Ideally this private member data should have protected access.
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition: point.h:38
static unsigned int ifem_n_dofs_at_node(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int n)