libMesh
fe_interface_inf_fe.C
Go to the documentation of this file.
1 // The libMesh Finite Element Library.
2 // Copyright (C) 2002-2019 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 #define inf_fe_family_mapping_switch(dim, func_and_args, prefix, suffix) \
33  do { \
34  switch (fe_t.radial_family) \
35  { \
36  case INFINITE_MAP: \
37  switch(fe_t.inf_map) \
38  { \
39  case CARTESIAN: \
40  prefix InfFE<dim,INFINITE_MAP,CARTESIAN>::func_and_args suffix \
41  case SPHERICAL: \
42  case ELLIPSOIDAL: \
43  libmesh_not_implemented(); \
44  default: \
45  libmesh_error_msg("Invalid radial mapping " << fe_t.inf_map); \
46  } \
47  case JACOBI_20_00: \
48  switch(fe_t.inf_map) \
49  { \
50  case CARTESIAN: \
51  prefix InfFE<dim,JACOBI_20_00,CARTESIAN>::func_and_args suffix \
52  case SPHERICAL: \
53  case ELLIPSOIDAL: \
54  libmesh_not_implemented(); \
55  default: \
56  libmesh_error_msg("Invalid radial mapping " << fe_t.inf_map); \
57  } \
58  case JACOBI_30_00: \
59  switch(fe_t.inf_map) \
60  { \
61  case CARTESIAN: \
62  prefix InfFE<dim,JACOBI_30_00,CARTESIAN>::func_and_args suffix \
63  case SPHERICAL: \
64  case ELLIPSOIDAL: \
65  libmesh_not_implemented(); \
66  default: \
67  libmesh_error_msg("Invalid radial mapping " << fe_t.inf_map); \
68  } \
69  case LEGENDRE: \
70  switch(fe_t.inf_map) \
71  { \
72  case CARTESIAN: \
73  prefix InfFE<dim,LEGENDRE,CARTESIAN>::func_and_args suffix \
74  case SPHERICAL: \
75  case ELLIPSOIDAL: \
76  libmesh_not_implemented(); \
77  default: \
78  libmesh_error_msg("Invalid radial mapping " << fe_t.inf_map); \
79  } \
80  case LAGRANGE: \
81  switch(fe_t.inf_map) \
82  { \
83  case CARTESIAN: \
84  prefix InfFE<dim,LAGRANGE,CARTESIAN>::func_and_args suffix \
85  case SPHERICAL: \
86  case ELLIPSOIDAL: \
87  libmesh_not_implemented(); \
88  default: \
89  libmesh_error_msg("Invalid radial mapping " << fe_t.inf_map); \
90  } \
91  default: \
92  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family); \
93  } \
94  } while (0)
95 
96 
97 //------------------------------------------------------------
98 //FEInterface class members handling calls to InfFE
99 
100 
101 
102 unsigned int FEInterface::ifem_n_shape_functions(const unsigned int dim,
103  const FEType & fe_t,
104  const ElemType t)
105 {
106  switch (dim)
107  {
108  // 1D
109  case 1:
110  /*
111  * Since InfFE<Dim,T_radial,T_map>::n_shape_functions(...)
112  * is actually independent of T_radial and T_map, we can use
113  * just any T_radial and T_map
114  */
115  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
116 
117  // 2D
118  case 2:
119  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
120 
121  // 3D
122  case 3:
123  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_shape_functions(fe_t, t);
124 
125  default:
126  libmesh_error_msg("Unsupported dim = " << dim);
127  }
128 }
129 
130 
131 
132 
133 
134 unsigned int FEInterface::ifem_n_dofs(const unsigned int dim,
135  const FEType & fe_t,
136  const ElemType t)
137 {
138  switch (dim)
139  {
140  // 1D
141  case 1:
142  /*
143  * Since InfFE<Dim,T_radial,T_map>::n_dofs(...)
144  * is actually independent of T_radial and T_map, we can use
145  * just any T_radial and T_map
146  */
147  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
148 
149  // 2D
150  case 2:
151  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
152 
153  // 3D
154  case 3:
155  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs(fe_t, t);
156 
157  default:
158  libmesh_error_msg("Unsupported dim = " << dim);
159  }
160 }
161 
162 
163 
164 
165 unsigned int FEInterface::ifem_n_dofs_at_node(const unsigned int dim,
166  const FEType & fe_t,
167  const ElemType t,
168  const unsigned int n)
169 {
170  switch (dim)
171  {
172  // 1D
173  case 1:
174  /*
175  * Since InfFE<Dim,T_radial,T_map>::n_dofs_at_node(...)
176  * is actually independent of T_radial and T_map, we can use
177  * just any T_radial and T_map
178  */
179  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
180 
181  // 2D
182  case 2:
183  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
184 
185  // 3D
186  case 3:
187  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_at_node(fe_t, t, n);
188 
189  default:
190  libmesh_error_msg("Unsupported dim = " << dim);
191  }
192 }
193 
194 
195 
196 
197 
198 unsigned int FEInterface::ifem_n_dofs_per_elem(const unsigned int dim,
199  const FEType & fe_t,
200  const ElemType t)
201 {
202  switch (dim)
203  {
204  // 1D
205  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  return InfFE<1,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
212 
213  // 2D
214  case 2:
215  return InfFE<2,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
216 
217  // 3D
218  case 3:
219  return InfFE<3,JACOBI_20_00,CARTESIAN>::n_dofs_per_elem(fe_t, t);
220 
221  default:
222  libmesh_error_msg("Unsupported dim = " << dim);
223  }
224 }
225 
226 
227 
228 
229 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  switch (dim)
236  {
237 
238  // 1D
239  case 1:
240  {
241  switch (fe_t.radial_family)
242  {
243  case INFINITE_MAP:
244  libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
245 
246  case JACOBI_20_00:
247  {
248  switch (fe_t.inf_map)
249  {
250  case CARTESIAN:
251  {
252  InfFE<1,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
253  break;
254  }
255  default:
256  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
257  }
258  break;
259  }
260 
261  case JACOBI_30_00:
262  {
263  switch (fe_t.inf_map)
264  {
265  case CARTESIAN:
266  {
267  InfFE<1,JACOBI_30_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 LEGENDRE:
277  {
278  switch (fe_t.inf_map)
279  {
280  case CARTESIAN:
281  {
282  InfFE<1,LEGENDRE,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 LAGRANGE:
292  {
293  switch (fe_t.inf_map)
294  {
295  case CARTESIAN:
296  {
297  InfFE<1,LAGRANGE,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  default:
307  libmesh_error_msg("ERROR: Bad FEType.radial_family= " << fe_t.radial_family);
308  }
309 
310  break;
311  }
312 
313 
314 
315 
316  // 2D
317  case 2:
318  {
319  switch (fe_t.radial_family)
320  {
321  case INFINITE_MAP:
322  libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
323 
324  case JACOBI_20_00:
325  {
326  switch (fe_t.inf_map)
327  {
328  case CARTESIAN:
329  {
330  InfFE<2,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
331  break;
332  }
333  default:
334  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
335  }
336  break;
337  }
338 
339  case JACOBI_30_00:
340  {
341  switch (fe_t.inf_map)
342  {
343  case CARTESIAN:
344  {
345  InfFE<2,JACOBI_30_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 LEGENDRE:
355  {
356  switch (fe_t.inf_map)
357  {
358  case CARTESIAN:
359  {
360  InfFE<2,LEGENDRE,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 LAGRANGE:
370  {
371  switch (fe_t.inf_map)
372  {
373  case CARTESIAN:
374  {
375  InfFE<2,LAGRANGE,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  default:
385  libmesh_error_msg("ERROR: Bad FEType.radial_family= " << fe_t.radial_family);
386  }
387 
388  break;
389  }
390 
391 
392 
393 
394  // 3D
395  case 3:
396  {
397  switch (fe_t.radial_family)
398  {
399  case INFINITE_MAP:
400  libmesh_error_msg("ERROR: INFINITE_MAP is not a valid shape family for radial approximation.");
401 
402  case JACOBI_20_00:
403  {
404  switch (fe_t.inf_map)
405  {
406  case CARTESIAN:
407  {
408  InfFE<3,JACOBI_20_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
409  break;
410  }
411  default:
412  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
413  }
414  break;
415  }
416 
417  case JACOBI_30_00:
418  {
419  switch (fe_t.inf_map)
420  {
421  case CARTESIAN:
422  {
423  InfFE<3,JACOBI_30_00,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
424  break;
425  }
426  default:
427  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
428  }
429  break;
430  }
431 
432  case LEGENDRE:
433  {
434  switch (fe_t.inf_map)
435  {
436  case CARTESIAN:
437  {
438  InfFE<3,LEGENDRE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
439  break;
440  }
441  default:
442  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
443  }
444  break;
445  }
446 
447  case LAGRANGE:
448  {
449  switch (fe_t.inf_map)
450  {
451  case CARTESIAN:
452  {
453  InfFE<3,LAGRANGE,CARTESIAN>::nodal_soln(fe_t, elem, elem_soln, nodal_soln);
454  break;
455  }
456  default:
457  libmesh_error_msg("ERROR: Spherical & Ellipsoidal IFEMs not implemented.");
458  }
459  break;
460  }
461 
462 
463 
464  default:
465  libmesh_error_msg("ERROR: Bad FEType.radial_family= " << fe_t.radial_family);
466  }
467 
468  break;
469  }
470 
471  default:
472  libmesh_error_msg("Invalid dim = " << dim);
473  }
474 }
475 
476 
477 
478 
479 Point FEInterface::ifem_map (const unsigned int dim,
480  const FEType & fe_t,
481  const Elem * elem,
482  const Point & p)
483 {
484  switch (fe_t.inf_map)
485  {
486  case CARTESIAN:
487  {
488  switch (dim)
489  {
490  case 1:
491  return InfFE<1,JACOBI_20_00,CARTESIAN>::map(elem, p);
492  case 2:
493  return InfFE<2,JACOBI_20_00,CARTESIAN>::map(elem, p);
494  case 3:
495  return InfFE<3,JACOBI_20_00,CARTESIAN>::map(elem, p);
496  default:
497  libmesh_error_msg("Invalid dim = " << dim);
498  }
499  }
500  case SPHERICAL:
501  case ELLIPSOIDAL:
502  libmesh_not_implemented_msg("ERROR: Spherical and Ellipsoidal IFEMs not (yet) implemented.");
503  default:
504  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
505  }
506 }
507 
508 
509 
510 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  switch (dim)
518  {
519  // 1D
520  case 1:
521  {
522  switch (fe_t.inf_map)
523  {
524  case CARTESIAN:
525  return InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
526 
527  case SPHERICAL:
528  case ELLIPSOIDAL:
529  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  default:
540  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
541  }
542  }
543 
544 
545  // 2D
546  case 2:
547  {
548  switch (fe_t.inf_map)
549  {
550  case CARTESIAN:
551  return InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
552 
553  case SPHERICAL:
554  case ELLIPSOIDAL:
555  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  default:
566  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
567  }
568  }
569 
570 
571  // 3D
572  case 3:
573  {
574  switch (fe_t.inf_map)
575  {
576  case CARTESIAN:
577  return InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, p, tolerance, secure);
578 
579  case SPHERICAL:
580  case ELLIPSOIDAL:
581  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  default:
592  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
593  }
594  }
595 
596  default:
597  libmesh_error_msg("Invalid dim = " << dim);
598  }
599 }
600 
601 
602 
603 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  switch (dim)
612  {
613  // 1D
614  case 1:
615  {
616  switch (fe_t.inf_map)
617  {
618  case CARTESIAN:
619  InfFE<1,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
620  return;
621 
622  default:
623  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
624  }
625  }
626 
627 
628  // 2D
629  case 2:
630  {
631  switch (fe_t.inf_map)
632  {
633  case CARTESIAN:
634  InfFE<2,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
635  return;
636 
637  default:
638  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
639  }
640  }
641 
642 
643  // 3D
644  case 3:
645  {
646  switch (fe_t.inf_map)
647  {
648  case CARTESIAN:
649  InfFE<3,JACOBI_20_00,CARTESIAN>::inverse_map(elem, physical_points, reference_points, tolerance, secure);
650  return;
651 
652  default:
653  libmesh_error_msg("Invalid map = " << fe_t.inf_map);
654  }
655  }
656 
657  default:
658  libmesh_error_msg("Invalid dim = " << dim);
659  }
660 }
661 
662 
663 
664 
665 bool FEInterface::ifem_on_reference_element(const Point & p,
666  const ElemType t,
667  const Real eps)
668 {
669  return FEBase::on_reference_element(p,t,eps);
670 }
671 
672 
673 
674 
675 Real FEInterface::ifem_shape(const unsigned int dim,
676  const FEType & fe_t,
677  const ElemType t,
678  const unsigned int i,
679  const Point & p)
680 {
681  switch (dim)
682  {
683  // 1D
684  case 1:
685  {
686  switch (fe_t.radial_family)
687  {
688  /*
689  * For no derivatives (and local coordinates, as
690  * given in \p p) the infinite element shapes
691  * are independent of mapping type
692  */
693  case INFINITE_MAP:
694  return InfFE<1,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p);
695 
696  case JACOBI_20_00:
697  return InfFE<1,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p);
698 
699  case JACOBI_30_00:
700  return InfFE<1,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p);
701 
702  case LEGENDRE:
703  return InfFE<1,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p);
704 
705  case LAGRANGE:
706  return InfFE<1,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p);
707 
708  default:
709  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
710  }
711  }
712 
713 
714  // 2D
715  case 2:
716  {
717  switch (fe_t.radial_family)
718  {
719  case INFINITE_MAP:
720  return InfFE<2,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p);
721 
722  case JACOBI_20_00:
723  return InfFE<2,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p);
724 
725  case JACOBI_30_00:
726  return InfFE<2,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p);
727 
728  case LEGENDRE:
729  return InfFE<2,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p);
730 
731  case LAGRANGE:
732  return InfFE<2,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p);
733 
734  default:
735  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
736  }
737  }
738 
739 
740  // 3D
741  case 3:
742  {
743  switch (fe_t.radial_family)
744  {
745  case INFINITE_MAP:
746  return InfFE<3,INFINITE_MAP,CARTESIAN>::shape(fe_t, t, i, p);
747 
748  case JACOBI_20_00:
749  return InfFE<3,JACOBI_20_00,CARTESIAN>::shape(fe_t, t, i, p);
750 
751  case JACOBI_30_00:
752  return InfFE<3,JACOBI_30_00,CARTESIAN>::shape(fe_t, t, i, p);
753 
754  case LEGENDRE:
755  return InfFE<3,LEGENDRE,CARTESIAN>::shape(fe_t, t, i, p);
756 
757  case LAGRANGE:
758  return InfFE<3,LAGRANGE,CARTESIAN>::shape(fe_t, t, i, p);
759 
760  default:
761  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
762  }
763  }
764 
765  default:
766  libmesh_error_msg("Invalid dim = " << dim);
767  }
768 }
769 
770 
771 
772 
773 Real FEInterface::ifem_shape(const unsigned int dim,
774  const FEType & fe_t,
775  const Elem * elem,
776  const unsigned int i,
777  const Point & p)
778 {
779  switch (dim)
780  {
781  // 1D
782  case 1:
783  {
784  switch (fe_t.radial_family)
785  {
786  /*
787  * For no derivatives (and local coordinates, as
788  * given in \p p) the infinite element shapes
789  * are independent of mapping type
790  */
791  case INFINITE_MAP:
792  return InfFE<1,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p);
793 
794  case JACOBI_20_00:
795  return InfFE<1,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p);
796 
797  case JACOBI_30_00:
798  return InfFE<1,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p);
799 
800  case LEGENDRE:
801  return InfFE<1,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p);
802 
803  case LAGRANGE:
804  return InfFE<1,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p);
805 
806  default:
807  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
808  }
809  }
810 
811 
812  // 2D
813  case 2:
814  {
815  switch (fe_t.radial_family)
816  {
817  case INFINITE_MAP:
818  return InfFE<2,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p);
819 
820  case JACOBI_20_00:
821  return InfFE<2,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p);
822 
823  case JACOBI_30_00:
824  return InfFE<2,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p);
825 
826  case LEGENDRE:
827  return InfFE<2,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p);
828 
829  case LAGRANGE:
830  return InfFE<2,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p);
831 
832  default:
833  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
834  }
835  }
836 
837 
838  // 3D
839  case 3:
840  {
841  switch (fe_t.radial_family)
842  {
843  case INFINITE_MAP:
844  return InfFE<3,INFINITE_MAP,CARTESIAN>::shape(fe_t, elem, i, p);
845 
846  case JACOBI_20_00:
847  return InfFE<3,JACOBI_20_00,CARTESIAN>::shape(fe_t, elem, i, p);
848 
849  case JACOBI_30_00:
850  return InfFE<3,JACOBI_30_00,CARTESIAN>::shape(fe_t, elem, i, p);
851 
852  case LEGENDRE:
853  return InfFE<3,LEGENDRE,CARTESIAN>::shape(fe_t, elem, i, p);
854 
855  case LAGRANGE:
856  return InfFE<3,LAGRANGE,CARTESIAN>::shape(fe_t, elem, i, p);
857 
858  default:
859  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
860  }
861  }
862 
863  default:
864  libmesh_error_msg("Invalid dim = " << dim);
865  }
866 }
867 
868 Real FEInterface::ifem_shape_deriv (const unsigned int dim,
869  const FEType & fe_t,
870  const Elem * elem,
871  const unsigned int i,
872  const unsigned int j,
873  const Point & p)
874 {
875  switch (dim)
876  {
877  // 1D
878  case 1:
879  inf_fe_family_mapping_switch(1, shape_deriv(fe_t, elem, i, j, p), return, ;);
880  // 2D
881  case 2:
882  inf_fe_family_mapping_switch(2, shape_deriv(fe_t, elem, i, j, p), return, ;);
883  // 3D
884  case 3:
885  inf_fe_family_mapping_switch(3, shape_deriv(fe_t, elem, i, j, p), return, ;);
886 
887  default:
888  libmesh_error_msg("Invalid dim = " << dim);
889  }
890 }
891 
892 
893 Real FEInterface::ifem_shape_deriv(const unsigned int dim,
894  const FEType & fe_t,
895  const ElemType t,
896  const unsigned int i,
897  const unsigned int j,
898  const Point & p)
899 {
900  switch (dim)
901  {
902  // 1D
903  case 1:
904  inf_fe_family_mapping_switch(1, shape_deriv(fe_t, t, i, j, p), return, ;);
905  // 2D
906  case 2:
907  inf_fe_family_mapping_switch(2, shape_deriv(fe_t, t, i, j, p), return, ;);
908  // 3D
909  case 3:
910  inf_fe_family_mapping_switch(3, shape_deriv(fe_t, t, i, j, p), return, ;);
911 
912  default:
913  libmesh_error_msg("Invalid dim = " << dim);
914  }
915 }
916 
917 
918 void FEInterface::ifem_compute_data(const unsigned int dim,
919  const FEType & fe_t,
920  const Elem * elem,
921  FEComputeData & data)
922 {
923  switch (dim)
924  {
925  // 1D
926  case 1:
927  {
928  switch (fe_t.radial_family)
929  {
930  /*
931  * For no derivatives (and local coordinates, as
932  * given in \p p) the infinite element shapes
933  * are independent of mapping type
934  */
935  case INFINITE_MAP:
936  InfFE<1,INFINITE_MAP,CARTESIAN>::compute_data(fe_t, elem, data);
937  break;
938 
939  case JACOBI_20_00:
940  InfFE<1,JACOBI_20_00,CARTESIAN>::compute_data(fe_t, elem, data);
941  break;
942 
943  case JACOBI_30_00:
944  InfFE<1,JACOBI_30_00,CARTESIAN>::compute_data(fe_t, elem, data);
945  break;
946 
947  case LEGENDRE:
948  InfFE<1,LEGENDRE,CARTESIAN>::compute_data(fe_t, elem, data);
949  break;
950 
951  case LAGRANGE:
952  InfFE<1,LAGRANGE,CARTESIAN>::compute_data(fe_t, elem, data);
953  break;
954 
955  default:
956  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
957  }
958 
959  break;
960  }
961 
962 
963  // 2D
964  case 2:
965  {
966  switch (fe_t.radial_family)
967  {
968  case INFINITE_MAP:
969  InfFE<2,INFINITE_MAP,CARTESIAN>::compute_data(fe_t, elem, data);
970  break;
971 
972  case JACOBI_20_00:
973  InfFE<2,JACOBI_20_00,CARTESIAN>::compute_data(fe_t, elem, data);
974  break;
975 
976  case JACOBI_30_00:
977  InfFE<2,JACOBI_30_00,CARTESIAN>::compute_data(fe_t, elem, data);
978  break;
979 
980  case LEGENDRE:
981  InfFE<2,LEGENDRE,CARTESIAN>::compute_data(fe_t, elem, data);
982  break;
983 
984  case LAGRANGE:
985  InfFE<2,LAGRANGE,CARTESIAN>::compute_data(fe_t, elem, data);
986  break;
987 
988  default:
989  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
990  }
991 
992  break;
993  }
994 
995 
996  // 3D
997  case 3:
998  {
999  switch (fe_t.radial_family)
1000  {
1001  case INFINITE_MAP:
1002  InfFE<3,INFINITE_MAP,CARTESIAN>::compute_data(fe_t, elem, data);
1003  break;
1004 
1005  case JACOBI_20_00:
1006  InfFE<3,JACOBI_20_00,CARTESIAN>::compute_data(fe_t, elem, data);
1007  break;
1008 
1009  case JACOBI_30_00:
1010  InfFE<3,JACOBI_30_00,CARTESIAN>::compute_data(fe_t, elem, data);
1011  break;
1012 
1013  case LEGENDRE:
1014  InfFE<3,LEGENDRE,CARTESIAN>::compute_data(fe_t, elem, data);
1015  break;
1016 
1017  case LAGRANGE:
1018  InfFE<3,LAGRANGE,CARTESIAN>::compute_data(fe_t, elem, data);
1019  break;
1020 
1021  default:
1022  libmesh_error_msg("Invalid radial family = " << fe_t.radial_family);
1023  }
1024 
1025  break;
1026  }
1027 
1028 
1029  default:
1030  libmesh_error_msg("Invalid dim = " << dim);
1031  break;
1032  }
1033 }
1034 
1035 } // namespace libMesh
1036 
1037 #endif // ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
libMesh::FEType::inf_map
InfMapType inf_map
The coordinate mapping type of the infinite element.
Definition: fe_type.h:257
libMesh::FEType::radial_family
FEFamily radial_family
The type of approximation in radial direction.
Definition: fe_type.h:249
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::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:229
libMesh::INFINITE_MAP
Definition: enum_fe_family.h:48
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:134
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:198
libMesh
The libMesh namespace provides an interface to certain functionality in the library.
Definition: factoryfunction.C:55
libMesh::InfFE::n_dofs
static unsigned int n_dofs(const FEType &fet, const ElemType inf_elem_type)
Definition: inf_fe_static.C:58
libMesh::JACOBI_20_00
Definition: enum_fe_family.h:49
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:123
libMesh::InfFE::map
static Point map(const Elem *inf_elem, const Point &reference_point)
Definition: inf_fe.h:390
dim
unsigned int dim
Definition: adaptivity_ex3.C:113
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)
Build the nodal soln from the element soln.
Definition: fe_interface.C:580
libMesh::CARTESIAN
Definition: enum_inf_map_type.h:35
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:893
libMesh::JACOBI_30_00
Definition: enum_fe_family.h:50
libMesh::Point
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition: point.h:38
libMesh::LEGENDRE
Definition: enum_fe_family.h:51
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:165
libMesh::InfFE::n_shape_functions
virtual unsigned int n_shape_functions() const override
Definition: inf_fe.h:482
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:102
libMesh::SPHERICAL
Definition: enum_inf_map_type.h:36
libMesh::ELLIPSOIDAL
Definition: enum_inf_map_type.h:37
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:675
libMesh::FEAbstract::on_reference_element
static bool on_reference_element(const Point &p, const ElemType t, const Real eps=TOLERANCE)
Definition: fe_abstract.C:606
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:397
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:845
libMesh::FEType
class FEType hides (possibly multiple) FEFamily and approximation orders, thereby enabling specialize...
Definition: fe_type.h:178
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:665
libMesh::InfFE::shape
static Real shape(const FEType &fet, const ElemType t, const unsigned int i, const Point &p)
Definition: inf_fe_static.C:158
libMesh::Elem
This is the base class from which all geometric element types are derived.
Definition: elem.h:100
data
IterBase * data
Ideally this private member data should have protected access.
Definition: variant_filter_iterator.h:337
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:510
libMesh::LAGRANGE
Definition: enum_fe_family.h:36
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:76
libMesh::InfFE::compute_data
static void compute_data(const FEType &fe_t, const Elem *inf_elem, FEComputeData &data)
Generalized version of shape(), takes an Elem *.
Definition: inf_fe_static.C:337
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition: libmesh_common.h:121
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:918
libMesh::ElemType
ElemType
Defines an enum for geometric element types.
Definition: enum_elem_type.h:33
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:105
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:479
Generated on Sat Jan 25 2020 12:06:57 for libMesh by   doxygen 1.8.16