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