LCOV - code coverage report
Current view: top level - src/fe - fe_lagrange_shape_3D.C (source / functions) Hit Total Coverage
Test: libMesh/libmesh: #4573 (924896) with base 3f0912 Lines: 1723 1893 91.0 %
Date: 2026-11-18 21:52:26 Functions: 26 32 81.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // The libMesh Finite Element Library.
       2             : // Copyright (C) 2002-2026 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
       3             : 
       4             : // This library is free software; you can redistribute it and/or
       5             : // modify it under the terms of the GNU Lesser General Public
       6             : // License as published by the Free Software Foundation; either
       7             : // version 2.1 of the License, or (at your option) any later version.
       8             : 
       9             : // This library is distributed in the hope that it will be useful,
      10             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12             : // Lesser General Public License for more details.
      13             : 
      14             : // You should have received a copy of the GNU Lesser General Public
      15             : // License along with this library; if not, write to the Free Software
      16             : // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      17             : 
      18             : 
      19             : // Local includes
      20             : #include "libmesh/fe.h"
      21             : #include "libmesh/elem.h"
      22             : #include "libmesh/fe_lagrange_shape_1D.h"
      23             : #include "libmesh/fe_simplex_lagrange.h"
      24             : #include "libmesh/fe_tensor_product_lagrange.h"
      25             : #include "libmesh/enum_to_string.h"
      26             : #include "libmesh/cell_c0polyhedron.h"
      27             : #include "libmesh/tensor_value.h"
      28             : 
      29             : // Anonymous namespace for functions shared by LAGRANGE and
      30             : // L2_LAGRANGE implementations. Implementations appear at the bottom
      31             : // of this file.
      32             : namespace
      33             : {
      34             : using namespace libMesh;
      35             : 
      36             : template <FEFamily T>
      37             : Real fe_lagrange_3D_shape(const ElemType,
      38             :                           const Order order,
      39             :                           const Elem * elem,
      40             :                           const unsigned int i,
      41             :                           const Point & p);
      42             : 
      43             : template <FEFamily T>
      44             : Real fe_lagrange_3D_shape_deriv(const ElemType type,
      45             :                                 const Order order,
      46             :                                 const Elem * elem,
      47             :                                 const unsigned int i,
      48             :                                 const unsigned int j,
      49             :                                 const Point & p);
      50             : 
      51             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
      52             : 
      53             : template <FEFamily T>
      54             : Real fe_lagrange_3D_shape_second_deriv(const ElemType type,
      55             :                                        const Order order,
      56             :                                        const Elem * elem,
      57             :                                        const unsigned int i,
      58             :                                        const unsigned int j,
      59             :                                        const Point & p);
      60             : 
      61             : #endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
      62             : 
      63             : } // anonymous namespace
      64             : 
      65             : namespace libMesh
      66             : {
      67             : 
      68             : 
      69             : // TODO: If optimizations for LAGRANGE work well we should do
      70             : // L2_LAGRANGE too...
      71    15341866 : LIBMESH_DEFAULT_VECTORIZED_FE(3,L2_LAGRANGE)
      72             : 
      73             : 
      74             : template<>
      75     6194143 : void FE<3,LAGRANGE>::all_shapes
      76             :   (const Elem * elem,
      77             :    const Order o,
      78             :    const std::vector<Point> & p,
      79             :    std::vector<std::vector<OutputShape>> & v,
      80             :    const bool add_p_level)
      81             : {
      82     6194143 :   const ElemType type = elem->type();
      83             : 
      84             :   // Just loop on the harder-to-optimize cases
      85     6194143 :   if (type != HEX8 && type != HEX27)
      86             :     {
      87             :       FE<3,LAGRANGE>::default_all_shapes
      88     5011492 :         (elem,o,p,v,add_p_level);
      89     5011492 :       return;
      90             :     }
      91             : 
      92             : #if LIBMESH_DIM == 3
      93             : 
      94     1182651 :   const unsigned int n_sf = v.size();
      95             : 
      96     1182651 :   switch (o)
      97             :     {
      98             :       // linear Lagrange shape functions
      99      936822 :     case FIRST:
     100             :       {
     101      492518 :         switch (type)
     102             :           {
     103             :             // trilinear hexahedral shape functions
     104      246259 :           case HEX8:
     105             :           case HEX20:
     106             :           case HEX27:
     107             :             {
     108      246259 :               libmesh_assert_less_equal (n_sf, 8);
     109             : 
     110     7112705 :               for (auto qp : index_range(p))
     111             :                 {
     112     1630894 :                   const Point & q_point = p[qp];
     113             : 
     114    55582947 :                   for (unsigned int i : make_range(n_sf))
     115    75501368 :                     v[i][qp] = libMesh::detail::fe_lagrange_hex8_shape(i, q_point(0), q_point(1), q_point(2));
     116             :                 }
     117      246259 :               return;
     118             :             }
     119             : 
     120           0 :           default:
     121           0 :             libmesh_error(); // How did we get here?
     122             :           }
     123             :       }
     124             : 
     125             : 
     126             :       // quadratic Lagrange shape functions
     127      245829 :     case SECOND:
     128             :       {
     129      245829 :         switch (type)
     130             :           {
     131             :             // triquadratic hexahedral shape functions
     132       59996 :           case HEX8:
     133             : // TODO: refactor to optimize this
     134             : //            libmesh_assert_msg(T == L2_LAGRANGE,
     135             : //                               "High order on first order elements only supported for L2 families");
     136             :             libmesh_fallthrough();
     137             :           case HEX27:
     138             :             {
     139       59996 :               libmesh_assert_less_equal (n_sf, 27);
     140             : 
     141     2475692 :               for (auto qp : index_range(p))
     142             :                 {
     143      532195 :                   const Point & q_point = p[qp];
     144             : 
     145    62436164 :                   for (unsigned int i : make_range(n_sf))
     146    88944831 :                     v[i][qp] = libMesh::detail::fe_lagrange_hex27_shape(i, q_point(0), q_point(1), q_point(2));
     147             :                 }
     148       59996 :               return;
     149             :             }
     150             : 
     151           0 :           default:
     152           0 :             libmesh_error(); // How did we get here?
     153             :           }
     154             :       }
     155             : 
     156             :       // unsupported order
     157           0 :     default:
     158           0 :       libmesh_error_msg("ERROR: Unsupported 3D FE order on HEX!: " << o);
     159             :     }
     160             : #else // LIBMESH_DIM != 3
     161             :   libmesh_ignore(elem, o, p, v, add_p_level);
     162             :   libmesh_not_implemented();
     163             : #endif // LIBMESH_DIM == 3
     164             : }
     165             : 
     166             : template<>
     167    69777923 : void FE<3,LAGRANGE>::shapes
     168             :   (const Elem * elem,
     169             :    const Order o,
     170             :    const unsigned int i,
     171             :    const std::vector<Point> & p,
     172             :    std::vector<OutputShape> & v,
     173             :    const bool add_p_level)
     174             : {
     175             :   FE<3,LAGRANGE>::default_shapes
     176    69777923 :     (elem,o,i,p,v,add_p_level);
     177    69777923 : }
     178             : 
     179             : template<>
     180   265005600 : void FE<3,LAGRANGE>::shape_derivs
     181             :   (const Elem * elem,
     182             :    const Order o,
     183             :    const unsigned int i,
     184             :    const unsigned int j,
     185             :    const std::vector<Point> & p,
     186             :    std::vector<OutputShape> & v,
     187             :    const bool add_p_level)
     188             : {
     189             :   FE<3,LAGRANGE>::default_shape_derivs
     190   265005600 :     (elem,o,i,j,p,v,add_p_level);
     191   265005600 : }
     192             : 
     193             : template<>
     194     8980939 : void FE<3,LAGRANGE>::all_shape_derivs
     195             :   (const Elem * elem,
     196             :    const Order o,
     197             :    const std::vector<Point> & p,
     198             :    std::vector<std::vector<OutputShape>> * comps[3],
     199             :    const bool add_p_level)
     200             : {
     201     8980939 :   const ElemType type = elem->type();
     202             : 
     203             :   // Just loop on the harder-to-optimize cases
     204     8980939 :   if (type != HEX8 && type != HEX27)
     205             :     {
     206             :       FE<3,LAGRANGE>::default_all_shape_derivs
     207     6149557 :         (elem,o,p,comps,add_p_level);
     208     6149557 :       return;
     209             :     }
     210             : 
     211             : #if LIBMESH_DIM == 3
     212             : 
     213      709143 :   libmesh_assert(comps[0]);
     214      709143 :   libmesh_assert(comps[1]);
     215      709143 :   libmesh_assert(comps[2]);
     216     2831382 :   const unsigned int n_sf = comps[0]->size();
     217             : 
     218     2831382 :   switch (o)
     219             :     {
     220             :       // linear Lagrange shape functions
     221     2174955 :     case FIRST:
     222             :       {
     223     1094670 :         switch (type)
     224             :           {
     225             :             // trilinear hexahedral shape functions
     226      547335 :           case HEX8:
     227             :           case HEX20:
     228             :           case HEX27:
     229             :             {
     230      547335 :               libmesh_assert_equal_to (n_sf, 8);
     231             : 
     232     5830946 :               for (auto qp : index_range(p))
     233             :                 {
     234      932097 :                   const Point & q_point = p[qp];
     235    32903919 :                   for (unsigned int i : make_range(n_sf))
     236             :                     {
     237    36704704 :                       (*comps[0])[i][qp] = libMesh::detail::fe_lagrange_hex8_shape_deriv(i, 0, q_point(0), q_point(1), q_point(2));
     238    36704704 :                       (*comps[1])[i][qp] = libMesh::detail::fe_lagrange_hex8_shape_deriv(i, 1, q_point(0), q_point(1), q_point(2));
     239    44161480 :                       (*comps[2])[i][qp] = libMesh::detail::fe_lagrange_hex8_shape_deriv(i, 2, q_point(0), q_point(1), q_point(2));
     240             :                     }
     241             :                 }
     242      547335 :               return;
     243             :             }
     244             : 
     245           0 :           default:
     246           0 :             libmesh_error(); // How did we get here?
     247             :           }
     248             :       }
     249             : 
     250             : 
     251             :       // quadratic Lagrange shape functions
     252      656427 :     case SECOND:
     253             :       {
     254      656427 :         switch (type)
     255             :           {
     256             :             // triquadratic hexahedral shape functions
     257      161808 :           case HEX8:
     258             : // TODO: refactor to optimize this
     259             : //            libmesh_assert_msg(T == L2_LAGRANGE,
     260             : //                               "High order on first order elements only supported for L2 families");
     261             :             libmesh_fallthrough();
     262             :           case HEX27:
     263             :             {
     264      161808 :               libmesh_assert_less_equal (n_sf, 27);
     265             : 
     266     4061841 :               for (auto qp : index_range(p))
     267             :                 {
     268      803892 :                   const Point & q_point = p[qp];
     269    95351592 :                   for (unsigned int i : make_range(n_sf))
     270             :                     {
     271   113651262 :                       (*comps[0])[i][qp] = libMesh::detail::fe_lagrange_hex27_shape_deriv(i, 0, q_point(0), q_point(1), q_point(2));
     272   113651262 :                       (*comps[1])[i][qp] = libMesh::detail::fe_lagrange_hex27_shape_deriv(i, 1, q_point(0), q_point(1), q_point(2));
     273   135356346 :                       (*comps[2])[i][qp] = libMesh::detail::fe_lagrange_hex27_shape_deriv(i, 2, q_point(0), q_point(1), q_point(2));
     274             :                     }
     275             :                 }
     276      161808 :               return;
     277             :             }
     278             : 
     279           0 :           default:
     280           0 :             libmesh_error(); // How did we get here?
     281             :           }
     282             :       }
     283             : 
     284             :       // unsupported order
     285           0 :     default:
     286           0 :       libmesh_error_msg("ERROR: Unsupported 3D FE order on HEX!: " << o);
     287             :     }
     288             : #else // LIBMESH_DIM != 3
     289             :   libmesh_ignore(elem, o, p, v, add_p_level);
     290             :   libmesh_not_implemented();
     291             : #endif // LIBMESH_DIM == 3
     292             : }
     293             : 
     294             : 
     295             : 
     296             : 
     297             : template <>
     298    80062236 : Real FE<3,LAGRANGE>::shape(const ElemType type,
     299             :                            const Order order,
     300             :                            const unsigned int i,
     301             :                            const Point & p)
     302             : {
     303    80062236 :   return fe_lagrange_3D_shape<LAGRANGE>(type, order, nullptr, i, p);
     304             : }
     305             : 
     306             : 
     307             : 
     308             : template <>
     309           0 : Real FE<3,L2_LAGRANGE>::shape(const ElemType type,
     310             :                               const Order order,
     311             :                               const unsigned int i,
     312             :                               const Point & p)
     313             : {
     314           0 :   return fe_lagrange_3D_shape<L2_LAGRANGE>(type, order, nullptr, i, p);
     315             : }
     316             : 
     317             : 
     318             : 
     319             : template <>
     320   352417346 : Real FE<3,LAGRANGE>::shape(const Elem * elem,
     321             :                            const Order order,
     322             :                            const unsigned int i,
     323             :                            const Point & p,
     324             :                            const bool add_p_level)
     325             : {
     326    88905631 :   libmesh_assert(elem);
     327             : 
     328             :   // call the orientation-independent shape functions
     329   530228608 :   return fe_lagrange_3D_shape<LAGRANGE>(elem->type(), order + add_p_level*elem->p_level(), elem, i, p);
     330             : }
     331             : 
     332             : 
     333             : 
     334             : template <>
     335    22439589 : Real FE<3,L2_LAGRANGE>::shape(const Elem * elem,
     336             :                               const Order order,
     337             :                               const unsigned int i,
     338             :                               const Point & p,
     339             :                               const bool add_p_level)
     340             : {
     341     5660926 :   libmesh_assert(elem);
     342             : 
     343             :   // call the orientation-independent shape functions
     344    33761441 :   return fe_lagrange_3D_shape<L2_LAGRANGE>(elem->type(), order + add_p_level*elem->p_level(), elem, i, p);
     345             : }
     346             : 
     347             : 
     348             : 
     349             : template <>
     350   482993387 : Real FE<3,LAGRANGE>::shape(const FEType fet,
     351             :                            const Elem * elem,
     352             :                            const unsigned int i,
     353             :                            const Point & p,
     354             :                            const bool add_p_level)
     355             : {
     356   141560480 :   libmesh_assert(elem);
     357   731410495 :   return fe_lagrange_3D_shape<LAGRANGE>(elem->type(), fet.order + add_p_level*elem->p_level(), elem, i, p);
     358             : }
     359             : 
     360             : 
     361             : 
     362             : template <>
     363           0 : Real FE<3,L2_LAGRANGE>::shape(const FEType fet,
     364             :                               const Elem * elem,
     365             :                               const unsigned int i,
     366             :                               const Point & p,
     367             :                               const bool add_p_level)
     368             : {
     369           0 :   libmesh_assert(elem);
     370           0 :   return fe_lagrange_3D_shape<L2_LAGRANGE>(elem->type(), fet.order + add_p_level*elem->p_level(), elem, i, p);
     371             : }
     372             : 
     373             : template <>
     374    90721512 : Real FE<3,LAGRANGE>::shape_deriv(const ElemType type,
     375             :                                  const Order order,
     376             :                                  const unsigned int i,
     377             :                                  const unsigned int j,
     378             :                                  const Point & p)
     379             : {
     380    90721512 :   return fe_lagrange_3D_shape_deriv<LAGRANGE>(type, order, nullptr, i, j, p);
     381             : }
     382             : 
     383             : 
     384             : 
     385             : template <>
     386           0 : Real FE<3,L2_LAGRANGE>::shape_deriv(const ElemType type,
     387             :                                     const Order order,
     388             :                                     const unsigned int i,
     389             :                                     const unsigned int j,
     390             :                                     const Point & p)
     391             : {
     392           0 :   return fe_lagrange_3D_shape_deriv<L2_LAGRANGE>(type, order, nullptr, i, j, p);
     393             : }
     394             : 
     395             : 
     396             : 
     397             : template <>
     398  1170702942 : Real FE<3,LAGRANGE>::shape_deriv(const Elem * elem,
     399             :                                  const Order order,
     400             :                                  const unsigned int i,
     401             :                                  const unsigned int j,
     402             :                                  const Point & p,
     403             :                                  const bool add_p_level)
     404             : {
     405   301912758 :   libmesh_assert(elem);
     406             : 
     407             :   // call the orientation-independent shape function derivatives
     408  1754128698 :   return fe_lagrange_3D_shape_deriv<LAGRANGE>(elem->type(), order + add_p_level*elem->p_level(), elem, i, j, p);
     409             : }
     410             : 
     411             : 
     412             : template <>
     413    13769610 : Real FE<3,L2_LAGRANGE>::shape_deriv(const Elem * elem,
     414             :                                     const Order order,
     415             :                                     const unsigned int i,
     416             :                                     const unsigned int j,
     417             :                                     const Point & p,
     418             :                                     const bool add_p_level)
     419             : {
     420     3593712 :   libmesh_assert(elem);
     421             : 
     422             :   // call the orientation-independent shape function derivatives
     423    20957034 :   return fe_lagrange_3D_shape_deriv<L2_LAGRANGE>(elem->type(), order + add_p_level*elem->p_level(), elem, i, j, p);
     424             : }
     425             : 
     426             : 
     427             : template <>
     428  3703424766 : Real FE<3,LAGRANGE>::shape_deriv(const FEType fet,
     429             :                                  const Elem * elem,
     430             :                                  const unsigned int i,
     431             :                                  const unsigned int j,
     432             :                                  const Point & p,
     433             :                                  const bool add_p_level)
     434             : {
     435   949846761 :   libmesh_assert(elem);
     436  5601201402 :   return fe_lagrange_3D_shape_deriv<LAGRANGE>(elem->type(), fet.order + add_p_level*elem->p_level(), elem, i, j, p);
     437             : }
     438             : 
     439             : 
     440             : template <>
     441           0 : Real FE<3,L2_LAGRANGE>::shape_deriv(const FEType fet,
     442             :                                     const Elem * elem,
     443             :                                     const unsigned int i,
     444             :                                     const unsigned int j,
     445             :                                     const Point & p,
     446             :                                     const bool add_p_level)
     447             : {
     448           0 :   libmesh_assert(elem);
     449           0 :   return fe_lagrange_3D_shape_deriv<L2_LAGRANGE>(elem->type(), fet.order + add_p_level*elem->p_level(), elem, i, j, p);
     450             : }
     451             : 
     452             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
     453             : 
     454             : template <>
     455    31940760 : Real FE<3,LAGRANGE>::shape_second_deriv(const ElemType type,
     456             :                                         const Order order,
     457             :                                         const unsigned int i,
     458             :                                         const unsigned int j,
     459             :                                         const Point & p)
     460             : {
     461    31940760 :   return fe_lagrange_3D_shape_second_deriv<LAGRANGE>(type, order, nullptr, i, j, p);
     462             : }
     463             : 
     464             : 
     465             : 
     466             : template <>
     467           0 : Real FE<3,L2_LAGRANGE>::shape_second_deriv(const ElemType type,
     468             :                                            const Order order,
     469             :                                            const unsigned int i,
     470             :                                            const unsigned int j,
     471             :                                            const Point & p)
     472             : {
     473           0 :   return fe_lagrange_3D_shape_second_deriv<L2_LAGRANGE>(type, order, nullptr, i, j, p);
     474             : }
     475             : 
     476             : 
     477             : 
     478             : template <>
     479    38132688 : Real FE<3,LAGRANGE>::shape_second_deriv(const Elem * elem,
     480             :                                         const Order order,
     481             :                                         const unsigned int i,
     482             :                                         const unsigned int j,
     483             :                                         const Point & p,
     484             :                                         const bool add_p_level)
     485             : {
     486     9932010 :   libmesh_assert(elem);
     487             : 
     488             :   // call the orientation-independent shape function derivatives
     489             :   return fe_lagrange_3D_shape_second_deriv<LAGRANGE>
     490    57996708 :     (elem->type(), order + add_p_level*elem->p_level(), elem, i, j, p);
     491             : }
     492             : 
     493             : 
     494             : 
     495             : template <>
     496    16229172 : Real FE<3,L2_LAGRANGE>::shape_second_deriv(const Elem * elem,
     497             :                                            const Order order,
     498             :                                            const unsigned int i,
     499             :                                            const unsigned int j,
     500             :                                            const Point & p,
     501             :                                            const bool add_p_level)
     502             : {
     503     4359504 :   libmesh_assert(elem);
     504             : 
     505             :   // call the orientation-independent shape function derivatives
     506             :   return fe_lagrange_3D_shape_second_deriv<L2_LAGRANGE>
     507    24948180 :     (elem->type(), order + add_p_level*elem->p_level(), elem, i, j, p);
     508             : }
     509             : 
     510             : 
     511             : template <>
     512   643274106 : Real FE<3,LAGRANGE>::shape_second_deriv(const FEType fet,
     513             :                                         const Elem * elem,
     514             :                                         const unsigned int i,
     515             :                                         const unsigned int j,
     516             :                                         const Point & p,
     517             :                                         const bool add_p_level)
     518             : {
     519   156721902 :   libmesh_assert(elem);
     520             :   return fe_lagrange_3D_shape_second_deriv<LAGRANGE>
     521   956717910 :     (elem->type(), fet.order + add_p_level*elem->p_level(), elem, i, j, p);
     522             : }
     523             : 
     524             : 
     525             : 
     526             : template <>
     527           0 : Real FE<3,L2_LAGRANGE>::shape_second_deriv(const FEType fet,
     528             :                                            const Elem * elem,
     529             :                                            const unsigned int i,
     530             :                                            const unsigned int j,
     531             :                                            const Point & p,
     532             :                                            const bool add_p_level)
     533             : {
     534           0 :   libmesh_assert(elem);
     535             :   return fe_lagrange_3D_shape_second_deriv<L2_LAGRANGE>
     536           0 :     (elem->type(), fet.order + add_p_level*elem->p_level(), elem, i, j, p);
     537             : }
     538             : 
     539             : 
     540             : #endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
     541             : 
     542             : } // namespace libMesh
     543             : 
     544             : 
     545             : 
     546             : namespace
     547             : {
     548             : using namespace libMesh;
     549             : 
     550             : template <FEFamily T>
     551  1016787226 : Real fe_lagrange_3D_shape(const ElemType type,
     552             :                           const Order order,
     553             :                           const Elem * elem,
     554             :                           const unsigned int i,
     555             :                           const Point & p)
     556             : {
     557             : #if LIBMESH_DIM == 3
     558             : 
     559  1016787226 :   switch (order)
     560             :     {
     561             :       // linear Lagrange shape functions
     562   156159755 :     case FIRST:
     563             :       {
     564   156159755 :         switch (type)
     565             :           {
     566             :             // trilinear hexahedral shape functions
     567    83076088 :           case HEX8:
     568             :           case HEX20:
     569             :           case HEX27:
     570             :             {
     571    23678696 :               libmesh_assert_less (i, 8);
     572             : 
     573    83076088 :               return libMesh::detail::fe_lagrange_hex8_shape(i, p(0), p(1), p(2));
     574             :             }
     575             : 
     576             :             // linear tetrahedral shape functions
     577    62092164 :           case TET4:
     578             :           case TET10:
     579             :           case TET14:
     580             :             {
     581    15737976 :               libmesh_assert_less (i, 4);
     582    62092164 :               return libMesh::detail::fe_lagrange_tet4_shape(i, p(0), p(1), p(2));
     583             :             }
     584             : 
     585             :             // linear prism shape functions
     586     5780754 :           case PRISM6:
     587             :           case PRISM15:
     588             :           case PRISM18:
     589             :           case PRISM20:
     590             :           case PRISM21:
     591             :             {
     592     1737090 :               libmesh_assert_less (i, 6);
     593             : 
     594             :               // Compute prism shape functions as a tensor-product
     595             :               // of a triangle and an edge
     596             : 
     597     5780754 :               Point p2d(p(0),p(1));
     598     5780754 :               Real p1d = p(2);
     599             : 
     600             :               //                                0  1  2  3  4  5
     601             :               static const unsigned int i0[] = {0, 0, 0, 1, 1, 1};
     602             :               static const unsigned int i1[] = {0, 1, 2, 0, 1, 2};
     603             : 
     604     5780754 :               return (FE<2,LAGRANGE>::shape(TRI3,  FIRST, i1[i], p2d)*
     605     9824418 :                       fe_lagrange_1D_linear_shape(i0[i], p1d));
     606             :             }
     607             : 
     608             :             // linear pyramid shape functions
     609      330335 :           case PYRAMID5:
     610             :           case PYRAMID13:
     611             :           case PYRAMID14:
     612             :           case PYRAMID18:
     613             :             {
     614       93140 :               libmesh_assert_less (i, 5);
     615             : 
     616      330335 :               const Real xi   = p(0);
     617      330335 :               const Real eta  = p(1);
     618      330335 :               const Real zeta = p(2);
     619       93140 :               const Real eps  = 1.e-35;
     620             : 
     621      330335 :               switch(i)
     622             :                 {
     623       66067 :                 case 0:
     624       66067 :                   return .25*(zeta + xi - 1.)*(zeta + eta - 1.)/((1. - zeta) + eps);
     625             : 
     626       66067 :                 case 1:
     627       66067 :                   return .25*(zeta - xi - 1.)*(zeta + eta - 1.)/((1. - zeta) + eps);
     628             : 
     629       66067 :                 case 2:
     630       66067 :                   return .25*(zeta - xi - 1.)*(zeta - eta - 1.)/((1. - zeta) + eps);
     631             : 
     632       66067 :                 case 3:
     633       66067 :                   return .25*(zeta + xi - 1.)*(zeta - eta - 1.)/((1. - zeta) + eps);
     634             : 
     635       18628 :                 case 4:
     636       18628 :                   return zeta;
     637             : 
     638           0 :                 default:
     639           0 :                   libmesh_error_msg("Invalid i = " << i);
     640             :                 }
     641             :             }
     642             : 
     643     4880414 :           case C0POLYHEDRON:
     644             :             {
     645             :               // Polyhedra require using newer FE APIs
     646     4880414 :               if (!elem)
     647           0 :                 libmesh_error_msg("Code (see stack trace) used an outdated FE function overload.\n"
     648             :                                   "Shape functions on a polyhedron are not defined by ElemType alone.");
     649             : 
     650     1364801 :               libmesh_assert(elem->type() == C0POLYHEDRON);
     651             : 
     652     1364801 :               const C0Polyhedron & poly = *cast_ptr<const C0Polyhedron *>(elem);
     653             : 
     654             :               // We can't use a small tolerance here, because in
     655             :               // inverse_map() Newton might hand us intermediate
     656             :               // iterates outside the polyhedron.
     657     4880414 :               const auto [s, a, b, c] = poly.subelement_coordinates(p, 100);
     658     4880414 :               if (s == invalid_uint)
     659           0 :                 return 0;
     660     1364801 :               libmesh_assert_less(s, poly.n_subelements());
     661             : 
     662     4880414 :               const auto subtet = poly.subelement(s);
     663             : 
     664             :               // Avoid signed/unsigned comparison warnings
     665     4880414 :               const int nodei = i;
     666     4880414 :               if (nodei == subtet[0])
     667      578398 :                 return 1-a-b-c;
     668     4302016 :               if (nodei == subtet[1])
     669      578398 :                 return a;
     670     3723618 :               if (nodei == subtet[2])
     671      578398 :                 return b;
     672     3145220 :               if (nodei == subtet[3])
     673      578398 :                 return c;
     674             : 
     675             :               // Basis function i is not supported on p's subtet
     676      717733 :               return 0;
     677             :             }
     678             : 
     679           0 :           default:
     680           0 :             libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
     681             :           }
     682             :       }
     683             : 
     684             : 
     685             :       // quadratic Lagrange shape functions
     686   293655121 :     case SECOND:
     687             :       {
     688   293655121 :         switch (type)
     689             :           {
     690             : 
     691             :             // serendipity hexahedral quadratic shape functions
     692    22257160 :           case HEX20:
     693             :             {
     694     6207020 :               libmesh_assert_less (i, 20);
     695    22257160 :               return libMesh::detail::fe_lagrange_hex20_shape(i, p(0), p(1), p(2));
     696             :             }
     697             : 
     698             :             // triquadratic hexahedral shape functions
     699   111160431 :           case HEX8:
     700      859761 :             libmesh_assert_msg(T == L2_LAGRANGE,
     701             :                                "High order on first order elements only supported for L2 families");
     702             :             libmesh_fallthrough();
     703    42839820 :           case HEX27:
     704             :             {
     705    43823754 :               libmesh_assert_less (i, 27);
     706             : 
     707   154124424 :               return libMesh::detail::fe_lagrange_hex27_shape(i, p(0), p(1), p(2));
     708             :             }
     709             : 
     710             :             // quadratic tetrahedral shape functions
     711    35193050 :           case TET4:
     712       54360 :             libmesh_assert_msg(T == L2_LAGRANGE,
     713             :                                "High order on first order elements only supported for L2 families");
     714             :             libmesh_fallthrough();
     715    12078110 :           case TET10:
     716    12186800 :             libmesh_assert_less (i, 10);
     717             :             libmesh_fallthrough();
     718             :           case TET14:
     719             :             {
     720    13576570 :               libmesh_assert_less (i, 14);
     721    48715260 :               return libMesh::detail::fe_lagrange_tet10_shape(i, p(0), p(1), p(2));
     722             :             }
     723             : 
     724             :             // "serendipity" prism
     725    18605640 :           case PRISM15:
     726             :             {
     727     5641470 :               libmesh_assert_less (i, 15);
     728             : 
     729    18605640 :               const Real xi   = p(0);
     730    18605640 :               const Real eta  = p(1);
     731    18605640 :               const Real zeta = p(2);
     732             : 
     733    18605640 :               switch(i)
     734             :                 {
     735     1240376 :                 case 0:
     736     1240376 :                   return (1. - zeta)*(xi + eta - 1.)*(xi + eta + 0.5*zeta);
     737             : 
     738     1240376 :                 case 1:
     739     1240376 :                   return (1. - zeta)*xi*(xi - 1. - 0.5*zeta);
     740             : 
     741     1240376 :                 case 2: // phi1 with xi <- eta
     742     1240376 :                   return (1. - zeta)*eta*(eta - 1. - 0.5*zeta);
     743             : 
     744     1240376 :                 case 3: // phi0 with zeta <- (-zeta)
     745     1240376 :                   return (1. + zeta)*(xi + eta - 1.)*(xi + eta - 0.5*zeta);
     746             : 
     747     1240376 :                 case 4: // phi1 with zeta <- (-zeta)
     748     1240376 :                   return (1. + zeta)*xi*(xi - 1. + 0.5*zeta);
     749             : 
     750     1240376 :                 case 5: // phi4 with xi <- eta
     751     1240376 :                   return (1. + zeta)*eta*(eta - 1. + 0.5*zeta);
     752             : 
     753     1240376 :                 case 6:
     754     1240376 :                   return 2.*(1. - zeta)*xi*(1. - xi - eta);
     755             : 
     756     1240376 :                 case 7:
     757     1240376 :                   return 2.*(1. - zeta)*xi*eta;
     758             : 
     759     1240376 :                 case 8:
     760     1240376 :                   return 2.*(1. - zeta)*eta*(1. - xi - eta);
     761             : 
     762     1240376 :                 case 9:
     763     1240376 :                   return (1. - zeta)*(1. + zeta)*(1. - xi - eta);
     764             : 
     765     1240376 :                 case 10:
     766     1240376 :                   return (1. - zeta)*(1. + zeta)*xi;
     767             : 
     768     1240376 :                 case 11: // phi10 with xi <-> eta
     769     1240376 :                   return (1. - zeta)*(1. + zeta)*eta;
     770             : 
     771     1240376 :                 case 12: // phi6 with zeta <- (-zeta)
     772     1240376 :                   return 2.*(1. + zeta)*xi*(1. - xi - eta);
     773             : 
     774     1240376 :                 case 13: // phi7 with zeta <- (-zeta)
     775     1240376 :                   return 2.*(1. + zeta)*xi*eta;
     776             : 
     777     1240376 :                 case 14: // phi8 with zeta <- (-zeta)
     778     1240376 :                   return 2.*(1. + zeta)*eta*(1. - xi - eta);
     779             : 
     780           0 :                 default:
     781           0 :                   libmesh_error_msg("Invalid i = " << i);
     782             :                 }
     783             :             }
     784             : 
     785             :             // quadratic prism shape functions
     786    28545174 :           case PRISM6:
     787       80460 :             libmesh_assert_msg(T == L2_LAGRANGE,
     788             :                                "High order on first order elements only supported for L2 families");
     789             :             libmesh_fallthrough();
     790    12548304 :           case PRISM18:
     791             :           case PRISM20:
     792             :           case PRISM21:
     793             :             {
     794    12871620 :               libmesh_assert_less (i, 18);
     795             : 
     796             :               // Compute prism shape functions as a tensor-product
     797             :               // of a triangle and an edge
     798             : 
     799    41336334 :               Point p2d(p(0),p(1));
     800    41336334 :               Real p1d = p(2);
     801             : 
     802             :               //                                0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17
     803             :               static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2};
     804             :               static const unsigned int i1[] = {0, 1, 2, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 3, 4, 5};
     805             : 
     806    41336334 :               return (FE<2,LAGRANGE>::shape(TRI6,  SECOND, i1[i], p2d)*
     807    53132238 :                       fe_lagrange_1D_quadratic_shape(i0[i], p1d));
     808             :             }
     809             : 
     810             :             // G. Bedrosian, "Shape functions and integration formulas for
     811             :             // three-dimensional finite element analysis", Int. J. Numerical
     812             :             // Methods Engineering, vol 35, p. 95-108, 1992.
     813     4044911 :           case PYRAMID13:
     814             :             {
     815     1146548 :               libmesh_assert_less (i, 13);
     816             : 
     817     4044911 :               const Real xi   = p(0);
     818     4044911 :               const Real eta  = p(1);
     819     4044911 :               const Real zeta = p(2);
     820     1146548 :               const Real eps  = 1.e-35;
     821             : 
     822             :               // Denominators are perturbed by epsilon to avoid
     823             :               // divide-by-zero issues.
     824     4044911 :               Real den = (1. - zeta + eps);
     825             : 
     826     4044911 :               switch(i)
     827             :                 {
     828      311147 :                 case 0:
     829      311147 :                   return 0.25*(-xi - eta - 1.)*((1. - xi)*(1. - eta) - zeta + xi*eta*zeta/den);
     830             : 
     831      311147 :                 case 1:
     832      311147 :                   return 0.25*(-eta + xi - 1.)*((1. + xi)*(1. - eta) - zeta - xi*eta*zeta/den);
     833             : 
     834      311147 :                 case 2:
     835      311147 :                   return 0.25*(xi + eta - 1.)*((1. + xi)*(1. + eta) - zeta + xi*eta*zeta/den);
     836             : 
     837      311147 :                 case 3:
     838      311147 :                   return 0.25*(eta - xi - 1.)*((1. - xi)*(1. + eta) - zeta - xi*eta*zeta/den);
     839             : 
     840      311147 :                 case 4:
     841      311147 :                   return zeta*(2.*zeta - 1.);
     842             : 
     843      311147 :                 case 5:
     844      311147 :                   return 0.5*(1. + xi - zeta)*(1. - xi - zeta)*(1. - eta - zeta)/den;
     845             : 
     846      311147 :                 case 6:
     847      311147 :                   return 0.5*(1. + eta - zeta)*(1. - eta - zeta)*(1. + xi - zeta)/den;
     848             : 
     849      311147 :                 case 7:
     850      311147 :                   return 0.5*(1. + xi - zeta)*(1. - xi - zeta)*(1. + eta - zeta)/den;
     851             : 
     852      311147 :                 case 8:
     853      311147 :                   return 0.5*(1. + eta - zeta)*(1. - eta - zeta)*(1. - xi - zeta)/den;
     854             : 
     855      311147 :                 case 9:
     856      311147 :                   return zeta*(1. - xi - zeta)*(1. - eta - zeta)/den;
     857             : 
     858      311147 :                 case 10:
     859      311147 :                   return zeta*(1. + xi - zeta)*(1. - eta - zeta)/den;
     860             : 
     861      311147 :                 case 11:
     862      311147 :                   return zeta*(1. + eta - zeta)*(1. + xi - zeta)/den;
     863             : 
     864      311147 :                 case 12:
     865      311147 :                   return zeta*(1. - xi - zeta)*(1. + eta - zeta)/den;
     866             : 
     867           0 :                 default:
     868           0 :                   libmesh_error_msg("Invalid i = " << i);
     869             :                 }
     870             :             }
     871             : 
     872             :             // Quadratic shape functions, as defined in R. Graglia, "Higher order
     873             :             // bases on pyramidal elements", IEEE Trans Antennas and Propagation,
     874             :             // vol 47, no 5, May 1999.
     875     3276336 :           case PYRAMID5:
     876           0 :             libmesh_assert_msg(T == L2_LAGRANGE,
     877             :                                "High order on first order elements only supported for L2 families");
     878             :             libmesh_fallthrough();
     879     1295056 :           case PYRAMID14:
     880             :           case PYRAMID18:
     881             :             {
     882     1295056 :               libmesh_assert_less (i, 14);
     883             : 
     884     4571392 :               const Real xi   = p(0);
     885     4571392 :               const Real eta  = p(1);
     886     4571392 :               const Real zeta = p(2);
     887     1295056 :               const Real eps  = 1.e-35;
     888             : 
     889             :               // The "normalized coordinates" defined by Graglia.  These are
     890             :               // the planes which define the faces of the pyramid.
     891             :               Real
     892     4571392 :                 p1 = 0.5*(1. - eta - zeta), // back
     893     4571392 :                 p2 = 0.5*(1. + xi  - zeta), // left
     894     4571392 :                 p3 = 0.5*(1. + eta - zeta), // front
     895     4571392 :                 p4 = 0.5*(1. - xi  - zeta); // right
     896             : 
     897             :               // Denominators are perturbed by epsilon to avoid
     898             :               // divide-by-zero issues.
     899             :               Real
     900     4571392 :                 den = (-1. + zeta + eps),
     901     4571392 :                 den2 = den*den;
     902             : 
     903     4571392 :               switch(i)
     904             :                 {
     905      326528 :                 case 0:
     906      326528 :                   return p4*p1*(xi*eta - zeta + zeta*zeta)/den2;
     907             : 
     908      326528 :                 case 1:
     909      326528 :                   return -p1*p2*(xi*eta + zeta - zeta*zeta)/den2;
     910             : 
     911      326528 :                 case 2:
     912      326528 :                   return p2*p3*(xi*eta - zeta + zeta*zeta)/den2;
     913             : 
     914      326528 :                 case 3:
     915      326528 :                   return -p3*p4*(xi*eta + zeta - zeta*zeta)/den2;
     916             : 
     917      326528 :                 case 4:
     918      326528 :                   return zeta*(2.*zeta - 1.);
     919             : 
     920      326528 :                 case 5:
     921      326528 :                   return -4.*p2*p1*p4*eta/den2;
     922             : 
     923      326528 :                 case 6:
     924      326528 :                   return 4.*p1*p2*p3*xi/den2;
     925             : 
     926      326528 :                 case 7:
     927      326528 :                   return 4.*p2*p3*p4*eta/den2;
     928             : 
     929      326528 :                 case 8:
     930      326528 :                   return -4.*p3*p4*p1*xi/den2;
     931             : 
     932      326528 :                 case 9:
     933      326528 :                   return -4.*p1*p4*zeta/den;
     934             : 
     935      326528 :                 case 10:
     936      326528 :                   return -4.*p2*p1*zeta/den;
     937             : 
     938      326528 :                 case 11:
     939      326528 :                   return -4.*p3*p2*zeta/den;
     940             : 
     941      326528 :                 case 12:
     942      326528 :                   return -4.*p4*p3*zeta/den;
     943             : 
     944      326528 :                 case 13:
     945      326528 :                   return 16.*p1*p2*p3*p4/den2;
     946             : 
     947           0 :                 default:
     948           0 :                   libmesh_error_msg("Invalid i = " << i);
     949             :                 }
     950             :             }
     951             : 
     952             : 
     953           0 :           default:
     954           0 :             libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
     955             :           }
     956             :       }
     957             : 
     958   566972350 :     case THIRD:
     959             :       {
     960   566972350 :         switch (type)
     961             :           {
     962             :             // quadratic Lagrange shape functions with cubic bubbles
     963    28011720 :           case PRISM20:
     964             :             {
     965     8307120 :               libmesh_assert_less (i, 20);
     966             : 
     967             :               // Compute Prism21 shape functions as a tensor-product
     968             :               // of a triangle and an edge, then redistribute the
     969             :               // central bubble function over the other Tri6 nodes
     970             :               // around it (in a way consistent with the Tri7 shape
     971             :               // function definitions).
     972             :               //                                0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
     973             :               static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2, 0, 1};
     974             : 
     975    28011720 :               Point p2d(p(0),p(1));
     976    28011720 :               Real p1d = p(2);
     977             : 
     978    28011720 :               const Real mainval = FE<3,LAGRANGE>::shape(PRISM21, THIRD, i, p);
     979             : 
     980    28011720 :               if (i0[i] != 2)
     981     5814984 :                 return mainval;
     982             : 
     983     8403516 :               const Real bubbleval =
     984     8403516 :                 FE<2,LAGRANGE>::shape(TRI7, THIRD, 6, p2d) *
     985     2492136 :                 fe_lagrange_1D_quadratic_shape(2, p1d);
     986             : 
     987     8403516 :               if (i < 12) // vertices
     988     4201758 :                 return mainval - bubbleval / 9;
     989             : 
     990     4201758 :               return mainval + bubbleval * (Real(4) / 9);
     991             :             }
     992             : 
     993             :             // quadratic Lagrange shape functions with cubic bubbles
     994    72085470 :           case PRISM21:
     995             :             {
     996    21349086 :               libmesh_assert_less (i, 21);
     997             : 
     998             :               // Compute prism shape functions as a tensor-product
     999             :               // of a triangle and an edge
    1000             : 
    1001    72085470 :               Point p2d(p(0),p(1));
    1002    72085470 :               Real p1d = p(2);
    1003             : 
    1004             :               //                                0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20
    1005             :               static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2, 0, 1, 2};
    1006             :               static const unsigned int i1[] = {0, 1, 2, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 3, 4, 5, 6, 6, 6};
    1007             : 
    1008    72085470 :               return (FE<2,LAGRANGE>::shape(TRI7, THIRD, i1[i], p2d)*
    1009    91409082 :                       fe_lagrange_1D_quadratic_shape(i0[i], p1d));
    1010             :             }
    1011             : 
    1012             :             // Weird rational shape functions with weirder bubbles...
    1013    90004050 :           case PYRAMID18:
    1014             :             {
    1015    25210692 :               libmesh_assert_less (i, 18);
    1016             : 
    1017    90004050 :               const Real xi   = p(0);
    1018    90004050 :               const Real eta  = p(1);
    1019    90004050 :               const Real zeta = p(2);
    1020    25210692 :               const Real eps  = 1.e-35;
    1021             : 
    1022             :               // The "normalized coordinates" defined by Graglia.  These are
    1023             :               // the planes which define the faces of the pyramid.
    1024             :               const Real
    1025    90004050 :                 p1 = 0.5*(1. - eta - zeta), // back
    1026    90004050 :                 p2 = 0.5*(1. + xi  - zeta), // left
    1027    90004050 :                 p3 = 0.5*(1. + eta - zeta), // front
    1028    90004050 :                 p4 = 0.5*(1. - xi  - zeta); // right
    1029             : 
    1030             :               // Denominators are perturbed by epsilon to avoid
    1031             :               // divide-by-zero issues.
    1032             :               const Real
    1033    90004050 :                 den = (-1. + zeta + eps),
    1034    90004050 :                 den2 = den*den;
    1035             : 
    1036             :               // Bubble functions on triangular sides.  We actually
    1037             :               // have a degree of freedom to play with here, and I'm
    1038             :               // not certain how best to use it, so let's leave it
    1039             :               // as a variable in case we figure that out later.
    1040    25210692 :               constexpr Real alpha = 0.5;
    1041             :               const Real
    1042    90004050 :                 bub_f1 = ((1-alpha)*(1-zeta) + alpha*(-eta)),
    1043    90004050 :                 bub_f2 = ((1-alpha)*(1-zeta) + alpha*(xi)),
    1044    90004050 :                 bub_f3 = ((1-alpha)*(1-zeta) + alpha*(eta)),
    1045    90004050 :                 bub_f4 = ((1-alpha)*(1-zeta) + alpha*(-xi));
    1046             : 
    1047             :               const Real
    1048    90004050 :                 bub1 = bub_f1*p1*p2*p4*zeta/den2,
    1049    90004050 :                 bub2 = bub_f2*p1*p2*p3*zeta/den2,
    1050    90004050 :                 bub3 = bub_f3*p2*p3*p4*zeta/den2,
    1051    90004050 :                 bub4 = bub_f4*p1*p3*p4*zeta/den2;
    1052             : 
    1053    90004050 :               switch(i)
    1054             :                 {
    1055     5000225 :                 case 0:
    1056     5000225 :                   return p4*p1*(xi*eta - zeta + zeta*zeta)/den2 + 3*(bub1+bub4);
    1057             : 
    1058     5000225 :                 case 1:
    1059     5000225 :                   return -p1*p2*(xi*eta + zeta - zeta*zeta)/den2 + 3*(bub1+bub2);
    1060             : 
    1061     5000225 :                 case 2:
    1062     5000225 :                   return p2*p3*(xi*eta - zeta + zeta*zeta)/den2 + 3*(bub2+bub3);
    1063             : 
    1064     5000225 :                 case 3:
    1065     5000225 :                   return -p3*p4*(xi*eta + zeta - zeta*zeta)/den2 + 3*(bub3+bub4);
    1066             : 
    1067     5000225 :                 case 4:
    1068     5000225 :                   return zeta*(2.*zeta - 1.) + 3*(bub1+bub2+bub3+bub4);
    1069             : 
    1070     5000225 :                 case 5:
    1071     5000225 :                   return -4.*p2*p1*p4*eta/den2 - 12*bub1;
    1072             : 
    1073     5000225 :                 case 6:
    1074     5000225 :                   return 4.*p1*p2*p3*xi/den2 - 12*bub2;
    1075             : 
    1076     5000225 :                 case 7:
    1077     5000225 :                   return 4.*p2*p3*p4*eta/den2 - 12*bub3;
    1078             : 
    1079     5000225 :                 case 8:
    1080     5000225 :                   return -4.*p3*p4*p1*xi/den2 - 12*bub4;
    1081             : 
    1082     5000225 :                 case 9:
    1083     5000225 :                   return -4.*p1*p4*zeta/den - 12*(bub1+bub4);
    1084             : 
    1085     5000225 :                 case 10:
    1086     5000225 :                   return -4.*p2*p1*zeta/den - 12*(bub1+bub2);
    1087             : 
    1088     5000225 :                 case 11:
    1089     5000225 :                   return -4.*p3*p2*zeta/den - 12*(bub2+bub3);
    1090             : 
    1091     5000225 :                 case 12:
    1092     5000225 :                   return -4.*p4*p3*zeta/den - 12*(bub3+bub4);
    1093             : 
    1094     5000225 :                 case 13:
    1095     5000225 :                   return 16.*p1*p2*p3*p4/den2;
    1096             : 
    1097     5000225 :                 case 14:
    1098     5000225 :                   return 27*bub1;
    1099             : 
    1100     5000225 :                 case 15:
    1101     5000225 :                   return 27*bub2;
    1102             : 
    1103     5000225 :                 case 16:
    1104     5000225 :                   return 27*bub3;
    1105             : 
    1106     5000225 :                 case 17:
    1107     5000225 :                   return 27*bub4;
    1108             : 
    1109           0 :                 default:
    1110           0 :                   libmesh_error_msg("Invalid i = " << i);
    1111             :                 }
    1112             :             }
    1113             : 
    1114             :             // quadratic Lagrange shape functions with cubic bubbles
    1115   376871110 :           case TET14:
    1116             :             {
    1117    97469764 :               libmesh_assert_less (i, 14);
    1118   376871110 :               return libMesh::detail::fe_lagrange_tet14_shape(i, p(0), p(1), p(2));
    1119             :             }
    1120             : 
    1121           0 :           default:
    1122           0 :             libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
    1123             :           }
    1124             :       }
    1125             : 
    1126             :       // unsupported order
    1127           0 :     default:
    1128           0 :       libmesh_error_msg("ERROR: Unsupported 3D FE order!: " << order);
    1129             :     }
    1130             : 
    1131             : #else // LIBMESH_DIM != 3
    1132             :   libmesh_ignore(type, order, elem, i, p);
    1133             :   libmesh_not_implemented();
    1134             : #endif
    1135             : }
    1136             : 
    1137             : 
    1138             : 
    1139             : template <FEFamily T>
    1140  4982121918 : Real fe_lagrange_3D_shape_deriv(const ElemType type,
    1141             :                                 const Order order,
    1142             :                                 const Elem * elem,
    1143             :                                 const unsigned int i,
    1144             :                                 const unsigned int j,
    1145             :                                 const Point & p)
    1146             : {
    1147             : #if LIBMESH_DIM == 3
    1148             : 
    1149  1281527751 :   libmesh_assert_less (j, 3);
    1150             : 
    1151  4982121918 :   switch (order)
    1152             :     {
    1153             :       // linear Lagrange shape functions
    1154   257383374 :     case FIRST:
    1155             :       {
    1156   257383374 :         switch (type)
    1157             :           {
    1158             :             // trilinear hexahedral shape functions
    1159   222224472 :           case HEX8:
    1160             :           case HEX20:
    1161             :           case HEX27:
    1162             :             {
    1163    55834056 :               libmesh_assert_less (i, 8);
    1164             : 
    1165   222224472 :               return libMesh::detail::fe_lagrange_hex8_shape_deriv(i, j, p(0), p(1), p(2));
    1166             :             }
    1167             : 
    1168             :             // linear tetrahedral shape functions
    1169      341676 :           case TET4:
    1170             :           case TET10:
    1171             :           case TET14:
    1172             :             {
    1173      341676 :               libmesh_assert_less (i, 4);
    1174      714204 :               return libMesh::detail::fe_lagrange_tet4_shape_deriv(i, j);
    1175             :             }
    1176             : 
    1177             :             // linear prism shape functions
    1178    17863290 :           case PRISM6:
    1179             :           case PRISM15:
    1180             :           case PRISM18:
    1181             :           case PRISM20:
    1182             :           case PRISM21:
    1183             :             {
    1184     4980024 :               libmesh_assert_less (i, 6);
    1185             : 
    1186             :               // Compute prism shape functions as a tensor-product
    1187             :               // of a triangle and an edge
    1188             : 
    1189    17863290 :               Point p2d(p(0),p(1));
    1190    17863290 :               Real p1d = p(2);
    1191             : 
    1192             :               //                                0  1  2  3  4  5
    1193             :               static const unsigned int i0[] = {0, 0, 0, 1, 1, 1};
    1194             :               static const unsigned int i1[] = {0, 1, 2, 0, 1, 2};
    1195             : 
    1196    17863290 :               switch (j)
    1197             :                 {
    1198             :                   // d()/dxi
    1199     5954430 :                 case 0:
    1200     5954430 :                   return (FE<2,LAGRANGE>::shape_deriv(TRI3,  FIRST, i1[i], 0, p2d)*
    1201    10248852 :                           fe_lagrange_1D_linear_shape(i0[i], p1d));
    1202             : 
    1203             :                   // d()/deta
    1204     5954430 :                 case 1:
    1205     5954430 :                   return (FE<2,LAGRANGE>::shape_deriv(TRI3,  FIRST, i1[i], 1, p2d)*
    1206    10248852 :                           fe_lagrange_1D_linear_shape(i0[i], p1d));
    1207             : 
    1208             :                   // d()/dzeta
    1209     5954430 :                 case 2:
    1210     5954430 :                   return (FE<2,LAGRANGE>::shape(TRI3,  FIRST, i1[i], p2d)*
    1211     8101641 :                           fe_lagrange_1D_linear_shape_deriv(i0[i], 0, p1d));
    1212             : 
    1213           0 :                 default:
    1214           0 :                   libmesh_error_msg("Invalid shape function derivative j = " << j);
    1215             :                 }
    1216             :             }
    1217             : 
    1218             :             // linear pyramid shape functions
    1219     1134600 :           case PYRAMID5:
    1220             :           case PYRAMID13:
    1221             :           case PYRAMID14:
    1222             :           case PYRAMID18:
    1223             :             {
    1224      308040 :               libmesh_assert_less (i, 5);
    1225             : 
    1226     1134600 :               const Real xi   = p(0);
    1227     1134600 :               const Real eta  = p(1);
    1228     1134600 :               const Real zeta = p(2);
    1229      308040 :               const Real eps  = 1.e-35;
    1230             : 
    1231     1134600 :               switch (j)
    1232             :                 {
    1233             :                   // d/dxi
    1234      378200 :                 case 0:
    1235      378200 :                   switch(i)
    1236             :                     {
    1237       75640 :                     case 0:
    1238       75640 :                       return  .25*(zeta + eta - 1.)/((1. - zeta) + eps);
    1239             : 
    1240       75640 :                     case 1:
    1241       75640 :                       return -.25*(zeta + eta - 1.)/((1. - zeta) + eps);
    1242             : 
    1243       75640 :                     case 2:
    1244       75640 :                       return -.25*(zeta - eta - 1.)/((1. - zeta) + eps);
    1245             : 
    1246       75640 :                     case 3:
    1247       75640 :                       return  .25*(zeta - eta - 1.)/((1. - zeta) + eps);
    1248             : 
    1249       20536 :                     case 4:
    1250       20536 :                       return 0;
    1251             : 
    1252           0 :                     default:
    1253           0 :                       libmesh_error_msg("Invalid i = " << i);
    1254             :                     }
    1255             : 
    1256             : 
    1257             :                   // d/deta
    1258      378200 :                 case 1:
    1259      378200 :                   switch(i)
    1260             :                     {
    1261       75640 :                     case 0:
    1262       75640 :                       return  .25*(zeta + xi - 1.)/((1. - zeta) + eps);
    1263             : 
    1264       75640 :                     case 1:
    1265       75640 :                       return  .25*(zeta - xi - 1.)/((1. - zeta) + eps);
    1266             : 
    1267       75640 :                     case 2:
    1268       75640 :                       return -.25*(zeta - xi - 1.)/((1. - zeta) + eps);
    1269             : 
    1270       75640 :                     case 3:
    1271       75640 :                       return -.25*(zeta + xi - 1.)/((1. - zeta) + eps);
    1272             : 
    1273       20536 :                     case 4:
    1274       20536 :                       return 0;
    1275             : 
    1276           0 :                     default:
    1277           0 :                       libmesh_error_msg("Invalid i = " << i);
    1278             :                     }
    1279             : 
    1280             : 
    1281             :                   // d/dzeta
    1282      378200 :                 case 2:
    1283             :                   {
    1284             :                     // We computed the derivatives with general eps and
    1285             :                     // then let eps tend to zero in the numerators...
    1286             :                     Real
    1287      378200 :                       num = zeta*(2. - zeta) - 1.,
    1288      378200 :                       den = (1. - zeta + eps)*(1. - zeta + eps);
    1289             : 
    1290      378200 :                     switch(i)
    1291             :                       {
    1292      151280 :                       case 0:
    1293             :                       case 2:
    1294      151280 :                         return .25*(num + xi*eta)/den;
    1295             : 
    1296      151280 :                       case 1:
    1297             :                       case 3:
    1298      151280 :                         return .25*(num - xi*eta)/den;
    1299             : 
    1300       20536 :                       case 4:
    1301       20536 :                         return 1.;
    1302             : 
    1303           0 :                       default:
    1304           0 :                         libmesh_error_msg("Invalid i = " << i);
    1305             :                       }
    1306             :                   }
    1307             : 
    1308           0 :                 default:
    1309           0 :                   libmesh_error_msg("Invalid j = " << j);
    1310             :                 }
    1311             :             }
    1312             : 
    1313    15105036 :           case C0POLYHEDRON:
    1314             :             {
    1315             :               // Polyhedra require using newer FE APIs
    1316    15105036 :               if (!elem)
    1317           0 :                 libmesh_error_msg("Code (see stack trace) used an outdated FE function overload.\n"
    1318             :                                   "Shape functions on a polyhedron are not defined by ElemType alone.");
    1319             : 
    1320     3777384 :               libmesh_assert(elem->type() == C0POLYHEDRON);
    1321             : 
    1322     3777384 :               const C0Polyhedron & poly = *cast_ptr<const C0Polyhedron *>(elem);
    1323             : 
    1324             :               // We can't use a small tolerance here, because in
    1325             :               // inverse_map() Newton might hand us intermediate
    1326             :               // iterates outside the polyhedron.
    1327    15105036 :               const auto [s, a, b, c] = poly.subelement_coordinates(p, 100);
    1328    15105036 :               if (s == invalid_uint)
    1329           0 :                 return 0;
    1330     3777384 :               libmesh_assert_less(s, poly.n_subelements());
    1331             : 
    1332    15105036 :               const auto subtet = poly.subelement(s);
    1333             : 
    1334             :               // Find derivatives w.r.t. subtriangle barycentric
    1335             :               // coordinates
    1336     3777384 :               Real du_da = 0, du_db = 0, du_dc = 0;
    1337             : 
    1338             :               // Avoid signed/unsigned comparison warnings
    1339    15105036 :               const int nodei = i;
    1340    15105036 :               if (nodei == subtet[0])
    1341      447687 :                 du_da = du_db = du_dc = -1;
    1342    13314663 :               else if (nodei == subtet[1])
    1343      447687 :                 du_da = 1;
    1344    11524290 :               else if (nodei == subtet[2])
    1345      447687 :                 du_db = 1;
    1346     9733917 :               else if (nodei == subtet[3])
    1347      447687 :                 du_dc = 1;
    1348             :               else
    1349             :                 // Basis function i is not supported on p's subtet
    1350     1986636 :                 return 0;
    1351             : 
    1352             :               // We want to return derivatives with respect to
    1353             :               // xi/eta/zeta for the polyhedron, but what we
    1354             :               // calculated above are with respect to xi and eta
    1355             :               // coordinates for a master *triangle*.  We need to
    1356             :               // convert from one to the other.
    1357             : 
    1358     7161492 :               const auto master_points = poly.master_subelement(s);
    1359             : 
    1360     1790748 :               const RealTensor dXi_dA(
    1361     7161492 :                 master_points[1](0) - master_points[0](0), master_points[2](0) - master_points[0](0), master_points[3](0) - master_points[0](0),
    1362     7161492 :                 master_points[1](1) - master_points[0](1), master_points[2](1) - master_points[0](1), master_points[3](1) - master_points[0](1),
    1363     7161492 :                 master_points[1](2) - master_points[0](2), master_points[2](2) - master_points[0](2), master_points[3](2) - master_points[0](2));
    1364             : 
    1365             :               // When we vectorize this we'll want a full inverse, but
    1366             :               // when we're querying one component at a time it's
    1367             :               // cheaper to manually compute a single column.
    1368             :               // const RealTensor dabc_dxietazeta_dabc = dxietazeta_dabc.inverse();
    1369     7161492 :               const Real jac = dXi_dA.det();
    1370             : 
    1371     7161492 :               switch (j)
    1372             :                 {
    1373             :                   // d()/dxi
    1374      596916 :                 case 0:
    1375             :                   {
    1376     2387164 :                     const Real da_dxi =  (dXi_dA(2,2)*dXi_dA(1,1) - dXi_dA(2,1)*dXi_dA(1,2)) / jac;
    1377     2387164 :                     const Real db_dxi = -(dXi_dA(2,2)*dXi_dA(1,0) - dXi_dA(2,0)*dXi_dA(1,2)) / jac;
    1378     2387164 :                     const Real dc_dxi =  (dXi_dA(2,1)*dXi_dA(1,0) - dXi_dA(2,0)*dXi_dA(1,1)) / jac;
    1379     2387164 :                     return du_da*da_dxi + du_db*db_dxi + du_dc*dc_dxi;
    1380             :                   }
    1381             :                   // d()/deta
    1382      596916 :                 case 1:
    1383             :                   {
    1384     2387164 :                     const Real da_deta = -(dXi_dA(2,2)*dXi_dA(0,1) - dXi_dA(2,1)*dXi_dA(0,2) ) / jac;
    1385     2387164 :                     const Real db_deta =  (dXi_dA(2,2)*dXi_dA(0,0) - dXi_dA(2,0)*dXi_dA(0,2)) / jac;
    1386     2387164 :                     const Real dc_deta = -(dXi_dA(2,1)*dXi_dA(0,0) - dXi_dA(2,0)*dXi_dA(0,1)) / jac;
    1387     2387164 :                     return du_da*da_deta + du_db*db_deta + du_dc*dc_deta;
    1388             :                   }
    1389             :                   // d()/dzeta
    1390      596916 :                 case 2:
    1391             :                   {
    1392     2387164 :                     const Real da_dzeta =  (dXi_dA(1,2)*dXi_dA(0,1) - dXi_dA(1,1)*dXi_dA(0,2) ) / jac;
    1393     2387164 :                     const Real db_dzeta = -(dXi_dA(1,2)*dXi_dA(0,0) - dXi_dA(1,0)*dXi_dA(0,2)) / jac;
    1394     2387164 :                     const Real dc_dzeta =  (dXi_dA(1,1)*dXi_dA(0,0) - dXi_dA(1,0)*dXi_dA(0,1)) / jac;
    1395     2387164 :                     return du_da*da_dzeta + du_db*db_dzeta + du_dc*dc_dzeta;
    1396             :                   }
    1397           0 :                 default:
    1398           0 :                   libmesh_error_msg("ERROR: Invalid derivative index j = " << j);
    1399             :                 }
    1400             :             }
    1401             : 
    1402           0 :           default:
    1403           0 :             libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
    1404             :           }
    1405             :       }
    1406             : 
    1407             : 
    1408             :       // quadratic Lagrange shape functions
    1409  3155602662 :     case SECOND:
    1410             :       {
    1411  3155602662 :         switch (type)
    1412             :           {
    1413             : 
    1414             :             // serendipity hexahedral quadratic shape functions
    1415    72681660 :           case HEX20:
    1416             :             {
    1417    18295380 :               libmesh_assert_less (i, 20);
    1418    72681660 :               return libMesh::detail::fe_lagrange_hex20_shape_deriv(i, j, p(0), p(1), p(2));
    1419             :             }
    1420             : 
    1421             :             // triquadratic hexahedral shape functions
    1422  2061043866 :           case HEX8:
    1423     1152711 :             libmesh_assert_msg(T == L2_LAGRANGE,
    1424             :                                "High order on first order elements only supported for L2 families");
    1425             :             libmesh_fallthrough();
    1426   688484367 :           case HEX27:
    1427             :             {
    1428   689939613 :               libmesh_assert_less (i, 27);
    1429             : 
    1430  2749830768 :               return libMesh::detail::fe_lagrange_hex27_shape_deriv(i, j, p(0), p(1), p(2));
    1431             :             }
    1432             : 
    1433             :             // quadratic tetrahedral shape functions
    1434    96656370 :           case TET4:
    1435       20880 :             libmesh_assert_msg(T == L2_LAGRANGE,
    1436             :                                "High order on first order elements only supported for L2 families");
    1437             :             libmesh_fallthrough();
    1438    37165380 :           case TET10:
    1439             :           case TET14:
    1440             :             {
    1441    37670370 :               libmesh_assert_less (i, 10);
    1442   134305860 :               return libMesh::detail::fe_lagrange_tet10_shape_deriv(i, j, p(0), p(1), p(2));
    1443             :             }
    1444             : 
    1445             : 
    1446             :             // "serendipity" prism
    1447    58933440 :           case PRISM15:
    1448             :             {
    1449    16614540 :               libmesh_assert_less (i, 15);
    1450             : 
    1451    58933440 :               const Real xi   = p(0);
    1452    58933440 :               const Real eta  = p(1);
    1453    58933440 :               const Real zeta = p(2);
    1454             : 
    1455    58933440 :               switch (j)
    1456             :                 {
    1457             :                   // d()/dxi
    1458    19644480 :                 case 0:
    1459             :                   {
    1460    19644480 :                     switch(i)
    1461             :                       {
    1462     1309632 :                       case 0:
    1463     1309632 :                         return (2.*xi + 2.*eta + 0.5*zeta - 1.)*(1. - zeta);
    1464     1309632 :                       case 1:
    1465     1309632 :                         return (2.*xi - 1. - 0.5*zeta)*(1. - zeta);
    1466      369212 :                       case 2:
    1467      369212 :                         return 0.;
    1468     1309632 :                       case 3:
    1469     1309632 :                         return (2.*xi + 2.*eta - 0.5*zeta - 1.)*(1. + zeta);
    1470     1309632 :                       case 4:
    1471     1309632 :                         return (2.*xi - 1. + 0.5*zeta)*(1. + zeta);
    1472      369212 :                       case 5:
    1473      369212 :                         return 0.;
    1474     1309632 :                       case 6:
    1475     1309632 :                         return (4.*xi + 2.*eta - 2.)*(zeta - 1.);
    1476     1309632 :                       case 7:
    1477     1309632 :                         return -2.*(zeta - 1.)*eta;
    1478     1309632 :                       case 8:
    1479     1309632 :                         return 2.*(zeta - 1.)*eta;
    1480     1309632 :                       case 9:
    1481     1309632 :                         return (zeta - 1.)*(1. + zeta);
    1482     1309632 :                       case 10:
    1483     1309632 :                         return (1. - zeta)*(1. + zeta);
    1484      369212 :                       case 11:
    1485      369212 :                         return 0.;
    1486     1309632 :                       case 12:
    1487     1309632 :                         return (-4.*xi - 2.*eta + 2.)*(1. + zeta);
    1488     1309632 :                       case 13:
    1489     1309632 :                         return 2.*(1. + zeta)*eta;
    1490     1309632 :                       case 14:
    1491     1309632 :                         return -2.*(1. + zeta)*eta;
    1492           0 :                       default:
    1493           0 :                         libmesh_error_msg("Invalid i = " << i);
    1494             :                       }
    1495             :                   }
    1496             : 
    1497             :                   // d()/deta
    1498    19644480 :                 case 1:
    1499             :                   {
    1500    19644480 :                     switch(i)
    1501             :                       {
    1502     1309632 :                       case 0:
    1503     1309632 :                         return (2.*xi + 2.*eta + 0.5*zeta - 1.)*(1. - zeta);
    1504      369212 :                       case 1:
    1505      369212 :                         return 0.;
    1506     1309632 :                       case 2:
    1507     1309632 :                         return (2.*eta - 1. - 0.5*zeta)*(1. - zeta);
    1508     1309632 :                       case 3:
    1509     1309632 :                         return (2.*xi + 2.*eta - 0.5*zeta - 1.)*(1. + zeta);
    1510      369212 :                       case 4:
    1511      369212 :                         return 0.;
    1512     1309632 :                       case 5:
    1513     1309632 :                         return (2.*eta - 1. + 0.5*zeta)*(1. + zeta);
    1514     1309632 :                       case 6:
    1515     1309632 :                         return 2.*(zeta - 1.)*xi;
    1516     1309632 :                       case 7:
    1517     1309632 :                         return 2.*(1. - zeta)*xi;
    1518     1309632 :                       case 8:
    1519     1309632 :                         return (2.*xi + 4.*eta - 2.)*(zeta - 1.);
    1520     1309632 :                       case 9:
    1521     1309632 :                         return (zeta - 1.)*(1. + zeta);
    1522      369212 :                       case 10:
    1523      369212 :                         return 0.;
    1524     1309632 :                       case 11:
    1525     1309632 :                         return (1. - zeta)*(1. + zeta);
    1526     1309632 :                       case 12:
    1527     1309632 :                         return -2.*(1. + zeta)*xi;
    1528     1309632 :                       case 13:
    1529     1309632 :                         return 2.*(1. + zeta)*xi;
    1530     1309632 :                       case 14:
    1531     1309632 :                         return (-2.*xi - 4.*eta + 2.)*(1. + zeta);
    1532             : 
    1533           0 :                       default:
    1534           0 :                         libmesh_error_msg("Invalid i = " << i);
    1535             :                       }
    1536             :                   }
    1537             : 
    1538             :                   // d()/dzeta
    1539    19644480 :                 case 2:
    1540             :                   {
    1541    19644480 :                     switch(i)
    1542             :                       {
    1543     1309632 :                       case 0:
    1544     1309632 :                         return (-xi - eta - zeta + 0.5)*(xi + eta - 1.);
    1545     1309632 :                       case 1:
    1546     1309632 :                         return -0.5*xi*(2.*xi - 1. - 2.*zeta);
    1547     1309632 :                       case 2:
    1548     1309632 :                         return -0.5*eta*(2.*eta - 1. - 2.*zeta);
    1549     1309632 :                       case 3:
    1550     1309632 :                         return (xi + eta - zeta - 0.5)*(xi + eta - 1.);
    1551     1309632 :                       case 4:
    1552     1309632 :                         return 0.5*xi*(2.*xi - 1. + 2.*zeta);
    1553     1309632 :                       case 5:
    1554     1309632 :                         return 0.5*eta*(2.*eta - 1. + 2.*zeta);
    1555     1309632 :                       case 6:
    1556     1309632 :                         return 2.*xi*(xi + eta - 1.);
    1557     1309632 :                       case 7:
    1558     1309632 :                         return -2.*xi*eta;
    1559     1309632 :                       case 8:
    1560     1309632 :                         return 2.*eta*(xi + eta - 1.);
    1561     1309632 :                       case 9:
    1562     1309632 :                         return 2.*zeta*(xi + eta - 1.);
    1563     1309632 :                       case 10:
    1564     1309632 :                         return -2.*xi*zeta;
    1565     1309632 :                       case 11:
    1566     1309632 :                         return -2.*eta*zeta;
    1567     1309632 :                       case 12:
    1568     1309632 :                         return 2.*xi*(1. - xi - eta);
    1569     1309632 :                       case 13:
    1570     1309632 :                         return 2.*xi*eta;
    1571     1309632 :                       case 14:
    1572     1309632 :                         return 2.*eta*(1. - xi - eta);
    1573             : 
    1574           0 :                       default:
    1575           0 :                         libmesh_error_msg("Invalid i = " << i);
    1576             :                       }
    1577             :                   }
    1578             : 
    1579           0 :                 default:
    1580           0 :                   libmesh_error_msg("Invalid j = " << j);
    1581             :                 }
    1582             :             }
    1583             : 
    1584             : 
    1585             : 
    1586             :             // quadratic prism shape functions
    1587    79800444 :           case PRISM6:
    1588      206712 :             libmesh_assert_msg(T == L2_LAGRANGE,
    1589             :                                "High order on first order elements only supported for L2 families");
    1590             :             libmesh_fallthrough();
    1591    32217372 :           case PRISM18:
    1592             :           case PRISM20:
    1593             :           case PRISM21:
    1594             :             {
    1595    33044220 :               libmesh_assert_less (i, 18);
    1596             : 
    1597             :               // Compute prism shape functions as a tensor-product
    1598             :               // of a triangle and an edge
    1599             : 
    1600   112637952 :               Point p2d(p(0),p(1));
    1601   112637952 :               Real p1d = p(2);
    1602             : 
    1603             :               //                                0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17
    1604             :               static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2};
    1605             :               static const unsigned int i1[] = {0, 1, 2, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 3, 4, 5};
    1606             : 
    1607   112637952 :               switch (j)
    1608             :                 {
    1609             :                   // d()/dxi
    1610    37545984 :                 case 0:
    1611    37545984 :                   return (FE<2,LAGRANGE>::shape_deriv(TRI6,  SECOND, i1[i], 0, p2d)*
    1612    48560904 :                           fe_lagrange_1D_quadratic_shape(i0[i], p1d));
    1613             : 
    1614             :                   // d()/deta
    1615    37545984 :                 case 1:
    1616    37545984 :                   return (FE<2,LAGRANGE>::shape_deriv(TRI6,  SECOND, i1[i], 1, p2d)*
    1617    48560904 :                           fe_lagrange_1D_quadratic_shape(i0[i], p1d));
    1618             : 
    1619             :                   // d()/dzeta
    1620    37545984 :                 case 2:
    1621    37545984 :                   return (FE<2,LAGRANGE>::shape(TRI6,  SECOND, i1[i], p2d)*
    1622    64077228 :                           fe_lagrange_1D_quadratic_shape_deriv(i0[i], 0, p1d));
    1623             : 
    1624           0 :                 default:
    1625           0 :                   libmesh_error_msg("Invalid shape function derivative j = " << j);
    1626             :                 }
    1627             :             }
    1628             : 
    1629             :             // G. Bedrosian, "Shape functions and integration formulas for
    1630             :             // three-dimensional finite element analysis", Int. J. Numerical
    1631             :             // Methods Engineering, vol 35, p. 95-108, 1992.
    1632    12798162 :           case PYRAMID13:
    1633             :             {
    1634     3588468 :               libmesh_assert_less (i, 13);
    1635             : 
    1636    12798162 :               const Real xi   = p(0);
    1637    12798162 :               const Real eta  = p(1);
    1638    12798162 :               const Real zeta = p(2);
    1639     3588468 :               const Real eps  = 1.e-35;
    1640             : 
    1641             :               // Denominators are perturbed by epsilon to avoid
    1642             :               // divide-by-zero issues.
    1643             :               Real
    1644    12798162 :                 den = (-1. + zeta + eps),
    1645    12798162 :                 den2 = den*den,
    1646    12798162 :                 xi2 = xi*xi,
    1647    12798162 :                 eta2 = eta*eta,
    1648    12798162 :                 zeta2 = zeta*zeta,
    1649    12798162 :                 zeta3 = zeta2*zeta;
    1650             : 
    1651    12798162 :               switch (j)
    1652             :                 {
    1653             :                   // d/dxi
    1654     4266054 :                 case 0:
    1655     4266054 :                   switch(i)
    1656             :                     {
    1657      328158 :                     case 0:
    1658      328158 :                       return 0.25*(-zeta - eta + 2.*eta*zeta - 2.*xi + 2.*zeta*xi + 2.*eta*xi + zeta2 + eta2)/den;
    1659             : 
    1660      328158 :                     case 1:
    1661      328158 :                       return -0.25*(-zeta - eta + 2.*eta*zeta + 2.*xi - 2.*zeta*xi - 2.*eta*xi + zeta2 + eta2)/den;
    1662             : 
    1663      328158 :                     case 2:
    1664      328158 :                       return -0.25*(-zeta + eta - 2.*eta*zeta + 2.*xi - 2.*zeta*xi + 2.*eta*xi + zeta2 + eta2)/den;
    1665             : 
    1666      328158 :                     case 3:
    1667      328158 :                       return 0.25*(-zeta + eta - 2.*eta*zeta - 2.*xi + 2.*zeta*xi - 2.*eta*xi + zeta2 + eta2)/den;
    1668             : 
    1669       92012 :                     case 4:
    1670       92012 :                       return 0.;
    1671             : 
    1672      328158 :                     case 5:
    1673      328158 :                       return -(-1. + eta + zeta)*xi/den;
    1674             : 
    1675      328158 :                     case 6:
    1676      328158 :                       return 0.5*(-1. + eta + zeta)*(1. + eta - zeta)/den;
    1677             : 
    1678      328158 :                     case 7:
    1679      328158 :                       return (1. + eta - zeta)*xi/den;
    1680             : 
    1681      328158 :                     case 8:
    1682      328158 :                       return -0.5*(-1. + eta + zeta)*(1. + eta - zeta)/den;
    1683             : 
    1684      328158 :                     case 9:
    1685      328158 :                       return -(-1. + eta + zeta)*zeta/den;
    1686             : 
    1687      328158 :                     case 10:
    1688      328158 :                       return (-1. + eta + zeta)*zeta/den;
    1689             : 
    1690      328158 :                     case 11:
    1691      328158 :                       return -(1. + eta - zeta)*zeta/den;
    1692             : 
    1693      328158 :                     case 12:
    1694      328158 :                       return (1. + eta - zeta)*zeta/den;
    1695             : 
    1696           0 :                     default:
    1697           0 :                       libmesh_error_msg("Invalid i = " << i);
    1698             :                     }
    1699             : 
    1700             :                   // d/deta
    1701     4266054 :                 case 1:
    1702     4266054 :                   switch(i)
    1703             :                     {
    1704      328158 :                     case 0:
    1705      328158 :                       return 0.25*(-zeta - 2.*eta + 2.*eta*zeta - xi + 2.*zeta*xi + 2.*eta*xi + zeta2 + xi2)/den;
    1706             : 
    1707      328158 :                     case 1:
    1708      328158 :                       return -0.25*(zeta + 2.*eta - 2.*eta*zeta - xi + 2.*zeta*xi + 2.*eta*xi - zeta2 - xi2)/den;
    1709             : 
    1710      328158 :                     case 2:
    1711      328158 :                       return -0.25*(-zeta + 2.*eta - 2.*eta*zeta + xi - 2.*zeta*xi + 2.*eta*xi + zeta2 + xi2)/den;
    1712             : 
    1713      328158 :                     case 3:
    1714      328158 :                       return 0.25*(zeta - 2.*eta + 2.*eta*zeta + xi - 2.*zeta*xi + 2.*eta*xi - zeta2 - xi2)/den;
    1715             : 
    1716       92012 :                     case 4:
    1717       92012 :                       return 0.;
    1718             : 
    1719      328158 :                     case 5:
    1720      328158 :                       return -0.5*(-1. + xi + zeta)*(1. + xi - zeta)/den;
    1721             : 
    1722      328158 :                     case 6:
    1723      328158 :                       return (1. + xi - zeta)*eta/den;
    1724             : 
    1725      328158 :                     case 7:
    1726      328158 :                       return 0.5*(-1. + xi + zeta)*(1. + xi - zeta)/den;
    1727             : 
    1728      328158 :                     case 8:
    1729      328158 :                       return -(-1. + xi + zeta)*eta/den;
    1730             : 
    1731      328158 :                     case 9:
    1732      328158 :                       return -(-1. + xi + zeta)*zeta/den;
    1733             : 
    1734      328158 :                     case 10:
    1735      328158 :                       return (1. + xi - zeta)*zeta/den;
    1736             : 
    1737      328158 :                     case 11:
    1738      328158 :                       return -(1. + xi - zeta)*zeta/den;
    1739             : 
    1740      328158 :                     case 12:
    1741      328158 :                       return (-1. + xi + zeta)*zeta/den;
    1742             : 
    1743           0 :                     default:
    1744           0 :                       libmesh_error_msg("Invalid i = " << i);
    1745             :                     }
    1746             : 
    1747             :                   // d/dzeta
    1748     4266054 :                 case 2:
    1749             :                   {
    1750     4266054 :                     switch(i)
    1751             :                       {
    1752      328158 :                       case 0:
    1753      328158 :                         return -0.25*(xi + eta + 1.)*(-1. + 2.*zeta - zeta2 + eta*xi)/den2;
    1754             : 
    1755      328158 :                       case 1:
    1756      328158 :                         return 0.25*(eta - xi + 1.)*(1. - 2.*zeta + zeta2 + eta*xi)/den2;
    1757             : 
    1758      328158 :                       case 2:
    1759      328158 :                         return 0.25*(xi + eta - 1.)*(-1. + 2.*zeta - zeta2 + eta*xi)/den2;
    1760             : 
    1761      328158 :                       case 3:
    1762      328158 :                         return -0.25*(eta - xi - 1.)*(1. - 2.*zeta + zeta2 + eta*xi)/den2;
    1763             : 
    1764      328158 :                       case 4:
    1765      328158 :                         return 4.*zeta - 1.;
    1766             : 
    1767      328158 :                       case 5:
    1768      328158 :                         return 0.5*(-2 + eta + 6.*zeta + eta*xi2 + eta*zeta2 - 6.*zeta2 + 2.*zeta3 - 2.*eta*zeta)/den2;
    1769             : 
    1770      328158 :                       case 6:
    1771      328158 :                         return -0.5*(2 - 6.*zeta + xi + xi*zeta2 + eta2*xi + 6.*zeta2 - 2.*zeta3 - 2.*zeta*xi)/den2;
    1772             : 
    1773      328158 :                       case 7:
    1774      328158 :                         return -0.5*(2 + eta - 6.*zeta + eta*xi2 + eta*zeta2 + 6.*zeta2 - 2.*zeta3 - 2.*eta*zeta)/den2;
    1775             : 
    1776      328158 :                       case 8:
    1777      328158 :                         return 0.5*(-2 + 6.*zeta + xi + xi*zeta2 + eta2*xi - 6.*zeta2 + 2.*zeta3 - 2.*zeta*xi)/den2;
    1778             : 
    1779      328158 :                       case 9:
    1780      328158 :                         return (1. - eta - 4.*zeta - xi - xi*zeta2 - eta*zeta2 + eta*xi + 5.*zeta2 - 2.*zeta3 + 2.*eta*zeta + 2.*zeta*xi)/den2;
    1781             : 
    1782      328158 :                       case 10:
    1783      328158 :                         return -(-1. + eta + 4.*zeta - xi - xi*zeta2 + eta*zeta2 + eta*xi - 5.*zeta2 + 2.*zeta3 - 2.*eta*zeta + 2.*zeta*xi)/den2;
    1784             : 
    1785      328158 :                       case 11:
    1786      328158 :                         return (1. + eta - 4.*zeta + xi + xi*zeta2 + eta*zeta2 + eta*xi + 5.*zeta2 - 2.*zeta3 - 2.*eta*zeta - 2.*zeta*xi)/den2;
    1787             : 
    1788      328158 :                       case 12:
    1789      328158 :                         return -(-1. - eta + 4.*zeta + xi + xi*zeta2 - eta*zeta2 + eta*xi - 5.*zeta2 + 2.*zeta3 + 2.*eta*zeta - 2.*zeta*xi)/den2;
    1790             : 
    1791           0 :                       default:
    1792           0 :                         libmesh_error_msg("Invalid i = " << i);
    1793             :                       }
    1794             :                   }
    1795             : 
    1796           0 :                 default:
    1797           0 :                   libmesh_error_msg("Invalid j = " << j);
    1798             :                 }
    1799             :             }
    1800             : 
    1801             :             // Quadratic shape functions, as defined in R. Graglia, "Higher order
    1802             :             // bases on pyramidal elements", IEEE Trans Antennas and Propagation,
    1803             :             // vol 47, no 5, May 1999.
    1804    10374252 :           case PYRAMID5:
    1805           0 :             libmesh_assert_msg(T == L2_LAGRANGE,
    1806             :                                "High order on first order elements only supported for L2 families");
    1807             :             libmesh_fallthrough();
    1808     4040568 :           case PYRAMID14:
    1809             :           case PYRAMID18:
    1810             :             {
    1811     4040568 :               libmesh_assert_less (i, 14);
    1812             : 
    1813    14414820 :               const Real xi   = p(0);
    1814    14414820 :               const Real eta  = p(1);
    1815    14414820 :               const Real zeta = p(2);
    1816     4040568 :               const Real eps  = 1.e-35;
    1817             : 
    1818             :               // The "normalized coordinates" defined by Graglia.  These are
    1819             :               // the planes which define the faces of the pyramid.
    1820             :               Real
    1821    14414820 :                 p1 = 0.5*(1. - eta - zeta), // back
    1822    14414820 :                 p2 = 0.5*(1. + xi  - zeta), // left
    1823    14414820 :                 p3 = 0.5*(1. + eta - zeta), // front
    1824    14414820 :                 p4 = 0.5*(1. - xi  - zeta); // right
    1825             : 
    1826             :               // Denominators are perturbed by epsilon to avoid
    1827             :               // divide-by-zero issues.
    1828             :               Real
    1829    14414820 :                 den = (-1. + zeta + eps),
    1830    14414820 :                 den2 = den*den,
    1831    14414820 :                 den3 = den2*den;
    1832             : 
    1833    14414820 :               switch (j)
    1834             :                 {
    1835             :                   // d/dxi
    1836     4804940 :                 case 0:
    1837     4804940 :                   switch(i)
    1838             :                     {
    1839      343210 :                     case 0:
    1840      343210 :                       return 0.5*p1*(-xi*eta + zeta - zeta*zeta + 2.*p4*eta)/den2;
    1841             : 
    1842      343210 :                     case 1:
    1843      343210 :                       return -0.5*p1*(xi*eta + zeta - zeta*zeta + 2.*p2*eta)/den2;
    1844             : 
    1845      343210 :                     case 2:
    1846      343210 :                       return 0.5*p3*(xi*eta - zeta + zeta*zeta + 2.*p2*eta)/den2;
    1847             : 
    1848      343210 :                     case 3:
    1849      343210 :                       return -0.5*p3*(-xi*eta - zeta + zeta*zeta + 2.*p4*eta)/den2;
    1850             : 
    1851       96204 :                     case 4:
    1852       96204 :                       return 0.;
    1853             : 
    1854      343210 :                     case 5:
    1855      343210 :                       return 2.*p1*eta*xi/den2;
    1856             : 
    1857      343210 :                     case 6:
    1858      343210 :                       return 2.*p1*p3*(xi + 2.*p2)/den2;
    1859             : 
    1860      343210 :                     case 7:
    1861      343210 :                       return -2.*p3*eta*xi/den2;
    1862             : 
    1863      343210 :                     case 8:
    1864      343210 :                       return -2.*p1*p3*(-xi + 2.*p4)/den2;
    1865             : 
    1866      343210 :                     case 9:
    1867      343210 :                       return 2.*p1*zeta/den;
    1868             : 
    1869      343210 :                     case 10:
    1870      343210 :                       return -2.*p1*zeta/den;
    1871             : 
    1872      343210 :                     case 11:
    1873      343210 :                       return -2.*p3*zeta/den;
    1874             : 
    1875      343210 :                     case 12:
    1876      343210 :                       return 2.*p3*zeta/den;
    1877             : 
    1878      343210 :                     case 13:
    1879      343210 :                       return -8.*p1*p3*xi/den2;
    1880             : 
    1881           0 :                     default:
    1882           0 :                       libmesh_error_msg("Invalid i = " << i);
    1883             :                     }
    1884             : 
    1885             :                   // d/deta
    1886     4804940 :                 case 1:
    1887     4804940 :                   switch(i)
    1888             :                     {
    1889      343210 :                     case 0:
    1890      343210 :                       return -0.5*p4*(xi*eta - zeta + zeta*zeta - 2.*p1*xi)/den2;
    1891             : 
    1892      343210 :                     case 1:
    1893      343210 :                       return 0.5*p2*(xi*eta + zeta - zeta*zeta - 2.*p1*xi)/den2;
    1894             : 
    1895      343210 :                     case 2:
    1896      343210 :                       return 0.5*p2*(xi*eta - zeta + zeta*zeta + 2.*p3*xi)/den2;
    1897             : 
    1898      343210 :                     case 3:
    1899      343210 :                       return -0.5*p4*(xi*eta + zeta - zeta*zeta + 2.*p3*xi)/den2;
    1900             : 
    1901       96204 :                     case 4:
    1902       96204 :                       return 0.;
    1903             : 
    1904      343210 :                     case 5:
    1905      343210 :                       return 2.*p2*p4*(eta - 2.*p1)/den2;
    1906             : 
    1907      343210 :                     case 6:
    1908      343210 :                       return -2.*p2*xi*eta/den2;
    1909             : 
    1910      343210 :                     case 7:
    1911      343210 :                       return 2.*p2*p4*(eta + 2.*p3)/den2;
    1912             : 
    1913      343210 :                     case 8:
    1914      343210 :                       return 2.*p4*xi*eta/den2;
    1915             : 
    1916      343210 :                     case 9:
    1917      343210 :                       return 2.*p4*zeta/den;
    1918             : 
    1919      343210 :                     case 10:
    1920      343210 :                       return 2.*p2*zeta/den;
    1921             : 
    1922      343210 :                     case 11:
    1923      343210 :                       return -2.*p2*zeta/den;
    1924             : 
    1925      343210 :                     case 12:
    1926      343210 :                       return -2.*p4*zeta/den;
    1927             : 
    1928      343210 :                     case 13:
    1929      343210 :                       return -8.*p2*p4*eta/den2;
    1930             : 
    1931           0 :                     default:
    1932           0 :                       libmesh_error_msg("Invalid i = " << i);
    1933             :                     }
    1934             : 
    1935             : 
    1936             :                   // d/dzeta
    1937     4804940 :                 case 2:
    1938             :                   {
    1939     4804940 :                     switch(i)
    1940             :                       {
    1941      343210 :                       case 0:
    1942      343210 :                         return -0.5*p1*(xi*eta - zeta + zeta*zeta)/den2
    1943      343210 :                           - 0.5*p4*(xi*eta - zeta + zeta*zeta)/den2
    1944      343210 :                           + p4*p1*(2.*zeta - 1)/den2
    1945      343210 :                           - 2.*p4*p1*(xi*eta - zeta + zeta*zeta)/den3;
    1946             : 
    1947      343210 :                       case 1:
    1948      343210 :                         return 0.5*p2*(xi*eta + zeta - zeta*zeta)/den2
    1949      343210 :                           + 0.5*p1*(xi*eta + zeta - zeta*zeta)/den2
    1950      343210 :                           - p1*p2*(1 - 2.*zeta)/den2
    1951      343210 :                           + 2.*p1*p2*(xi*eta + zeta - zeta*zeta)/den3;
    1952             : 
    1953      343210 :                       case 2:
    1954      343210 :                         return -0.5*p3*(xi*eta - zeta + zeta*zeta)/den2
    1955      343210 :                           - 0.5*p2*(xi*eta - zeta + zeta*zeta)/den2
    1956      343210 :                           + p2*p3*(2.*zeta - 1)/den2
    1957      343210 :                           - 2.*p2*p3*(xi*eta - zeta + zeta*zeta)/den3;
    1958             : 
    1959      343210 :                       case 3:
    1960      343210 :                         return 0.5*p4*(xi*eta + zeta - zeta*zeta)/den2
    1961      343210 :                           + 0.5*p3*(xi*eta + zeta - zeta*zeta)/den2
    1962      343210 :                           - p3*p4*(1 - 2.*zeta)/den2
    1963      343210 :                           + 2.*p3*p4*(xi*eta + zeta - zeta*zeta)/den3;
    1964             : 
    1965      343210 :                       case 4:
    1966      343210 :                         return 4.*zeta - 1.;
    1967             : 
    1968      343210 :                       case 5:
    1969      343210 :                         return 2.*p4*p1*eta/den2
    1970      343210 :                           + 2.*p2*p4*eta/den2
    1971      343210 :                           + 2.*p1*p2*eta/den2
    1972      343210 :                           + 8.*p2*p1*p4*eta/den3;
    1973             : 
    1974      343210 :                       case 6:
    1975      343210 :                         return -2.*p2*p3*xi/den2
    1976      343210 :                           - 2.*p1*p3*xi/den2
    1977      343210 :                           - 2.*p1*p2*xi/den2
    1978      343210 :                           - 8.*p1*p2*p3*xi/den3;
    1979             : 
    1980      343210 :                       case 7:
    1981      343210 :                         return -2.*p3*p4*eta/den2
    1982      343210 :                           - 2.*p2*p4*eta/den2
    1983      343210 :                           - 2.*p2*p3*eta/den2
    1984      343210 :                           - 8.*p2*p3*p4*eta/den3;
    1985             : 
    1986      343210 :                       case 8:
    1987      343210 :                         return 2.*p4*p1*xi/den2
    1988      343210 :                           + 2.*p1*p3*xi/den2
    1989      343210 :                           + 2.*p3*p4*xi/den2
    1990      343210 :                           + 8.*p3*p4*p1*xi/den3;
    1991             : 
    1992      343210 :                       case 9:
    1993      343210 :                         return 2.*p4*zeta/den
    1994      343210 :                           + 2.*p1*zeta/den
    1995      343210 :                           - 4.*p1*p4/den
    1996      343210 :                           + 4.*p1*p4*zeta/den2;
    1997             : 
    1998      343210 :                       case 10:
    1999      343210 :                         return 2.*p1*zeta/den
    2000      343210 :                           + 2.*p2*zeta/den
    2001      343210 :                           - 4.*p2*p1/den
    2002      343210 :                           + 4.*p2*p1*zeta/den2;
    2003             : 
    2004      343210 :                       case 11:
    2005      343210 :                         return 2.*p2*zeta/den
    2006      343210 :                           + 2.*p3*zeta/den
    2007      343210 :                           - 4.*p3*p2/den
    2008      343210 :                           + 4.*p3*p2*zeta/den2;
    2009             : 
    2010      343210 :                       case 12:
    2011      343210 :                         return 2.*p3*zeta/den
    2012      343210 :                           + 2.*p4*zeta/den
    2013      343210 :                           - 4.*p4*p3/den
    2014      343210 :                           + 4.*p4*p3*zeta/den2;
    2015             : 
    2016      343210 :                       case 13:
    2017      343210 :                         return -8.*p2*p3*p4/den2
    2018      343210 :                           - 8.*p3*p4*p1/den2
    2019      343210 :                           - 8.*p2*p1*p4/den2
    2020      343210 :                           - 8.*p1*p2*p3/den2
    2021      343210 :                           - 32.*p1*p2*p3*p4/den3;
    2022             : 
    2023           0 :                       default:
    2024           0 :                         libmesh_error_msg("Invalid i = " << i);
    2025             :                       }
    2026             :                   }
    2027             : 
    2028           0 :                 default:
    2029           0 :                   libmesh_error_msg("Invalid j = " << j);
    2030             :                 }
    2031             :             }
    2032             : 
    2033             : 
    2034           0 :           default:
    2035           0 :             libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
    2036             :           }
    2037             :       }
    2038             : 
    2039  1569135882 :     case THIRD:
    2040             :       {
    2041  1569135882 :         switch (type)
    2042             :           {
    2043             :             // quadratic Lagrange shape functions with a cubic bubble
    2044  1216857054 :           case TET14:
    2045             :             {
    2046   315331128 :               libmesh_assert_less (i, 14);
    2047  1216857054 :               return libMesh::detail::fe_lagrange_tet14_shape_deriv(i, j, p(0), p(1), p(2));
    2048             :             }
    2049             : 
    2050    90657000 :           case PRISM20:
    2051             :             {
    2052    25206120 :               libmesh_assert_less (i, 20);
    2053             : 
    2054             :               //                                0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20
    2055             :               static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2, 0, 1, 2};
    2056             : 
    2057    90657000 :               Point p2d(p(0),p(1));
    2058    90657000 :               Real p1d = p(2);
    2059             : 
    2060    90657000 :               const Real mainval = FE<3,LAGRANGE>::shape_deriv(PRISM21, THIRD, i, j, p);
    2061             : 
    2062    90657000 :               if (i0[i] != 2)
    2063    17644284 :                 return mainval;
    2064             : 
    2065     7561836 :               Real bubbleval = 0;
    2066             : 
    2067     7561836 :               switch (j)
    2068             :                 {
    2069             :                   // d()/dxi
    2070     9065700 :                 case 0:
    2071     9065700 :                   bubbleval =
    2072     9065700 :                     FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, 6, 0, p2d)*
    2073     2520612 :                     fe_lagrange_1D_quadratic_shape(2, p1d);
    2074     9065700 :                   break;
    2075             : 
    2076             :                   // d()/deta
    2077     9065700 :                 case 1:
    2078     9065700 :                   bubbleval =
    2079     9065700 :                     FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, 6, 1, p2d)*
    2080     2520612 :                     fe_lagrange_1D_quadratic_shape(2, p1d);
    2081     9065700 :                   break;
    2082             : 
    2083             :                   // d()/dzeta
    2084     9065700 :                 case 2:
    2085     9065700 :                   bubbleval =
    2086     9065700 :                     FE<2,LAGRANGE>::shape(TRI7, THIRD, 6, p2d)*
    2087     2520612 :                     fe_lagrange_1D_quadratic_shape_deriv(2, 0, p1d);
    2088     9065700 :                   break;
    2089             : 
    2090           0 :                 default:
    2091           0 :                   libmesh_error_msg("Invalid shape function derivative j = " << j);
    2092             :                 }
    2093             : 
    2094    27197100 :               if (i < 12) // vertices
    2095    13598550 :                 return mainval - bubbleval / 9;
    2096             : 
    2097    13598550 :               return mainval + bubbleval * (Real(4) / 9);
    2098             :             }
    2099             : 
    2100   222184494 :           case PRISM21:
    2101             :             {
    2102    61526880 :               libmesh_assert_less (i, 21);
    2103             : 
    2104             :               // Compute prism shape functions as a tensor-product
    2105             :               // of a triangle and an edge
    2106             : 
    2107   222184494 :               Point p2d(p(0),p(1));
    2108   222184494 :               Real p1d = p(2);
    2109             : 
    2110             :               //                                0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20
    2111             :               static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2, 0, 1, 2};
    2112             :               static const unsigned int i1[] = {0, 1, 2, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 3, 4, 5, 6, 6, 6};
    2113             : 
    2114   222184494 :               switch (j)
    2115             :                 {
    2116             :                   // d()/dxi
    2117    74061498 :                 case 0:
    2118    74061498 :                   return (FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, i1[i], 0, p2d)*
    2119    94565640 :                           fe_lagrange_1D_quadratic_shape(i0[i], p1d));
    2120             : 
    2121             :                   // d()/deta
    2122    74061498 :                 case 1:
    2123    74061498 :                   return (FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, i1[i], 1, p2d)*
    2124    94565640 :                           fe_lagrange_1D_quadratic_shape(i0[i], p1d));
    2125             : 
    2126             :                   // d()/dzeta
    2127    74061498 :                 case 2:
    2128    74061498 :                   return (FE<2,LAGRANGE>::shape(TRI7, THIRD, i1[i], p2d)*
    2129   127614036 :                           fe_lagrange_1D_quadratic_shape_deriv(i0[i], 0, p1d));
    2130             : 
    2131           0 :                 default:
    2132           0 :                   libmesh_error_msg("Invalid shape function derivative j = " << j);
    2133             :                 }
    2134             :             }
    2135             : 
    2136    39437334 :           case PYRAMID18:
    2137             :             {
    2138    39437334 :               return fe_fdm_deriv(type, order, elem, i, j, p, fe_lagrange_3D_shape<T>);
    2139             :             }
    2140             : 
    2141           0 :           default:
    2142           0 :             libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
    2143             :           }
    2144             :       }
    2145             : 
    2146             :       // unsupported order
    2147           0 :     default:
    2148           0 :       libmesh_error_msg("ERROR: Unsupported 3D FE order!: " << order);
    2149             :     }
    2150             : 
    2151             : #else // LIBMESH_DIM != 3
    2152             :   libmesh_ignore(type, order, elem, i, j, p);
    2153             :   libmesh_not_implemented();
    2154             : #endif
    2155             : }
    2156             : 
    2157             : 
    2158             : 
    2159             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
    2160             : 
    2161             : template <FEFamily T>
    2162   729576726 : Real fe_lagrange_3D_shape_second_deriv(const ElemType type,
    2163             :                                        const Order order,
    2164             :                                        const Elem * elem,
    2165             :                                        const unsigned int i,
    2166             :                                        const unsigned int j,
    2167             :                                        const Point & p)
    2168             : {
    2169             : #if LIBMESH_DIM == 3
    2170             : 
    2171   179627976 :   libmesh_assert_less (j, 6);
    2172             : 
    2173   729576726 :   switch (order)
    2174             :     {
    2175             :       // linear Lagrange shape functions
    2176    62646576 :     case FIRST:
    2177             :       {
    2178    62646576 :         switch (type)
    2179             :           {
    2180             :             // Linear tets have all second derivatives = 0
    2181      191280 :           case TET4:
    2182             :           case TET10:
    2183             :           case TET14:
    2184             :             {
    2185      191280 :               return 0.;
    2186             :             }
    2187             : 
    2188             :             // The following elements use either tensor product or
    2189             :             // rational basis functions, and therefore probably have
    2190             :             // second derivatives, but we have not implemented them
    2191             :             // yet...
    2192     7391556 :           case PRISM6:
    2193             :           case PRISM15:
    2194             :           case PRISM18:
    2195             :           case PRISM20:
    2196             :           case PRISM21:
    2197             :             {
    2198     2054016 :               libmesh_assert_less (i, 6);
    2199             : 
    2200             :               // Compute prism shape functions as a tensor-product
    2201             :               // of a triangle and an edge
    2202             : 
    2203     7391556 :               Point p2d(p(0),p(1));
    2204     2054016 :               Real p1d = p(2);
    2205             : 
    2206             :               //                                0  1  2  3  4  5
    2207             :               static const unsigned int i0[] = {0, 0, 0, 1, 1, 1};
    2208             :               static const unsigned int i1[] = {0, 1, 2, 0, 1, 2};
    2209             : 
    2210     7391556 :               switch (j)
    2211             :                 {
    2212             :                   // All repeated second derivatives and the xi-eta derivative are zero on PRISMs
    2213     1369344 :                 case 0: // d^2()/dxi^2
    2214             :                 case 1: // d^2()/dxideta
    2215             :                 case 2: // d^2()/deta^2
    2216             :                 case 5: // d^2()/dzeta^2
    2217             :                   {
    2218     1369344 :                     return 0.;
    2219             :                   }
    2220             : 
    2221     1231926 :                 case 3: // d^2()/dxidzeta
    2222     1231926 :                   return (FE<2,LAGRANGE>::shape_deriv(TRI3,  FIRST, i1[i], 0, p2d)*
    2223     1676721 :                           fe_lagrange_1D_linear_shape_deriv(i0[i], 0, p1d));
    2224             : 
    2225     1231926 :                 case 4: // d^2()/detadzeta
    2226     1231926 :                   return (FE<2,LAGRANGE>::shape_deriv(TRI3,  FIRST, i1[i], 1, p2d)*
    2227     1676721 :                           fe_lagrange_1D_linear_shape_deriv(i0[i], 0, p1d));
    2228             : 
    2229           0 :                 default:
    2230           0 :                   libmesh_error_msg("Invalid j = " << j);
    2231             :                 }
    2232             :             }
    2233             : 
    2234      269340 :           case PYRAMID5:
    2235             :           case PYRAMID13:
    2236             :           case PYRAMID14:
    2237             :           case PYRAMID18:
    2238             :             {
    2239       72240 :               libmesh_assert_less (i, 5);
    2240             : 
    2241      269340 :               const Real xi   = p(0);
    2242      269340 :               const Real eta  = p(1);
    2243      269340 :               const Real zeta = p(2);
    2244       72240 :               const Real eps  = 1.e-35;
    2245             : 
    2246      269340 :               switch (j)
    2247             :                 {
    2248             :                   // xi-xi and eta-eta derivatives are all zero for PYRAMID5.
    2249       24080 :                 case 0: // d^2()/dxi^2
    2250             :                 case 2: // d^2()/deta^2
    2251       24080 :                   return 0.;
    2252             : 
    2253       44890 :                 case 1: // d^2()/dxideta
    2254             :                   {
    2255       44890 :                     switch (i)
    2256             :                       {
    2257       17956 :                       case 0:
    2258             :                       case 2:
    2259       17956 :                         return 0.25/(1. - zeta + eps);
    2260       17956 :                       case 1:
    2261             :                       case 3:
    2262       17956 :                         return -0.25/(1. - zeta + eps);
    2263        2408 :                       case 4:
    2264        2408 :                         return 0.;
    2265           0 :                       default:
    2266           0 :                         libmesh_error_msg("Invalid i = " << i);
    2267             :                       }
    2268             :                   }
    2269             : 
    2270       44890 :                 case 3: // d^2()/dxidzeta
    2271             :                   {
    2272       44890 :                     Real den = (1. - zeta + eps)*(1. - zeta + eps);
    2273             : 
    2274       44890 :                     switch (i)
    2275             :                       {
    2276       17956 :                       case 0:
    2277             :                       case 2:
    2278       17956 :                         return 0.25*eta/den;
    2279       17956 :                       case 1:
    2280             :                       case 3:
    2281       17956 :                         return -0.25*eta/den;
    2282        2408 :                       case 4:
    2283        2408 :                         return 0.;
    2284           0 :                       default:
    2285           0 :                         libmesh_error_msg("Invalid i = " << i);
    2286             :                       }
    2287             :                   }
    2288             : 
    2289       44890 :                 case 4: // d^2()/detadzeta
    2290             :                   {
    2291       44890 :                     Real den = (1. - zeta + eps)*(1. - zeta + eps);
    2292             : 
    2293       44890 :                     switch (i)
    2294             :                       {
    2295       17956 :                       case 0:
    2296             :                       case 2:
    2297       17956 :                         return 0.25*xi/den;
    2298       17956 :                       case 1:
    2299             :                       case 3:
    2300       17956 :                         return -0.25*xi/den;
    2301        2408 :                       case 4:
    2302        2408 :                         return 0.;
    2303           0 :                       default:
    2304           0 :                         libmesh_error_msg("Invalid i = " << i);
    2305             :                       }
    2306             :                   }
    2307             : 
    2308       44890 :                 case 5: // d^2()/dzeta^2
    2309             :                   {
    2310       44890 :                     Real den = (1. - zeta + eps)*(1. - zeta + eps)*(1. - zeta + eps);
    2311             : 
    2312       44890 :                     switch (i)
    2313             :                       {
    2314       17956 :                       case 0:
    2315             :                       case 2:
    2316       17956 :                         return 0.5*xi*eta/den;
    2317       17956 :                       case 1:
    2318             :                       case 3:
    2319       17956 :                         return -0.5*xi*eta/den;
    2320        2408 :                       case 4:
    2321        2408 :                         return 0.;
    2322           0 :                       default:
    2323           0 :                         libmesh_error_msg("Invalid i = " << i);
    2324             :                       }
    2325             :                   }
    2326             : 
    2327           0 :                 default:
    2328           0 :                   libmesh_error_msg("Invalid j = " << j);
    2329             :                 }
    2330             :             }
    2331             : 
    2332             :             // Trilinear shape functions on HEX8s have nonzero mixed second derivatives
    2333    48775776 :           case HEX8:
    2334             :           case HEX20:
    2335             :           case HEX27:
    2336             :             {
    2337    12197136 :               libmesh_assert_less (i, 8);
    2338    48775776 :               return libMesh::detail::fe_lagrange_hex8_shape_second_deriv(i, j, p(0), p(1), p(2));
    2339             :             }
    2340             : 
    2341             :           // All second derivatives for piecewise-linear polyhedra are
    2342             :           // zero or dirac-type distributions, but we can't put the
    2343             :           // latter in a Real, so beware when integrating...
    2344     1385676 :           case C0POLYHEDRON:
    2345             :             {
    2346     1385676 :               return 0.;
    2347             :             }
    2348             : 
    2349           0 :           default:
    2350           0 :             libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
    2351             :           }
    2352             : 
    2353             :       }
    2354             : 
    2355             :       // quadratic Lagrange shape functions
    2356   327471408 :     case SECOND:
    2357             :       {
    2358   327471408 :         switch (type)
    2359             :           {
    2360             : 
    2361             :             // serendipity hexahedral quadratic shape functions
    2362    24134400 :           case HEX20:
    2363             :             {
    2364     6033600 :               libmesh_assert_less (i, 20);
    2365    24134400 :               return libMesh::detail::fe_lagrange_hex20_shape_second_deriv(i, j, p(0), p(1), p(2));
    2366             :             }
    2367             : 
    2368             :             // triquadratic hexahedral shape functions
    2369   196069896 :           case HEX8:
    2370      625806 :             libmesh_assert_msg(T == L2_LAGRANGE,
    2371             :                                "High order on first order elements only supported for L2 families");
    2372             :             libmesh_fallthrough();
    2373    57787020 :           case HEX27:
    2374             :             {
    2375    59017896 :               libmesh_assert_less (i, 27);
    2376   254461986 :               return libMesh::detail::fe_lagrange_hex27_shape_second_deriv(i, j, p(0), p(1), p(2));
    2377             :             }
    2378             : 
    2379             :             // quadratic tetrahedral shape functions
    2380     1584060 :           case TET4:
    2381       41760 :             libmesh_assert_msg(T == L2_LAGRANGE,
    2382             :                                "High order on first order elements only supported for L2 families");
    2383             :             libmesh_fallthrough();
    2384      529560 :           case TET10:
    2385             :           case TET14:
    2386             :             {
    2387      617940 :               libmesh_assert_less (i, 10);
    2388     2160240 :               return libMesh::detail::fe_lagrange_tet10_shape_second_deriv(i, j);
    2389             :             }
    2390             : 
    2391             : 
    2392             : 
    2393             :             // "serendipity" prism
    2394    15507990 :           case PRISM15:
    2395             :             {
    2396     4315140 :               libmesh_assert_less (i, 15);
    2397             : 
    2398    15507990 :               const Real xi   = p(0);
    2399    15507990 :               const Real eta  = p(1);
    2400    15507990 :               const Real zeta = p(2);
    2401             : 
    2402    15507990 :               switch (j)
    2403             :                 {
    2404             :                   // d^2()/dxi^2
    2405     2584665 :                 case 0:
    2406             :                   {
    2407     2584665 :                     switch(i)
    2408             :                       {
    2409      344622 :                       case 0:
    2410             :                       case 1:
    2411      344622 :                         return 2.*(1. - zeta);
    2412      431514 :                       case 2:
    2413             :                       case 5:
    2414             :                       case 7:
    2415             :                       case 8:
    2416             :                       case 9:
    2417             :                       case 10:
    2418             :                       case 11:
    2419             :                       case 13:
    2420             :                       case 14:
    2421      431514 :                         return 0.;
    2422      344622 :                       case 3:
    2423             :                       case 4:
    2424      344622 :                         return 2.*(1. + zeta);
    2425      172311 :                       case 6:
    2426      172311 :                         return 4.*(zeta - 1);
    2427      172311 :                       case 12:
    2428      172311 :                         return -4.*(1. + zeta);
    2429           0 :                       default:
    2430           0 :                         libmesh_error_msg("Invalid i = " << i);
    2431             :                       }
    2432             :                   }
    2433             : 
    2434             :                   // d^2()/dxideta
    2435     2584665 :                 case 1:
    2436             :                   {
    2437     2584665 :                     switch(i)
    2438             :                       {
    2439      344622 :                       case 0:
    2440             :                       case 7:
    2441      344622 :                         return 2.*(1. - zeta);
    2442      335622 :                       case 1:
    2443             :                       case 2:
    2444             :                       case 4:
    2445             :                       case 5:
    2446             :                       case 9:
    2447             :                       case 10:
    2448             :                       case 11:
    2449      335622 :                         return 0.;
    2450      344622 :                       case 3:
    2451             :                       case 13:
    2452      344622 :                         return 2.*(1. + zeta);
    2453      344622 :                       case 6:
    2454             :                       case 8:
    2455      344622 :                         return 2.*(zeta - 1.);
    2456      344622 :                       case 12:
    2457             :                       case 14:
    2458      344622 :                         return -2.*(1. + zeta);
    2459           0 :                       default:
    2460           0 :                         libmesh_error_msg("Invalid i = " << i);
    2461             :                       }
    2462             :                   }
    2463             : 
    2464             :                   // d^2()/deta^2
    2465     2584665 :                 case 2:
    2466             :                   {
    2467     2584665 :                     switch(i)
    2468             :                       {
    2469      344622 :                       case 0:
    2470             :                       case 2:
    2471      344622 :                         return 2.*(1. - zeta);
    2472      431514 :                       case 1:
    2473             :                       case 4:
    2474             :                       case 6:
    2475             :                       case 7:
    2476             :                       case 9:
    2477             :                       case 10:
    2478             :                       case 11:
    2479             :                       case 12:
    2480             :                       case 13:
    2481      431514 :                         return 0.;
    2482      344622 :                       case 3:
    2483             :                       case 5:
    2484      344622 :                         return 2.*(1. + zeta);
    2485      172311 :                       case 8:
    2486      172311 :                         return 4.*(zeta - 1.);
    2487      172311 :                       case 14:
    2488      172311 :                         return -4.*(1. + zeta);
    2489           0 :                       default:
    2490           0 :                         libmesh_error_msg("Invalid i = " << i);
    2491             :                       }
    2492             :                   }
    2493             : 
    2494             :                   // d^2()/dxidzeta
    2495     2584665 :                 case 3:
    2496             :                   {
    2497     2584665 :                     switch(i)
    2498             :                       {
    2499      172311 :                       case 0:
    2500      172311 :                         return 1.5 - zeta - 2.*xi - 2.*eta;
    2501      172311 :                       case 1:
    2502      172311 :                         return 0.5 + zeta - 2.*xi;
    2503      143838 :                       case 2:
    2504             :                       case 5:
    2505             :                       case 11:
    2506      143838 :                         return 0.;
    2507      172311 :                       case 3:
    2508      172311 :                         return -1.5 - zeta + 2.*xi + 2.*eta;
    2509      172311 :                       case 4:
    2510      172311 :                         return -0.5 + zeta + 2.*xi;
    2511      172311 :                       case 6:
    2512      172311 :                         return 4.*xi + 2.*eta - 2.;
    2513      172311 :                       case 7:
    2514      172311 :                         return -2.*eta;
    2515      172311 :                       case 8:
    2516      172311 :                         return 2.*eta;
    2517      172311 :                       case 9:
    2518      172311 :                         return 2.*zeta;
    2519      172311 :                       case 10:
    2520      172311 :                         return -2.*zeta;
    2521      172311 :                       case 12:
    2522      172311 :                         return -4.*xi - 2.*eta + 2.;
    2523      172311 :                       case 13:
    2524      172311 :                         return 2.*eta;
    2525      172311 :                       case 14:
    2526      172311 :                         return -2.*eta;
    2527           0 :                       default:
    2528           0 :                         libmesh_error_msg("Invalid i = " << i);
    2529             :                       }
    2530             :                   }
    2531             : 
    2532             :                   // d^2()/detadzeta
    2533     2584665 :                 case 4:
    2534             :                   {
    2535     2584665 :                     switch(i)
    2536             :                       {
    2537      172311 :                       case 0:
    2538      172311 :                         return 1.5 - zeta - 2.*xi - 2.*eta;
    2539      143838 :                       case 1:
    2540             :                       case 4:
    2541             :                       case 10:
    2542      143838 :                         return 0.;
    2543      172311 :                       case 2:
    2544      172311 :                         return .5 + zeta - 2.*eta;
    2545      172311 :                       case 3:
    2546      172311 :                         return -1.5 - zeta + 2.*xi + 2.*eta;
    2547      172311 :                       case 5:
    2548      172311 :                         return -.5 + zeta + 2.*eta;
    2549      172311 :                       case 6:
    2550      172311 :                         return 2.*xi;
    2551      172311 :                       case 7:
    2552      172311 :                         return -2.*xi;
    2553      172311 :                       case 8:
    2554      172311 :                         return 2.*xi + 4.*eta - 2.;
    2555      172311 :                       case 9:
    2556      172311 :                         return 2.*zeta;
    2557      172311 :                       case 11:
    2558      172311 :                         return -2.*zeta;
    2559      172311 :                       case 12:
    2560      172311 :                         return -2.*xi;
    2561      172311 :                       case 13:
    2562      172311 :                         return 2.*xi;
    2563      172311 :                       case 14:
    2564      172311 :                         return -2.*xi - 4.*eta + 2.;
    2565           0 :                       default:
    2566           0 :                         libmesh_error_msg("Invalid i = " << i);
    2567             :                       }
    2568             :                   }
    2569             : 
    2570             :                   // d^2()/dzeta^2
    2571     2584665 :                 case 5:
    2572             :                   {
    2573     2584665 :                     switch(i)
    2574             :                       {
    2575      344622 :                       case 0:
    2576             :                       case 3:
    2577      344622 :                         return 1. - xi - eta;
    2578       95892 :                       case 1:
    2579             :                       case 4:
    2580       95892 :                         return xi;
    2581      344622 :                       case 2:
    2582             :                       case 5:
    2583      344622 :                         return eta;
    2584      575352 :                       case 6:
    2585             :                       case 7:
    2586             :                       case 8:
    2587             :                       case 12:
    2588             :                       case 13:
    2589             :                       case 14:
    2590      575352 :                         return 0.;
    2591      172311 :                       case 9:
    2592      172311 :                         return 2.*xi + 2.*eta - 2.;
    2593      172311 :                       case 10:
    2594      172311 :                         return -2.*xi;
    2595      172311 :                       case 11:
    2596      172311 :                         return -2.*eta;
    2597           0 :                       default:
    2598           0 :                         libmesh_error_msg("Invalid i = " << i);
    2599             :                       }
    2600             :                   }
    2601             : 
    2602           0 :                 default:
    2603           0 :                   libmesh_error_msg("Invalid j = " << j);
    2604             :                 }
    2605             :             }
    2606             : 
    2607             : 
    2608             : 
    2609             :             // quadratic prism shape functions
    2610    21499344 :           case PRISM6:
    2611      413424 :             libmesh_assert_msg(T == L2_LAGRANGE,
    2612             :                                "High order on first order elements only supported for L2 families");
    2613             :             libmesh_fallthrough();
    2614     6472872 :           case PRISM18:
    2615             :           case PRISM20:
    2616             :           case PRISM21:
    2617             :             {
    2618     8126568 :               libmesh_assert_less (i, 18);
    2619             : 
    2620             :               // Compute prism shape functions as a tensor-product
    2621             :               // of a triangle and an edge
    2622             : 
    2623    29212488 :               Point p2d(p(0),p(1));
    2624    29212488 :               Real p1d = p(2);
    2625             : 
    2626             :               //                                0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17
    2627             :               static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2};
    2628             :               static const unsigned int i1[] = {0, 1, 2, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 3, 4, 5};
    2629             : 
    2630    29212488 :               switch (j)
    2631             :                 {
    2632             :                   // d^2()/dxi^2
    2633     4868748 :                 case 0:
    2634     4868748 :                   return (FE<2,LAGRANGE>::shape_second_deriv(TRI6, SECOND, i1[i], 0, p2d)*
    2635     6223176 :                           fe_lagrange_1D_quadratic_shape(i0[i], p1d));
    2636             : 
    2637             :                   // d^2()/dxideta
    2638     4868748 :                 case 1:
    2639     4868748 :                   return (FE<2,LAGRANGE>::shape_second_deriv(TRI6, SECOND, i1[i], 1, p2d)*
    2640     6223176 :                           fe_lagrange_1D_quadratic_shape(i0[i], p1d));
    2641             : 
    2642             :                   // d^2()/deta^2
    2643     4868748 :                 case 2:
    2644     4868748 :                   return (FE<2,LAGRANGE>::shape_second_deriv(TRI6, SECOND, i1[i], 2, p2d)*
    2645     6223176 :                           fe_lagrange_1D_quadratic_shape(i0[i], p1d));
    2646             : 
    2647             :                   // d^2()/dxidzeta
    2648     4868748 :                 case 3:
    2649     4868748 :                   return (FE<2,LAGRANGE>::shape_deriv(TRI6,  SECOND, i1[i], 0, p2d)*
    2650     8383068 :                           fe_lagrange_1D_quadratic_shape_deriv(i0[i], 0, p1d));
    2651             : 
    2652             :                   // d^2()/detadzeta
    2653     4868748 :                 case 4:
    2654     4868748 :                   return (FE<2,LAGRANGE>::shape_deriv(TRI6,  SECOND, i1[i], 1, p2d)*
    2655     8383068 :                           fe_lagrange_1D_quadratic_shape_deriv(i0[i], 0, p1d));
    2656             : 
    2657             :                   // d^2()/dzeta^2
    2658     4868748 :                 case 5:
    2659     4868748 :                   return (FE<2,LAGRANGE>::shape(TRI6,  SECOND, i1[i], p2d)*
    2660     6040188 :                           fe_lagrange_1D_quadratic_shape_second_deriv(i0[i], 0, p1d));
    2661             : 
    2662           0 :                 default:
    2663           0 :                   libmesh_error_msg("Invalid shape function derivative j = " << j);
    2664             :                 }
    2665             :             }
    2666             : 
    2667             : 
    2668             :             // Quadratic shape functions, as defined in R. Graglia, "Higher order
    2669             :             // bases on pyramidal elements", IEEE Trans Antennas and Propagation,
    2670             :             // vol 47, no 5, May 1999.
    2671      899640 :           case PYRAMID5:
    2672           0 :             libmesh_assert_msg(T == L2_LAGRANGE,
    2673             :                                "High order on first order elements only supported for L2 families");
    2674             :             libmesh_fallthrough();
    2675      332136 :           case PYRAMID14:
    2676             :           case PYRAMID18:
    2677             :             {
    2678      332136 :               libmesh_assert_less (i, 14);
    2679             : 
    2680     1231776 :               const Real xi   = p(0);
    2681     1231776 :               const Real eta  = p(1);
    2682     1231776 :               const Real zeta = p(2);
    2683      332136 :               const Real eps  = 1.e-35;
    2684             : 
    2685             :               // The "normalized coordinates" defined by Graglia.  These are
    2686             :               // the planes which define the faces of the pyramid.
    2687             :               Real
    2688     1231776 :                 p1 = 0.5*(1. - eta - zeta), // back
    2689     1231776 :                 p2 = 0.5*(1. + xi  - zeta), // left
    2690     1231776 :                 p3 = 0.5*(1. + eta - zeta), // front
    2691     1231776 :                 p4 = 0.5*(1. - xi  - zeta); // right
    2692             : 
    2693             :               // Denominators are perturbed by epsilon to avoid
    2694             :               // divide-by-zero issues.
    2695             :               Real
    2696     1231776 :                 den = (-1. + zeta + eps),
    2697     1231776 :                 den2 = den*den,
    2698     1231776 :                 den3 = den2*den,
    2699     1231776 :                 den4 = den2*den2;
    2700             : 
    2701             :               // These terms are used in several of the derivatives
    2702             :               Real
    2703     1231776 :                 numer_mp = xi*eta - zeta + zeta*zeta,
    2704     1231776 :                 numer_pm = xi*eta + zeta - zeta*zeta;
    2705             : 
    2706     1231776 :               switch (j)
    2707             :                 {
    2708      205296 :                 case 0: // d^2()/dxi^2
    2709             :                   {
    2710      205296 :                     switch(i)
    2711             :                       {
    2712       29328 :                       case 0:
    2713             :                       case 1:
    2714       29328 :                         return -p1*eta/den2;
    2715       29328 :                       case 2:
    2716             :                       case 3:
    2717       29328 :                         return p3*eta/den2;
    2718       19770 :                       case 4:
    2719             :                       case 9:
    2720             :                       case 10:
    2721             :                       case 11:
    2722             :                       case 12:
    2723       19770 :                         return 0.;
    2724       14664 :                       case 5:
    2725       14664 :                         return 2.*p1*eta/den2;
    2726       29328 :                       case 6:
    2727             :                       case 8:
    2728       29328 :                         return 4.*p1*p3/den2;
    2729       14664 :                       case 7:
    2730       14664 :                         return -2.*p3*eta/den2;
    2731       14664 :                       case 13:
    2732       14664 :                         return -8.*p1*p3/den2;
    2733           0 :                       default:
    2734           0 :                         libmesh_error_msg("Invalid i = " << i);
    2735             :                       }
    2736             :                   }
    2737             : 
    2738      205296 :                 case 1: // d^2()/dxideta
    2739             :                   {
    2740      205296 :                     switch(i)
    2741             :                       {
    2742       14664 :                       case 0:
    2743       14664 :                         return 0.25*numer_mp/den2
    2744       14664 :                           - 0.5*p1*xi/den2
    2745       14664 :                           - 0.5*p4*eta/den2
    2746       14664 :                           + p4*p1/den2;
    2747             : 
    2748       14664 :                       case 1:
    2749       14664 :                         return 0.25*numer_pm/den2
    2750       14664 :                           - 0.5*p1*xi/den2
    2751       14664 :                           + 0.5*p2*eta/den2
    2752       14664 :                           - p1*p2/den2;
    2753             : 
    2754       14664 :                       case 2:
    2755       14664 :                         return 0.25*numer_mp/den2
    2756       14664 :                           + 0.5*p3*xi/den2
    2757       14664 :                           + 0.5*p2*eta/den2
    2758       14664 :                           + p2*p3/den2;
    2759             : 
    2760       14664 :                       case 3:
    2761       14664 :                         return 0.25*numer_pm/den2
    2762       14664 :                           + 0.5*p3*xi/den2
    2763       14664 :                           - 0.5*p4*eta/den2
    2764       14664 :                           - p3*p4/den2;
    2765             : 
    2766        3954 :                       case 4:
    2767        3954 :                         return 0.;
    2768             : 
    2769       14664 :                       case 5:
    2770       14664 :                         return p4*eta/den2
    2771       14664 :                           - 2.*p4*p1/den2
    2772       14664 :                           - p2*eta/den2
    2773       14664 :                           + 2.*p1*p2/den2;
    2774             : 
    2775       14664 :                       case 6:
    2776       14664 :                         return -p3*xi/den2
    2777       14664 :                           + p1*xi/den2
    2778       14664 :                           - 2.*p2*p3/den2
    2779       14664 :                           + 2.*p1*p2/den2;
    2780             : 
    2781       14664 :                       case 7:
    2782       14664 :                         return p4*eta/den2
    2783       14664 :                           + 2.*p3*p4/den2
    2784       14664 :                           - p2*eta/den2
    2785       14664 :                           - 2.*p2*p3/den2;
    2786             : 
    2787       14664 :                       case 8:
    2788       14664 :                         return -p3*xi/den2
    2789       14664 :                           + p1*xi/den2
    2790       14664 :                           - 2.*p4*p1/den2
    2791       14664 :                           + 2.*p3*p4/den2;
    2792             : 
    2793       29328 :                       case 9:
    2794             :                       case 11:
    2795       29328 :                         return -zeta/den;
    2796             : 
    2797       29328 :                       case 10:
    2798             :                       case 12:
    2799       29328 :                         return zeta/den;
    2800             : 
    2801       14664 :                       case 13:
    2802       14664 :                         return 4.*p4*p1/den2
    2803       14664 :                           - 4.*p3*p4/den2
    2804       14664 :                           + 4.*p2*p3/den2
    2805       14664 :                           - 4.*p1*p2/den2;
    2806             : 
    2807           0 :                       default:
    2808           0 :                         libmesh_error_msg("Invalid i = " << i);
    2809             :                       }
    2810             :                   }
    2811             : 
    2812             : 
    2813      205296 :                 case 2: // d^2()/deta^2
    2814             :                   {
    2815      205296 :                     switch(i)
    2816             :                       {
    2817       29328 :                       case 0:
    2818             :                       case 3:
    2819       29328 :                         return -p4*xi/den2;
    2820       29328 :                       case 1:
    2821             :                       case 2:
    2822       29328 :                         return p2*xi/den2;
    2823       19770 :                       case 4:
    2824             :                       case 9:
    2825             :                       case 10:
    2826             :                       case 11:
    2827             :                       case 12:
    2828       19770 :                         return 0.;
    2829       29328 :                       case 5:
    2830             :                       case 7:
    2831       29328 :                         return 4.*p2*p4/den2;
    2832       14664 :                       case 6:
    2833       14664 :                         return -2.*p2*xi/den2;
    2834       14664 :                       case 8:
    2835       14664 :                         return 2.*p4*xi/den2;
    2836       14664 :                       case 13:
    2837       14664 :                         return -8.*p2*p4/den2;
    2838           0 :                       default:
    2839           0 :                         libmesh_error_msg("Invalid i = " << i);
    2840             :                       }
    2841             :                   }
    2842             : 
    2843             : 
    2844      205296 :                 case 3: // d^2()/dxidzeta
    2845             :                   {
    2846      205296 :                     switch(i)
    2847             :                       {
    2848       14664 :                       case 0:
    2849       14664 :                         return 0.25*numer_mp/den2
    2850       14664 :                           - 0.5*p1*(2.*zeta - 1.)/den2
    2851       14664 :                           + p1*numer_mp/den3
    2852       14664 :                           - 0.5*p1*eta/den2
    2853       14664 :                           - 0.5*p4*eta/den2
    2854       14664 :                           - 2.*p4*p1*eta/den3;
    2855             : 
    2856       14664 :                       case 1:
    2857       14664 :                         return 0.25*numer_pm/den2
    2858       14664 :                           - 0.5*p1*(1 - 2.*zeta)/den2
    2859       14664 :                           + p1*numer_pm/den3
    2860       14664 :                           + 0.5*p2*eta/den2
    2861       14664 :                           + 0.5*p1*eta/den2
    2862       14664 :                           + 2.*p1*p2*eta/den3;
    2863             : 
    2864       14664 :                       case 2:
    2865       14664 :                         return -0.25*numer_mp/den2
    2866       14664 :                           + 0.5*p3*(2.*zeta - 1.)/den2
    2867       14664 :                           - p3*numer_mp/den3
    2868       14664 :                           - 0.5*p3*eta/den2
    2869       14664 :                           - 0.5*p2*eta/den2
    2870       14664 :                           - 2.*p2*p3*eta/den3;
    2871             : 
    2872       14664 :                       case 3:
    2873       14664 :                         return -0.25*numer_pm/den2
    2874       14664 :                           + 0.5*p3*(1 - 2.*zeta)/den2
    2875       14664 :                           - p3*numer_pm/den3
    2876       14664 :                           + 0.5*p4*eta/den2
    2877       14664 :                           + 0.5*p3*eta/den2
    2878       14664 :                           + 2.*p3*p4*eta/den3;
    2879             : 
    2880        3954 :                       case 4:
    2881        3954 :                         return 0.;
    2882             : 
    2883       14664 :                       case 5:
    2884       14664 :                         return p4*eta/den2
    2885       14664 :                           + 4.*p4*p1*eta/den3
    2886       14664 :                           - p2*eta/den2
    2887       14664 :                           - 4.*p1*p2*eta/den3;
    2888             : 
    2889       14664 :                       case 6:
    2890       14664 :                         return -p3*xi/den2
    2891       14664 :                           - p1*xi/den2
    2892       14664 :                           - 4.*p1*p3*xi/den3
    2893       14664 :                           - 2.*p2*p3/den2
    2894       14664 :                           - 2.*p1*p3/den2
    2895       14664 :                           - 2.*p1*p2/den2
    2896       14664 :                           - 8.*p1*p2*p3/den3;
    2897             : 
    2898       14664 :                       case 7:
    2899       14664 :                         return -p4*eta/den2
    2900       14664 :                           - 4.*p3*p4*eta/den3
    2901       14664 :                           + p2*eta/den2
    2902       14664 :                           + 4.*p2*p3*eta/den3;
    2903             : 
    2904       14664 :                       case 8:
    2905       14664 :                         return -p3*xi/den2
    2906       14664 :                           - p1*xi/den2
    2907       14664 :                           - 4.*p1*p3*xi/den3
    2908       14664 :                           + 2.*p4*p1/den2
    2909       14664 :                           + 2.*p1*p3/den2
    2910       14664 :                           + 2.*p3*p4/den2
    2911       14664 :                           + 8.*p3*p4*p1/den3;
    2912             : 
    2913       14664 :                       case 9:
    2914       14664 :                         return -zeta/den
    2915       14664 :                           + 2.*p1/den
    2916       14664 :                           - 2.*p1*zeta/den2;
    2917             : 
    2918       14664 :                       case 10:
    2919       14664 :                         return zeta/den
    2920       14664 :                           - 2.*p1/den
    2921       14664 :                           + 2.*p1*zeta/den2;
    2922             : 
    2923       14664 :                       case 11:
    2924       14664 :                         return zeta/den
    2925       14664 :                           - 2.*p3/den
    2926       14664 :                           + 2.*p3*zeta/den2;
    2927             : 
    2928       14664 :                       case 12:
    2929       14664 :                         return -zeta/den
    2930       14664 :                           + 2.*p3/den
    2931       14664 :                           - 2.*p3*zeta/den2;
    2932             : 
    2933       14664 :                       case 13:
    2934       14664 :                         return -4.*p4*p1/den2
    2935       14664 :                           - 4.*p3*p4/den2
    2936       14664 :                           - 16.*p3*p4*p1/den3
    2937       14664 :                           + 4.*p2*p3/den2
    2938       14664 :                           + 4.*p1*p2/den2
    2939       14664 :                           + 16.*p1*p2*p3/den3;
    2940             : 
    2941           0 :                       default:
    2942           0 :                         libmesh_error_msg("Invalid i = " << i);
    2943             :                       }
    2944             :                   }
    2945             : 
    2946      205296 :                 case 4: // d^2()/detadzeta
    2947             :                   {
    2948      205296 :                     switch(i)
    2949             :                       {
    2950       14664 :                       case 0:
    2951       14664 :                         return 0.25*numer_mp/den2
    2952       14664 :                           - 0.5*p4*(2.*zeta - 1.)/den2
    2953       14664 :                           + p4*numer_mp/den3
    2954       14664 :                           - 0.5*p1*xi/den2
    2955       14664 :                           - 0.5*p4*xi/den2
    2956       14664 :                           - 2.*p4*p1*xi/den3;
    2957             : 
    2958       14664 :                       case 1:
    2959       14664 :                         return -0.25*numer_pm/den2
    2960       14664 :                           + 0.5*p2*(1. - 2.*zeta)/den2
    2961       14664 :                           - p2*numer_pm/den3
    2962       14664 :                           + 0.5*p2*xi/den2
    2963       14664 :                           + 0.5*p1*xi/den2
    2964       14664 :                           + 2.*p1*p2*xi/den3;
    2965             : 
    2966       14664 :                       case 2:
    2967       14664 :                         return -0.25*numer_mp/den2
    2968       14664 :                           + 0.5*p2*(2.*zeta - 1.)/den2
    2969       14664 :                           - p2*numer_mp/den3
    2970       14664 :                           - 0.5*p3*xi/den2
    2971       14664 :                           - 0.5*p2*xi/den2
    2972       14664 :                           - 2.*p2*p3*xi/den3;
    2973             : 
    2974       14664 :                       case 3:
    2975       14664 :                         return 0.25*numer_pm/den2
    2976       14664 :                           - 0.5*p4*(1. - 2.*zeta)/den2
    2977       14664 :                           + p4*numer_pm/den3
    2978       14664 :                           + 0.5*p4*xi/den2
    2979       14664 :                           + 0.5*p3*xi/den2
    2980       14664 :                           + 2.*p3*p4*xi/den3;
    2981             : 
    2982        3954 :                       case 4:
    2983        3954 :                         return 0.;
    2984             : 
    2985       14664 :                       case 5:
    2986       14664 :                         return -p4*eta/den2
    2987       14664 :                           - p2*eta/den2
    2988       14664 :                           - 4.*p2*p4*eta/den3
    2989       14664 :                           + 2.*p4*p1/den2
    2990       14664 :                           + 2.*p2*p4/den2
    2991       14664 :                           + 2.*p1*p2/den2
    2992       14664 :                           + 8.*p2*p1*p4/den3;
    2993             : 
    2994       14664 :                       case 6:
    2995       14664 :                         return p3*xi/den2
    2996       14664 :                           + 4.*p2*p3*xi/den3
    2997       14664 :                           - p1*xi/den2
    2998       14664 :                           - 4.*p1*p2*xi/den3;
    2999             : 
    3000       14664 :                       case 7:
    3001       14664 :                         return -p4*eta/den2
    3002       14664 :                           - p2*eta/den2
    3003       14664 :                           - 4.*p2*p4*eta/den3
    3004       14664 :                           - 2.*p3*p4/den2
    3005       14664 :                           - 2.*p2*p4/den2
    3006       14664 :                           - 2.*p2*p3/den2
    3007       14664 :                           - 8.*p2*p3*p4/den3;
    3008             : 
    3009       14664 :                       case 8:
    3010       14664 :                         return p1*xi/den2
    3011       14664 :                           + 4.*p4*p1*xi/den3
    3012       14664 :                           - p3*xi/den2
    3013       14664 :                           - 4.*p3*p4*xi/den3;
    3014             : 
    3015       14664 :                       case 9:
    3016       14664 :                         return -zeta/den
    3017       14664 :                           + 2.*p4/den
    3018       14664 :                           - 2.*p4*zeta/den2;
    3019             : 
    3020       14664 :                       case 10:
    3021       14664 :                         return -zeta/den
    3022       14664 :                           + 2.*p2/den
    3023       14664 :                           - 2.*p2*zeta/den2;
    3024             : 
    3025       14664 :                       case 11:
    3026       14664 :                         return zeta/den
    3027       14664 :                           - 2.*p2/den
    3028       14664 :                           + 2.*p2*zeta/den2;
    3029             : 
    3030       14664 :                       case 12:
    3031       14664 :                         return zeta/den
    3032       14664 :                           - 2.*p4/den
    3033       14664 :                           + 2.*p4*zeta/den2;
    3034             : 
    3035       14664 :                       case 13:
    3036       14664 :                         return 4.*p3*p4/den2
    3037       14664 :                           + 4.*p2*p3/den2
    3038       14664 :                           + 16.*p2*p3*p4/den3
    3039       14664 :                           - 4.*p4*p1/den2
    3040       14664 :                           - 4.*p1*p2/den2
    3041       14664 :                           - 16.*p2*p1*p4/den3;
    3042             : 
    3043           0 :                       default:
    3044           0 :                         libmesh_error_msg("Invalid i = " << i);
    3045             :                       }
    3046             :                   }
    3047             : 
    3048      205296 :                 case 5: // d^2()/dzeta^2
    3049             :                   {
    3050      205296 :                     switch(i)
    3051             :                       {
    3052       14664 :                       case 0:
    3053       14664 :                         return 0.5*numer_mp/den2
    3054       14664 :                           - p1*(2.*zeta - 1.)/den2
    3055       14664 :                           + 2.*p1*numer_mp/den3
    3056       14664 :                           - p4*(2.*zeta - 1.)/den2
    3057       14664 :                           + 2.*p4*numer_mp/den3
    3058       14664 :                           + 2.*p4*p1/den2
    3059       14664 :                           - 4.*p4*p1*(2.*zeta - 1.)/den3
    3060       14664 :                           + 6.*p4*p1*numer_mp/den4;
    3061             : 
    3062       14664 :                       case 1:
    3063       14664 :                         return -0.5*numer_pm/den2
    3064       14664 :                           + p2*(1 - 2.*zeta)/den2
    3065       14664 :                           - 2.*p2*numer_pm/den3
    3066       14664 :                           + p1*(1 - 2.*zeta)/den2
    3067       14664 :                           - 2.*p1*numer_pm/den3
    3068       14664 :                           + 2.*p1*p2/den2
    3069       14664 :                           + 4.*p1*p2*(1 - 2.*zeta)/den3
    3070       14664 :                           - 6.*p1*p2*numer_pm/den4;
    3071             : 
    3072       14664 :                       case 2:
    3073       14664 :                         return 0.5*numer_mp/den2
    3074       14664 :                           - p3*(2.*zeta - 1.)/den2
    3075       14664 :                           + 2.*p3*numer_mp/den3
    3076       14664 :                           - p2*(2.*zeta - 1.)/den2
    3077       14664 :                           + 2.*p2*numer_mp/den3
    3078       14664 :                           + 2.*p2*p3/den2
    3079       14664 :                           - 4.*p2*p3*(2.*zeta - 1.)/den3
    3080       14664 :                           + 6.*p2*p3*numer_mp/den4;
    3081             : 
    3082       14664 :                       case 3:
    3083       14664 :                         return -0.5*numer_pm/den2
    3084       14664 :                           + p4*(1 - 2.*zeta)/den2
    3085       14664 :                           - 2.*p4*numer_pm/den3
    3086       14664 :                           + p3*(1 - 2.*zeta)/den2
    3087       14664 :                           - 2.*p3*numer_pm/den3
    3088       14664 :                           + 2.*p3*p4/den2
    3089       14664 :                           + 4.*p3*p4*(1 - 2.*zeta)/den3
    3090       14664 :                           - 6.*p3*p4*numer_pm/den4;
    3091             : 
    3092        3954 :                       case 4:
    3093        3954 :                         return 4.;
    3094             : 
    3095       14664 :                       case 5:
    3096       14664 :                         return -2.*p1*eta/den2
    3097       14664 :                           - 2.*p4*eta/den2
    3098       14664 :                           - 8.*p4*p1*eta/den3
    3099       14664 :                           - 2.*p2*eta/den2
    3100       14664 :                           - 8.*p2*p4*eta/den3
    3101       14664 :                           - 8.*p1*p2*eta/den3
    3102       14664 :                           - 24.*p2*p1*p4*eta/den4;
    3103             : 
    3104       14664 :                       case 6:
    3105       14664 :                         return 2.*p3*xi/den2
    3106       14664 :                           + 2.*p2*xi/den2
    3107       14664 :                           + 8.*p2*p3*xi/den3
    3108       14664 :                           + 2.*p1*xi/den2
    3109       14664 :                           + 8.*p1*p3*xi/den3
    3110       14664 :                           + 8.*p1*p2*xi/den3
    3111       14664 :                           + 24.*p1*p2*p3*xi/den4;
    3112             : 
    3113       14664 :                       case 7:
    3114       14664 :                         return 2.*p4*eta/den2
    3115       14664 :                           + 2.*p3*eta/den2
    3116       14664 :                           + 8.*p3*p4*eta/den3
    3117       14664 :                           + 2.*p2*eta/den2
    3118       14664 :                           + 8.*p2*p4*eta/den3
    3119       14664 :                           + 8.*p2*p3*eta/den3
    3120       14664 :                           + 24.*p2*p3*p4*eta/den4;
    3121             : 
    3122       14664 :                       case 8:
    3123       14664 :                         return -2.*p1*xi/den2
    3124       14664 :                           - 2.*p4*xi/den2
    3125       14664 :                           - 8.*p4*p1*xi/den3
    3126       14664 :                           - 2.*p3*xi/den2
    3127       14664 :                           - 8.*p1*p3*xi/den3
    3128       14664 :                           - 8.*p3*p4*xi/den3
    3129       14664 :                           - 24.*p3*p4*p1*xi/den4;
    3130             : 
    3131       14664 :                       case 9:
    3132       14664 :                         return -2.*zeta/den
    3133       14664 :                           + 4.*p4/den
    3134       14664 :                           - 4.*p4*zeta/den2
    3135       14664 :                           + 4.*p1/den
    3136       14664 :                           - 4.*p1*zeta/den2
    3137       14664 :                           + 8.*p4*p1/den2
    3138       14664 :                           - 8.*p1*p4*zeta/den3;
    3139             : 
    3140       14664 :                       case 10:
    3141       14664 :                         return -2.*zeta/den
    3142       14664 :                           + 4.*p1/den
    3143       14664 :                           - 4.*p1*zeta/den2
    3144       14664 :                           + 4.*p2/den
    3145       14664 :                           - 4.*p2*zeta/den2
    3146       14664 :                           + 8.*p1*p2/den2
    3147       14664 :                           - 8.*p2*p1*zeta/den3;
    3148             : 
    3149       14664 :                       case 11:
    3150       14664 :                         return -2.*zeta/den
    3151       14664 :                           + 4.*p2/den
    3152       14664 :                           - 4.*p2*zeta/den2
    3153       14664 :                           + 4.*p3/den
    3154       14664 :                           - 4.*p3*zeta/den2
    3155       14664 :                           + 8.*p2*p3/den2
    3156       14664 :                           - 8.*p3*p2*zeta/den3;
    3157             : 
    3158       14664 :                       case 12:
    3159       14664 :                         return -2.*zeta/den
    3160       14664 :                           + 4.*p3/den
    3161       14664 :                           - 4.*p3*zeta/den2
    3162       14664 :                           + 4.*p4/den
    3163       14664 :                           - 4.*p4*zeta/den2
    3164       14664 :                           + 8.*p3*p4/den2
    3165       14664 :                           - 8.*p4*p3*zeta/den3;
    3166             : 
    3167       14664 :                       case 13:
    3168       14664 :                         return 8.*p3*p4/den2
    3169       14664 :                           + 8.*p2*p4/den2
    3170       14664 :                           + 8.*p2*p3/den2
    3171       14664 :                           + 32.*p2*p3*p4/den3
    3172       14664 :                           + 8.*p4*p1/den2
    3173       14664 :                           + 8.*p1*p3/den2
    3174       14664 :                           + 32.*p3*p4*p1/den3
    3175       14664 :                           + 8.*p1*p2/den2
    3176       14664 :                           + 32.*p2*p1*p4/den3
    3177       14664 :                           + 32.*p1*p2*p3/den3
    3178       14664 :                           + 96.*p1*p2*p3*p4/den4;
    3179             : 
    3180           0 :                       default:
    3181           0 :                         libmesh_error_msg("Invalid i = " << i);
    3182             :                       }
    3183             :                   }
    3184             : 
    3185           0 :                 default:
    3186           0 :                   libmesh_error_msg("Invalid j = " << j);
    3187             :                 }
    3188             :             }
    3189             : 
    3190             :             // G. Bedrosian, "Shape functions and integration formulas for
    3191             :             // three-dimensional finite element analysis", Int. J. Numerical
    3192             :             // Methods Engineering, vol 35, p. 95-108, 1992.
    3193      762528 :           case PYRAMID13:
    3194             :             {
    3195      205608 :               libmesh_assert_less (i, 13);
    3196             : 
    3197      762528 :               const Real xi   = p(0);
    3198      762528 :               const Real eta  = p(1);
    3199      762528 :               const Real zeta = p(2);
    3200      205608 :               const Real eps  = 1.e-35;
    3201             : 
    3202             :               // Denominators are perturbed by epsilon to avoid
    3203             :               // divide-by-zero issues.
    3204             :               Real
    3205      762528 :                 den = (-1. + zeta + eps),
    3206      762528 :                 den2 = den*den,
    3207      762528 :                 den3 = den2*den,
    3208      762528 :                 xi2 = xi*xi,
    3209      762528 :                 eta2 = eta*eta,
    3210      762528 :                 zeta2 = zeta*zeta,
    3211      762528 :                 zeta3 = zeta2*zeta;
    3212             : 
    3213      762528 :               switch (j)
    3214             :                 {
    3215      127088 :                 case 0: // d^2()/dxi^2
    3216             :                   {
    3217      127088 :                     switch(i)
    3218             :                       {
    3219       19552 :                       case 0:
    3220             :                       case 1:
    3221       19552 :                         return 0.5*(-1. + zeta + eta)/den;
    3222             : 
    3223       19552 :                       case 2:
    3224             :                       case 3:
    3225       19552 :                         return 0.5*(-1. + zeta - eta)/den;
    3226             : 
    3227       18452 :                       case 4:
    3228             :                       case 6:
    3229             :                       case 8:
    3230             :                       case 9:
    3231             :                       case 10:
    3232             :                       case 11:
    3233             :                       case 12:
    3234       18452 :                         return 0.;
    3235             : 
    3236        9776 :                       case 5:
    3237        9776 :                         return (1. - eta - zeta)/den;
    3238             : 
    3239        9776 :                       case 7:
    3240        9776 :                         return (1. + eta - zeta)/den;
    3241             : 
    3242           0 :                       default:
    3243           0 :                         libmesh_error_msg("Invalid i = " << i);
    3244             :                       }
    3245             :                   }
    3246             : 
    3247      127088 :                 case 1: // d^2()/dxideta
    3248             :                   {
    3249      127088 :                     switch(i)
    3250             :                       {
    3251        9776 :                       case 0:
    3252        9776 :                         return  0.25*(-1. + 2.*zeta + 2.*xi + 2.*eta)/den;
    3253             : 
    3254        9776 :                       case 1:
    3255        9776 :                         return -0.25*(-1. + 2.*zeta - 2.*xi + 2.*eta)/den;
    3256             : 
    3257        9776 :                       case 2:
    3258        9776 :                         return -0.25*(1. - 2.*zeta + 2.*xi + 2.*eta)/den;
    3259             : 
    3260        9776 :                       case 3:
    3261        9776 :                         return  0.25*(1. - 2.*zeta - 2.*xi + 2.*eta)/den;
    3262             : 
    3263        2636 :                       case 4:
    3264        2636 :                         return 0.;
    3265             : 
    3266        9776 :                       case 5:
    3267        9776 :                         return -xi/den;
    3268             : 
    3269        9776 :                       case 6:
    3270        9776 :                         return eta/den;
    3271             : 
    3272        9776 :                       case 7:
    3273        9776 :                         return xi/den;
    3274             : 
    3275        9776 :                       case 8:
    3276        9776 :                         return -eta/den;
    3277             : 
    3278        9776 :                       case 9:
    3279        9776 :                         return -zeta/den;
    3280             : 
    3281        9776 :                       case 10:
    3282        9776 :                         return zeta/den;
    3283             : 
    3284        9776 :                       case 11:
    3285        9776 :                         return -zeta/den;
    3286             : 
    3287        9776 :                       case 12:
    3288        9776 :                         return zeta/den;
    3289             : 
    3290           0 :                       default:
    3291           0 :                         libmesh_error_msg("Invalid i = " << i);
    3292             :                       }
    3293             :                   }
    3294             : 
    3295             : 
    3296      127088 :                 case 2: // d^2()/deta^2
    3297             :                   {
    3298      127088 :                     switch(i)
    3299             :                       {
    3300       19552 :                       case 0:
    3301             :                       case 3:
    3302       19552 :                         return 0.5*(-1. + zeta + xi)/den;
    3303             : 
    3304       19552 :                       case 1:
    3305             :                       case 2:
    3306       19552 :                         return 0.5*(-1. + zeta - xi)/den;
    3307             : 
    3308       18452 :                       case 4:
    3309             :                       case 5:
    3310             :                       case 7:
    3311             :                       case 9:
    3312             :                       case 10:
    3313             :                       case 11:
    3314             :                       case 12:
    3315       18452 :                         return 0.;
    3316             : 
    3317        9776 :                       case 6:
    3318        9776 :                         return (1. + xi - zeta)/den;
    3319             : 
    3320        9776 :                       case 8:
    3321        9776 :                         return (1. - xi - zeta)/den;
    3322             : 
    3323           0 :                       default:
    3324           0 :                         libmesh_error_msg("Invalid i = " << i);
    3325             :                       }
    3326             :                   }
    3327             : 
    3328             : 
    3329      127088 :                 case 3: // d^2()/dxidzeta
    3330             :                   {
    3331      127088 :                     switch(i)
    3332             :                       {
    3333        9776 :                       case 0:
    3334        9776 :                         return -0.25*(-1. + 2.*zeta - zeta2 + eta + 2.*eta*xi + eta2)/den2;
    3335             : 
    3336        9776 :                       case 1:
    3337        9776 :                         return 0.25*(-1. + 2.*zeta - zeta2 + eta - 2.*eta*xi + eta2)/den2;
    3338             : 
    3339        9776 :                       case 2:
    3340        9776 :                         return 0.25*(-1. + 2.*zeta - zeta2 - eta + 2.*eta*xi + eta2)/den2;
    3341             : 
    3342        9776 :                       case 3:
    3343        9776 :                         return -0.25*(-1. + 2.*zeta - zeta2 - eta - 2.*eta*xi + eta2)/den2;
    3344             : 
    3345        2636 :                       case 4:
    3346        2636 :                         return 0.;
    3347             : 
    3348        9776 :                       case 5:
    3349        9776 :                         return eta*xi/den2;
    3350             : 
    3351        9776 :                       case 6:
    3352        9776 :                         return -0.5*(1. + zeta2 + eta2 - 2.*zeta)/den2;
    3353             : 
    3354        9776 :                       case 7:
    3355        9776 :                         return -eta*xi/den2;
    3356             : 
    3357        9776 :                       case 8:
    3358        9776 :                         return 0.5*(1. + zeta2 + eta2 - 2.*zeta)/den2;
    3359             : 
    3360        9776 :                       case 9:
    3361        9776 :                         return (-1. - zeta2 + eta + 2.*zeta)/den2;
    3362             : 
    3363        9776 :                       case 10:
    3364        9776 :                         return -(-1. - zeta2 + eta + 2.*zeta)/den2;
    3365             : 
    3366        9776 :                       case 11:
    3367        9776 :                         return (1. + zeta2 + eta - 2.*zeta)/den2;
    3368             : 
    3369        9776 :                       case 12:
    3370        9776 :                         return -(1. + zeta2 + eta - 2.*zeta)/den2;
    3371             : 
    3372           0 :                       default:
    3373           0 :                         libmesh_error_msg("Invalid i = " << i);
    3374             :                       }
    3375             :                   }
    3376             : 
    3377      127088 :                 case 4: // d^2()/detadzeta
    3378             :                   {
    3379      127088 :                     switch(i)
    3380             :                       {
    3381        9776 :                       case 0:
    3382        9776 :                         return -0.25*(-1. + 2.*zeta - zeta2 + xi + 2.*eta*xi + xi2)/den2;
    3383             : 
    3384        9776 :                       case 1:
    3385        9776 :                         return 0.25*(1. - 2.*zeta + zeta2 + xi + 2.*eta*xi - xi2)/den2;
    3386             : 
    3387        9776 :                       case 2:
    3388        9776 :                         return 0.25*(-1. + 2.*zeta - zeta2 - xi + 2.*eta*xi + xi2)/den2;
    3389             : 
    3390        9776 :                       case 3:
    3391        9776 :                         return -0.25*(1. - 2.*zeta + zeta2 - xi + 2.*eta*xi - xi2)/den2;
    3392             : 
    3393        2636 :                       case 4:
    3394        2636 :                         return 0.;
    3395             : 
    3396        9776 :                       case 5:
    3397        9776 :                         return 0.5*(1. + xi2 + zeta2 - 2.*zeta)/den2;
    3398             : 
    3399        9776 :                       case 6:
    3400        9776 :                         return -eta*xi/den2;
    3401             : 
    3402        9776 :                       case 7:
    3403        9776 :                         return -0.5*(1. + xi2 + zeta2 - 2.*zeta)/den2;
    3404             : 
    3405        9776 :                       case 8:
    3406        9776 :                         return eta*xi/den2;
    3407             : 
    3408        9776 :                       case 9:
    3409        9776 :                         return (-1. - zeta2 + xi + 2.*zeta)/den2;
    3410             : 
    3411        9776 :                       case 10:
    3412        9776 :                         return -(1. + zeta2 + xi - 2.*zeta)/den2;
    3413             : 
    3414        9776 :                       case 11:
    3415        9776 :                         return (1. + zeta2 + xi - 2.*zeta)/den2;
    3416             : 
    3417        9776 :                       case 12:
    3418        9776 :                         return -(-1. - zeta2 + xi + 2.*zeta)/den2;
    3419             : 
    3420           0 :                       default:
    3421           0 :                         libmesh_error_msg("Invalid i = " << i);
    3422             :                       }
    3423             :                   }
    3424             : 
    3425      127088 :                 case 5: // d^2()/dzeta^2
    3426             :                   {
    3427      127088 :                     switch(i)
    3428             :                       {
    3429        9776 :                       case 0:
    3430        9776 :                         return 0.5*(xi + eta + 1.)*eta*xi/den3;
    3431             : 
    3432        9776 :                       case 1:
    3433        9776 :                         return -0.5*(eta - xi + 1.)*eta*xi/den3;
    3434             : 
    3435        9776 :                       case 2:
    3436        9776 :                         return -0.5*(xi + eta - 1.)*eta*xi/den3;
    3437             : 
    3438        9776 :                       case 3:
    3439        9776 :                         return 0.5*(eta - xi - 1.)*eta*xi/den3;
    3440             : 
    3441        2636 :                       case 4:
    3442        2636 :                         return 4.;
    3443             : 
    3444        9776 :                       case 5:
    3445        9776 :                         return -(1. - 3.*zeta + 3.*zeta2 - zeta3 + eta*xi2)/den3;
    3446             : 
    3447        9776 :                       case 6:
    3448        9776 :                         return (-1. + 3.*zeta - 3.*zeta2 + zeta3 + eta2*xi)/den3;
    3449             : 
    3450        9776 :                       case 7:
    3451        9776 :                         return (-1. + 3.*zeta - 3.*zeta2 + zeta3 + eta*xi2)/den3;
    3452             : 
    3453        9776 :                       case 8:
    3454        9776 :                         return -(1. - 3.*zeta + 3.*zeta2 - zeta3 + eta2*xi)/den3;
    3455             : 
    3456        9776 :                       case 9:
    3457        9776 :                         return -2.*(-1. + 3.*zeta - 3.*zeta2 + zeta3 + eta*xi)/den3;
    3458             : 
    3459        9776 :                       case 10:
    3460        9776 :                         return 2.*(1. - 3.*zeta + 3.*zeta2 - zeta3 + eta*xi)/den3;
    3461             : 
    3462        9776 :                       case 11:
    3463        9776 :                         return -2.*(-1. + 3.*zeta - 3.*zeta2 + zeta3 + eta*xi)/den3;
    3464             : 
    3465        9776 :                       case 12:
    3466        9776 :                         return 2.*(1. - 3.*zeta + 3.*zeta2 - zeta3 + eta*xi)/den3;
    3467             : 
    3468           0 :                       default:
    3469           0 :                         libmesh_error_msg("Invalid i = " << i);
    3470             :                       }
    3471             :                   }
    3472             : 
    3473           0 :                 default:
    3474           0 :                   libmesh_error_msg("Invalid j = " << j);
    3475             :                 }
    3476             :             }
    3477             : 
    3478           0 :           default:
    3479           0 :             libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
    3480             :           }
    3481             :       }
    3482             : 
    3483   339458742 :     case THIRD:
    3484             :       {
    3485   339458742 :         switch (type)
    3486             :           {
    3487             :             // quadratic Lagrange shape functions with a cubic bubble
    3488   233856588 :           case TET14:
    3489             :             {
    3490    56532336 :               libmesh_assert_less (i, 14);
    3491   233856588 :               return libMesh::detail::fe_lagrange_tet14_shape_second_deriv(i, j, p(0), p(1), p(2));
    3492             :             }
    3493             : 
    3494    31940760 :           case PRISM20:
    3495             :             {
    3496     8614560 :               libmesh_assert_less (i, 20);
    3497             : 
    3498             :               // Compute prism shape functions as a tensor-product
    3499             :               // of a triangle and an edge
    3500             : 
    3501    31940760 :               Point p2d(p(0),p(1));
    3502    31940760 :               Real p1d = p(2);
    3503             : 
    3504             :               //                                0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
    3505             :               static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2, 0, 1};
    3506             : 
    3507    31940760 :               const Real mainval = FE<3,LAGRANGE>::shape_second_deriv(PRISM21, THIRD, i, j, p);
    3508             : 
    3509    31940760 :               if (i0[i] != 2)
    3510     6030192 :                 return mainval;
    3511             : 
    3512     2584368 :               Real bubbleval = 0;
    3513             : 
    3514     2584368 :               switch (j)
    3515             :                 {
    3516             :                   // d^2()/dxi^2
    3517     1597038 :                 case 0:
    3518     1597038 :                   bubbleval =
    3519     1597038 :                     FE<2,LAGRANGE>::shape_second_deriv(TRI7, THIRD, 6, 0, p2d)*
    3520      430728 :                     fe_lagrange_1D_quadratic_shape(2, p1d);
    3521     1597038 :                   break;
    3522             : 
    3523             :                   // d^2()/dxideta
    3524     1597038 :                 case 1:
    3525     1597038 :                   bubbleval =
    3526     1597038 :                     FE<2,LAGRANGE>::shape_second_deriv(TRI7, THIRD, 6, 1, p2d)*
    3527      430728 :                     fe_lagrange_1D_quadratic_shape(2, p1d);
    3528     1597038 :                   break;
    3529             : 
    3530             :                   // d^2()/deta^2
    3531     1597038 :                 case 2:
    3532     1597038 :                   bubbleval =
    3533     1597038 :                     FE<2,LAGRANGE>::shape_second_deriv(TRI7, THIRD, 6, 2, p2d)*
    3534      430728 :                     fe_lagrange_1D_quadratic_shape(2, p1d);
    3535     1597038 :                   break;
    3536             : 
    3537             :                   // d^2()/dxidzeta
    3538     1597038 :                 case 3:
    3539     1597038 :                   bubbleval =
    3540     1597038 :                     FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, 6, 0, p2d)*
    3541      430728 :                     fe_lagrange_1D_quadratic_shape_deriv(2, 0, p1d);
    3542     1597038 :                   break;
    3543             : 
    3544             :                   // d^2()/detadzeta
    3545     1597038 :                 case 4:
    3546     1597038 :                   bubbleval =
    3547     1597038 :                     FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, 6, 1, p2d)*
    3548      430728 :                     fe_lagrange_1D_quadratic_shape_deriv(2, 0, p1d);
    3549     1597038 :                   break;
    3550             : 
    3551             :                   // d^2()/dzeta^2
    3552     1597038 :                 case 5:
    3553     1597038 :                   bubbleval =
    3554     1597038 :                     FE<2,LAGRANGE>::shape(TRI7, THIRD, 6, p2d)*
    3555      430728 :                     fe_lagrange_1D_quadratic_shape_second_deriv(2, 0, p1d);
    3556     1597038 :                   break;
    3557             : 
    3558           0 :                 default:
    3559           0 :                   libmesh_error_msg("Invalid shape function derivative j = " << j);
    3560             :                 }
    3561             : 
    3562     9582228 :               if (i < 12) // vertices
    3563     4791114 :                 return mainval - bubbleval / 9;
    3564             : 
    3565     4791114 :               return mainval + bubbleval * (Real(4) / 9);
    3566             :             }
    3567             : 
    3568    71909850 :           case PRISM21:
    3569             :             {
    3570    19456860 :               libmesh_assert_less (i, 21);
    3571             : 
    3572             :               // Compute prism shape functions as a tensor-product
    3573             :               // of a triangle and an edge
    3574             : 
    3575    71909850 :               Point p2d(p(0),p(1));
    3576    71909850 :               Real p1d = p(2);
    3577             : 
    3578             :               //                                0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20
    3579             :               static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2, 0, 1, 2};
    3580             :               static const unsigned int i1[] = {0, 1, 2, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 3, 4, 5, 6, 6, 6};
    3581             : 
    3582    71909850 :               switch (j)
    3583             :                 {
    3584             :                   // d^2()/dxi^2
    3585    11984975 :                 case 0:
    3586    11984975 :                   return (FE<2,LAGRANGE>::shape_second_deriv(TRI7, THIRD, i1[i], 0, p2d)*
    3587    15227785 :                           fe_lagrange_1D_quadratic_shape(i0[i], p1d));
    3588             : 
    3589             :                   // d^2()/dxideta
    3590    11984975 :                 case 1:
    3591    11984975 :                   return (FE<2,LAGRANGE>::shape_second_deriv(TRI7, THIRD, i1[i], 1, p2d)*
    3592    15227785 :                           fe_lagrange_1D_quadratic_shape(i0[i], p1d));
    3593             : 
    3594             :                   // d^2()/deta^2
    3595    11984975 :                 case 2:
    3596    11984975 :                   return (FE<2,LAGRANGE>::shape_second_deriv(TRI7, THIRD, i1[i], 2, p2d)*
    3597    15227785 :                           fe_lagrange_1D_quadratic_shape(i0[i], p1d));
    3598             : 
    3599             :                   // d^2()/dxidzeta
    3600    11984975 :                 case 3:
    3601    11984975 :                   return (FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, i1[i], 0, p2d)*
    3602    20727140 :                           fe_lagrange_1D_quadratic_shape_deriv(i0[i], 0, p1d));
    3603             : 
    3604             :                   // d^2()/detadzeta
    3605    11984975 :                 case 4:
    3606    11984975 :                   return (FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, i1[i], 1, p2d)*
    3607    20727140 :                           fe_lagrange_1D_quadratic_shape_deriv(i0[i], 0, p1d));
    3608             : 
    3609             :                   // d^2()/dzeta^2
    3610    11984975 :                 case 5:
    3611    11984975 :                   return (FE<2,LAGRANGE>::shape(TRI7, THIRD, i1[i], p2d)*
    3612    14769440 :                           fe_lagrange_1D_quadratic_shape_second_deriv(i0[i], 0, p1d));
    3613             : 
    3614           0 :                 default:
    3615           0 :                   libmesh_error_msg("Invalid shape function derivative j = " << j);
    3616             :                 }
    3617             :             }
    3618             : 
    3619     1751544 :           case PYRAMID18:
    3620             :             {
    3621     1751544 :               return fe_fdm_second_deriv(type, order, elem, i, j, p,
    3622     1751544 :                                          fe_lagrange_3D_shape_deriv<T>);
    3623             :             }
    3624             : 
    3625           0 :           default:
    3626           0 :             libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
    3627             :           }
    3628             :       }
    3629             : 
    3630             :       // unsupported order
    3631           0 :     default:
    3632           0 :       libmesh_error_msg("ERROR: Unsupported 3D FE order!: " << order);
    3633             :     }
    3634             : 
    3635             : #else // LIBMESH_DIM != 3
    3636             :   libmesh_ignore(type, order, elem, i, j, p);
    3637             :   libmesh_not_implemented();
    3638             : #endif
    3639             : }
    3640             : 
    3641             : #endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
    3642             : 
    3643             : 
    3644             : } // anonymous namespace

Generated by: LCOV version 1.14