LCOV - code coverage report
Current view: top level - src/fe - fe_lagrange.C (source / functions) Hit Total Coverage
Test: libMesh/libmesh: #4573 (924896) with base 3f0912 Lines: 382 468 81.6 %
Date: 2026-11-18 21:52:26 Functions: 49 60 81.7 %
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             : 
      20             : // Local includes
      21             : #include "libmesh/dof_map.h"
      22             : #include "libmesh/elem.h"
      23             : #include "libmesh/enum_to_string.h"
      24             : #include "libmesh/fe.h"
      25             : #include "libmesh/fe_lagrange_n_dofs.h"
      26             : #include "libmesh/fe_interface.h"
      27             : #include "libmesh/fe_macro.h"
      28             : #include "libmesh/remote_elem.h"
      29             : #include "libmesh/threads.h"
      30             : 
      31             : 
      32             : #ifdef LIBMESH_ENABLE_AMR
      33             : #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
      34             : // to have the macro 'inf_fe_switch' available.
      35             : #include "libmesh/fe_interface_macros.h"
      36             : #include "libmesh/inf_fe.h"
      37             : #endif
      38             : #endif
      39             : 
      40             : namespace libMesh
      41             : {
      42             : 
      43             : // global helper function
      44     2681397 : void lagrange_nodal_soln(const Elem * elem,
      45             :                          const Order order,
      46             :                          const std::vector<Number> & elem_soln,
      47             :                          std::vector<Number> &       nodal_soln,
      48             :                          const bool add_p_level)
      49             : {
      50     2681397 :   const unsigned int n_nodes = elem->n_nodes();
      51     2681397 :   const ElemType type        = elem->type();
      52             : 
      53     3448324 :   const Order totalorder = order + add_p_level*elem->p_level();
      54             : 
      55     2681397 :   nodal_soln.resize(n_nodes);
      56             : 
      57             : 
      58             : 
      59     2681397 :   switch (totalorder)
      60             :     {
      61             :       // linear Lagrange shape functions
      62     2375083 :     case FIRST:
      63             :       {
      64     2375083 :         switch (type)
      65             :           {
      66         328 :           case EDGE3:
      67             :             {
      68         164 :               libmesh_assert_equal_to (elem_soln.size(), 2);
      69         164 :               libmesh_assert_equal_to (nodal_soln.size(), 3);
      70             : 
      71         656 :               nodal_soln[0] = elem_soln[0];
      72         656 :               nodal_soln[1] = elem_soln[1];
      73         656 :               nodal_soln[2] = .5*(elem_soln[0] + elem_soln[1]);
      74             : 
      75         656 :               return;
      76             :             }
      77             : 
      78           0 :           case EDGE4:
      79             :             {
      80           0 :               libmesh_assert_equal_to (elem_soln.size(), 2);
      81           0 :               libmesh_assert_equal_to (nodal_soln.size(), 4);
      82             : 
      83           0 :               nodal_soln[0] = elem_soln[0];
      84           0 :               nodal_soln[1] = elem_soln[1];
      85           0 :               nodal_soln[2] = (2.*elem_soln[0] + elem_soln[1])/3.;
      86           0 :               nodal_soln[3] = (elem_soln[0] + 2.*elem_soln[1])/3.;
      87             : 
      88           0 :               return;
      89             :             }
      90             : 
      91             : 
      92        1395 :           case TRI7:
      93         468 :             libmesh_assert_equal_to (nodal_soln.size(), 7);
      94        1863 :             nodal_soln[6] = (elem_soln[0] + elem_soln[1] + elem_soln[2])/3.;
      95             :             libmesh_fallthrough();
      96        4910 :           case TRI6:
      97             :             {
      98        1328 :               libmesh_assert (type == TRI7 || nodal_soln.size() == 6);
      99        1328 :               libmesh_assert_equal_to (elem_soln.size(), 3);
     100             : 
     101        4910 :               nodal_soln[0] = elem_soln[0];
     102        4910 :               nodal_soln[1] = elem_soln[1];
     103        4910 :               nodal_soln[2] = elem_soln[2];
     104        4910 :               nodal_soln[3] = .5*(elem_soln[0] + elem_soln[1]);
     105        4910 :               nodal_soln[4] = .5*(elem_soln[1] + elem_soln[2]);
     106        4910 :               nodal_soln[5] = .5*(elem_soln[2] + elem_soln[0]);
     107             : 
     108        4910 :               return;
     109             :             }
     110             : 
     111             : 
     112       22647 :           case QUAD8:
     113             :           case QUAD9:
     114             :             {
     115       22647 :               libmesh_assert_equal_to (elem_soln.size(), 4);
     116             : 
     117       22647 :               if (type == QUAD8)
     118           0 :                 libmesh_assert_equal_to (nodal_soln.size(), 8);
     119             :               else
     120       22647 :                 libmesh_assert_equal_to (nodal_soln.size(), 9);
     121             : 
     122             : 
     123       88552 :               nodal_soln[0] = elem_soln[0];
     124       88552 :               nodal_soln[1] = elem_soln[1];
     125       88552 :               nodal_soln[2] = elem_soln[2];
     126       88552 :               nodal_soln[3] = elem_soln[3];
     127       88552 :               nodal_soln[4] = .5*(elem_soln[0] + elem_soln[1]);
     128       88552 :               nodal_soln[5] = .5*(elem_soln[1] + elem_soln[2]);
     129       88552 :               nodal_soln[6] = .5*(elem_soln[2] + elem_soln[3]);
     130       88552 :               nodal_soln[7] = .5*(elem_soln[3] + elem_soln[0]);
     131             : 
     132       88552 :               if (type == QUAD9)
     133       88552 :                 nodal_soln[8] = .25*(elem_soln[0] + elem_soln[1] + elem_soln[2] + elem_soln[3]);
     134             : 
     135       22647 :               return;
     136             :             }
     137             : 
     138             : 
     139        4608 :           case TET14:
     140        1536 :             libmesh_assert_equal_to (nodal_soln.size(), 14);
     141        6144 :             nodal_soln[10] = (elem_soln[0] + elem_soln[1] + elem_soln[2])/3.;
     142        6144 :             nodal_soln[11] = (elem_soln[0] + elem_soln[1] + elem_soln[3])/3.;
     143        6144 :             nodal_soln[12] = (elem_soln[1] + elem_soln[2] + elem_soln[3])/3.;
     144        6144 :             nodal_soln[13] = (elem_soln[0] + elem_soln[2] + elem_soln[3])/3.;
     145             :             libmesh_fallthrough();
     146        6144 :           case TET10:
     147             :             {
     148        1536 :               libmesh_assert_equal_to (elem_soln.size(), 4);
     149        1536 :               libmesh_assert (type == TET14 || nodal_soln.size() == 10);
     150             : 
     151        6144 :               nodal_soln[0] = elem_soln[0];
     152        6144 :               nodal_soln[1] = elem_soln[1];
     153        6144 :               nodal_soln[2] = elem_soln[2];
     154        6144 :               nodal_soln[3] = elem_soln[3];
     155        6144 :               nodal_soln[4] = .5*(elem_soln[0] + elem_soln[1]);
     156        6144 :               nodal_soln[5] = .5*(elem_soln[1] + elem_soln[2]);
     157        6144 :               nodal_soln[6] = .5*(elem_soln[2] + elem_soln[0]);
     158        6144 :               nodal_soln[7] = .5*(elem_soln[3] + elem_soln[0]);
     159        6144 :               nodal_soln[8] = .5*(elem_soln[3] + elem_soln[1]);
     160        6144 :               nodal_soln[9] = .5*(elem_soln[3] + elem_soln[2]);
     161             : 
     162        6144 :               return;
     163             :             }
     164             : 
     165             : 
     166        1936 :           case HEX20:
     167             :           case HEX27:
     168             :             {
     169        1936 :               libmesh_assert_equal_to (elem_soln.size(), 8);
     170             : 
     171        1936 :               if (type == HEX20)
     172           0 :                 libmesh_assert_equal_to (nodal_soln.size(), 20);
     173             :               else
     174        1936 :                 libmesh_assert_equal_to (nodal_soln.size(), 27);
     175             : 
     176        7624 :               nodal_soln[0]  = elem_soln[0];
     177        7624 :               nodal_soln[1]  = elem_soln[1];
     178        7624 :               nodal_soln[2]  = elem_soln[2];
     179        7624 :               nodal_soln[3]  = elem_soln[3];
     180        7624 :               nodal_soln[4]  = elem_soln[4];
     181        7624 :               nodal_soln[5]  = elem_soln[5];
     182        7624 :               nodal_soln[6]  = elem_soln[6];
     183        7624 :               nodal_soln[7]  = elem_soln[7];
     184        7624 :               nodal_soln[8]  = .5*(elem_soln[0] + elem_soln[1]);
     185        7624 :               nodal_soln[9]  = .5*(elem_soln[1] + elem_soln[2]);
     186        7624 :               nodal_soln[10] = .5*(elem_soln[2] + elem_soln[3]);
     187        7624 :               nodal_soln[11] = .5*(elem_soln[3] + elem_soln[0]);
     188        7624 :               nodal_soln[12] = .5*(elem_soln[0] + elem_soln[4]);
     189        7624 :               nodal_soln[13] = .5*(elem_soln[1] + elem_soln[5]);
     190        7624 :               nodal_soln[14] = .5*(elem_soln[2] + elem_soln[6]);
     191        7624 :               nodal_soln[15] = .5*(elem_soln[3] + elem_soln[7]);
     192        7624 :               nodal_soln[16] = .5*(elem_soln[4] + elem_soln[5]);
     193        7624 :               nodal_soln[17] = .5*(elem_soln[5] + elem_soln[6]);
     194        7624 :               nodal_soln[18] = .5*(elem_soln[6] + elem_soln[7]);
     195        7624 :               nodal_soln[19] = .5*(elem_soln[4] + elem_soln[7]);
     196             : 
     197        7624 :               if (type == HEX27)
     198             :                 {
     199        7624 :                   nodal_soln[20] = .25*(elem_soln[0] + elem_soln[1] + elem_soln[2] + elem_soln[3]);
     200        7624 :                   nodal_soln[21] = .25*(elem_soln[0] + elem_soln[1] + elem_soln[4] + elem_soln[5]);
     201        7624 :                   nodal_soln[22] = .25*(elem_soln[1] + elem_soln[2] + elem_soln[5] + elem_soln[6]);
     202        7624 :                   nodal_soln[23] = .25*(elem_soln[2] + elem_soln[3] + elem_soln[6] + elem_soln[7]);
     203        7624 :                   nodal_soln[24] = .25*(elem_soln[3] + elem_soln[0] + elem_soln[7] + elem_soln[4]);
     204        7624 :                   nodal_soln[25] = .25*(elem_soln[4] + elem_soln[5] + elem_soln[6] + elem_soln[7]);
     205             : 
     206       11496 :                   nodal_soln[26] = .125*(elem_soln[0] + elem_soln[1] + elem_soln[2] + elem_soln[3] +
     207        5808 :                                          elem_soln[4] + elem_soln[5] + elem_soln[6] + elem_soln[7]);
     208             :                 }
     209             : 
     210        1936 :               return;
     211             :             }
     212             : 
     213             : 
     214          60 :           case PRISM21:
     215         132 :             nodal_soln[20]  = (elem_soln[0] + elem_soln[1] + elem_soln[2] +
     216          72 :                                elem_soln[3] + elem_soln[4] + elem_soln[5])/Real(6);
     217             :             libmesh_fallthrough();
     218          48 :           case PRISM20:
     219          48 :             if (type == PRISM20)
     220          24 :               libmesh_assert_equal_to (nodal_soln.size(), 20);
     221         168 :             nodal_soln[18]  = (elem_soln[0] + elem_soln[1] + elem_soln[2])/Real(3);
     222         168 :             nodal_soln[19]  = (elem_soln[3] + elem_soln[4] + elem_soln[5])/Real(3);
     223             :             libmesh_fallthrough();
     224          72 :           case PRISM18:
     225          72 :             if (type == PRISM18)
     226          24 :               libmesh_assert_equal_to (nodal_soln.size(), 18);
     227         252 :             nodal_soln[15] = .25*(elem_soln[0] + elem_soln[1] + elem_soln[4] + elem_soln[3]);
     228         252 :             nodal_soln[16] = .25*(elem_soln[1] + elem_soln[2] + elem_soln[5] + elem_soln[4]);
     229         252 :             nodal_soln[17] = .25*(elem_soln[2] + elem_soln[0] + elem_soln[3] + elem_soln[5]);
     230             :             libmesh_fallthrough();
     231          96 :           case PRISM15:
     232             :             {
     233          96 :               libmesh_assert_equal_to (elem_soln.size(), 6);
     234             : 
     235          96 :               if (type == PRISM15)
     236          24 :                 libmesh_assert_equal_to (nodal_soln.size(), 15);
     237             : 
     238         336 :               nodal_soln[0]  = elem_soln[0];
     239         336 :               nodal_soln[1]  = elem_soln[1];
     240         336 :               nodal_soln[2]  = elem_soln[2];
     241         336 :               nodal_soln[3]  = elem_soln[3];
     242         336 :               nodal_soln[4]  = elem_soln[4];
     243         336 :               nodal_soln[5]  = elem_soln[5];
     244         336 :               nodal_soln[6]  = .5*(elem_soln[0] + elem_soln[1]);
     245         336 :               nodal_soln[7]  = .5*(elem_soln[1] + elem_soln[2]);
     246         336 :               nodal_soln[8]  = .5*(elem_soln[0] + elem_soln[2]);
     247         336 :               nodal_soln[9]  = .5*(elem_soln[0] + elem_soln[3]);
     248         336 :               nodal_soln[10] = .5*(elem_soln[1] + elem_soln[4]);
     249         336 :               nodal_soln[11] = .5*(elem_soln[2] + elem_soln[5]);
     250         336 :               nodal_soln[12] = .5*(elem_soln[3] + elem_soln[4]);
     251         336 :               nodal_soln[13] = .5*(elem_soln[4] + elem_soln[5]);
     252         336 :               nodal_soln[14] = .5*(elem_soln[3] + elem_soln[5]);
     253             : 
     254         336 :               return;
     255             :             }
     256             : 
     257           0 :           case PYRAMID18:
     258             :             {
     259           0 :               libmesh_assert_equal_to (nodal_soln.size(), 18);
     260             : 
     261           0 :               nodal_soln[14] = (elem_soln[0] + elem_soln[1] + elem_soln[4])/Real(3);
     262           0 :               nodal_soln[15] = (elem_soln[1] + elem_soln[2] + elem_soln[4])/Real(3);
     263           0 :               nodal_soln[16] = (elem_soln[2] + elem_soln[3] + elem_soln[4])/Real(3);
     264           0 :               nodal_soln[17] = (elem_soln[0] + elem_soln[3] + elem_soln[4])/Real(3);
     265             : 
     266             :               libmesh_fallthrough();
     267             :             }
     268             : 
     269           0 :           case PYRAMID14:
     270             :             {
     271           0 :               if (type == PYRAMID14)
     272           0 :                 libmesh_assert_equal_to (nodal_soln.size(), 14);
     273             : 
     274           0 :               nodal_soln[13] = .25*(elem_soln[0] + elem_soln[1] + elem_soln[2] + elem_soln[3]);
     275             : 
     276             :               libmesh_fallthrough();
     277             :             }
     278             : 
     279           0 :           case PYRAMID13:
     280             :             {
     281           0 :               libmesh_assert_equal_to (elem_soln.size(), 5);
     282             : 
     283           0 :               if (type == PYRAMID13)
     284           0 :                 libmesh_assert_equal_to (nodal_soln.size(), 13);
     285             : 
     286           0 :               nodal_soln[0]  = elem_soln[0];
     287           0 :               nodal_soln[1]  = elem_soln[1];
     288           0 :               nodal_soln[2]  = elem_soln[2];
     289           0 :               nodal_soln[3]  = elem_soln[3];
     290           0 :               nodal_soln[4]  = elem_soln[4];
     291           0 :               nodal_soln[5]  = .5*(elem_soln[0] + elem_soln[1]);
     292           0 :               nodal_soln[6]  = .5*(elem_soln[1] + elem_soln[2]);
     293           0 :               nodal_soln[7]  = .5*(elem_soln[2] + elem_soln[3]);
     294           0 :               nodal_soln[8]  = .5*(elem_soln[3] + elem_soln[0]);
     295           0 :               nodal_soln[9]  = .5*(elem_soln[0] + elem_soln[4]);
     296           0 :               nodal_soln[10] = .5*(elem_soln[1] + elem_soln[4]);
     297           0 :               nodal_soln[11] = .5*(elem_soln[2] + elem_soln[4]);
     298           0 :               nodal_soln[12] = .5*(elem_soln[3] + elem_soln[4]);
     299             : 
     300           0 :               return;
     301             :             }
     302     2266861 :           default:
     303             :             {
     304             :               // By default the element solution _is_ nodal,
     305             :               // so just copy it.
     306     2266861 :               nodal_soln = elem_soln;
     307             : 
     308     2266861 :               return;
     309             :             }
     310             :           }
     311             :       }
     312             : 
     313      303904 :     case SECOND:
     314             :       {
     315      303904 :         switch (type)
     316             :           {
     317           0 :           case EDGE4:
     318             :             {
     319           0 :               libmesh_assert_equal_to (elem_soln.size(), 3);
     320           0 :               libmesh_assert_equal_to (nodal_soln.size(), 4);
     321             : 
     322             :               // Project quadratic solution onto cubic element nodes
     323           0 :               nodal_soln[0] = elem_soln[0];
     324           0 :               nodal_soln[1] = elem_soln[1];
     325           0 :               nodal_soln[2] = (2.*elem_soln[0] - elem_soln[1] +
     326           0 :                                8.*elem_soln[2])/9.;
     327           0 :               nodal_soln[3] = (-elem_soln[0] + 2.*elem_soln[1] +
     328           0 :                                8.*elem_soln[2])/9.;
     329           0 :               return;
     330             :             }
     331             : 
     332         486 :           case TRI7:
     333             :             {
     334         486 :               libmesh_assert_equal_to (elem_soln.size(), 6);
     335         486 :               libmesh_assert_equal_to (nodal_soln.size(), 7);
     336             : 
     337       13482 :               for (int i=0; i != 6; ++i)
     338       17388 :                 nodal_soln[i] = elem_soln[i];
     339             : 
     340        2412 :               nodal_soln[6] = -1./9. * (elem_soln[0] + elem_soln[1] + elem_soln[2])
     341        1458 :                               +4./9. * (elem_soln[3] + elem_soln[4] + elem_soln[5]);
     342             : 
     343        1926 :               return;
     344             :             }
     345             : 
     346        1556 :           case TET14:
     347             :             {
     348        1556 :               libmesh_assert_equal_to (elem_soln.size(), 10);
     349        1556 :               libmesh_assert_equal_to (nodal_soln.size(), 14);
     350             : 
     351       68354 :               for (int i=0; i != 10; ++i)
     352       93260 :                 nodal_soln[i] = elem_soln[i];
     353             : 
     354        7770 :               nodal_soln[10] = -1./9. * (elem_soln[0] + elem_soln[1] + elem_soln[2])
     355        4668 :                                +4./9. * (elem_soln[4] + elem_soln[5] + elem_soln[6]);
     356        7770 :               nodal_soln[11] = -1./9. * (elem_soln[0] + elem_soln[1] + elem_soln[3])
     357        4668 :                                +4./9. * (elem_soln[4] + elem_soln[7] + elem_soln[8]);
     358        7770 :               nodal_soln[12] = -1./9. * (elem_soln[1] + elem_soln[2] + elem_soln[3])
     359        4668 :                                +4./9. * (elem_soln[5] + elem_soln[8] + elem_soln[9]);
     360        7770 :               nodal_soln[13] = -1./9. * (elem_soln[0] + elem_soln[2] + elem_soln[3])
     361        4668 :                                +4./9. * (elem_soln[6] + elem_soln[7] + elem_soln[9]);
     362             : 
     363        6214 :               return;
     364             :             }
     365             : 
     366         548 :           case PRISM21:
     367             :             {
     368        1608 :               nodal_soln[20] = -1./9. * (elem_soln[9] + elem_soln[10] + elem_soln[11])
     369         822 :                                +4./9. * (elem_soln[15] + elem_soln[16] + elem_soln[17]);
     370             :               libmesh_fallthrough();
     371             :             }
     372         346 :           case PRISM20:
     373             :             {
     374         346 :               libmesh_assert_equal_to (elem_soln.size(), 18);
     375         346 :               if (type == PRISM20)
     376          72 :                 libmesh_assert_equal_to (nodal_soln.size(), 20);
     377             : 
     378       24928 :               for (int i=0; i != 18; ++i)
     379       36072 :                 nodal_soln[i] = elem_soln[i];
     380             : 
     381        1658 :               nodal_soln[18] = -1./9. * (elem_soln[0] + elem_soln[1] + elem_soln[2])
     382        1038 :                                +4./9. * (elem_soln[6] + elem_soln[7] + elem_soln[8]);
     383        1658 :               nodal_soln[19] = -1./9. * (elem_soln[3] + elem_soln[4] + elem_soln[5])
     384        1038 :                                +4./9. * (elem_soln[12] + elem_soln[13] + elem_soln[14]);
     385        1312 :               return;
     386             :             }
     387             : 
     388          28 :           case PYRAMID18:
     389             :             {
     390          28 :               libmesh_assert_equal_to (elem_soln.size(), 14);
     391          28 :               libmesh_assert_equal_to (nodal_soln.size(), 18);
     392             : 
     393        1470 :               for (int i=0; i != 14; ++i)
     394        2156 :                 nodal_soln[i] = elem_soln[i];
     395             : 
     396         126 :               nodal_soln[14] = -1./9. * (elem_soln[0] + elem_soln[1] + elem_soln[4])
     397          84 :                                +4./9. * (elem_soln[5] + elem_soln[9] + elem_soln[10]);
     398         126 :               nodal_soln[15] = -1./9. * (elem_soln[1] + elem_soln[2] + elem_soln[4])
     399          84 :                                +4./9. * (elem_soln[6] + elem_soln[10] + elem_soln[11]);
     400         126 :               nodal_soln[16] = -1./9. * (elem_soln[2] + elem_soln[3] + elem_soln[4])
     401          84 :                                +4./9. * (elem_soln[7] + elem_soln[11] + elem_soln[12]);
     402         126 :               nodal_soln[17] = -1./9. * (elem_soln[0] + elem_soln[3] + elem_soln[4])
     403          84 :                                +4./9. * (elem_soln[8] + elem_soln[9] + elem_soln[12]);
     404             : 
     405          98 :               return;
     406             :             }
     407             : 
     408       76402 :           default:
     409             :             {
     410             :               // By default the element solution _is_ nodal, so just
     411             :               // copy the portion relevant to the nodal solution.
     412             :               // (this is the whole nodal solution for true Lagrange
     413             :               // elements, but a smaller part for "L2 Lagrange"
     414       76402 :               libmesh_assert_less_equal(nodal_soln.size(), elem_soln.size());
     415     2960842 :               for (const auto i : index_range(nodal_soln))
     416     4049116 :                 nodal_soln[i] = elem_soln[i];
     417             : 
     418      152804 :               return;
     419             :             }
     420             :           }
     421             :       }
     422             : 
     423             : 
     424             : 
     425             : 
     426         658 :     default:
     427             :       {
     428             :         // By default the element solution _is_ nodal, so just copy
     429             :         // the portion relevant to the nodal solution.  (this is the
     430             :         // whole nodal solution for true Lagrange elements, but a
     431             :         // smaller part for "L2 Lagrange"
     432         658 :         libmesh_assert_less_equal(nodal_soln.size(), elem_soln.size());
     433       45440 :         for (const auto i : index_range(nodal_soln))
     434       66498 :           nodal_soln[i] = elem_soln[i];
     435             : 
     436        1316 :         return;
     437             :       }
     438             :     }
     439             : }
     440             : 
     441             : 
     442             : // Anonymous namespace for local helper functions
     443             : namespace {
     444   421707281 : unsigned int lagrange_n_dofs(const ElemType t, const Elem * e, const Order o)
     445             : {
     446   131003820 :   libmesh_assert(!e || e->type() == t);
     447             : 
     448             :   // The counts live in a header so that device code, which cannot call in
     449             :   // here, reads the same ones.  What stays is what a header cannot do:
     450             :   // report our errors, and ask a polytope for the node count its element
     451             :   // type does not fix, which only makes it a first-order element.
     452   421707281 :   const unsigned int n = FECounts::lagrange_n_dofs(t, o);
     453   421707281 :   if (n != invalid_uint)
     454   130462144 :     return n;
     455             : 
     456     2091296 :   if (o == FIRST && (t == C0POLYGON || t == C0POLYHEDRON))
     457             :     {
     458             :       // Polygons and polyhedra require using newer FE APIs
     459     2091268 :       if (!e)
     460          14 :         libmesh_error_msg("Code (see stack trace) used an outdated FE function overload.\n"
     461             :                           "n_dofs() on a polygon or polyhedron is not defined by ElemType alone.");
     462     2091261 :       return e->n_nodes();
     463             :     }
     464             : 
     465          43 :   libmesh_error_msg_if(o > THIRD || o < CONSTANT,
     466             :                        "ERROR: Invalid Order " << Utility::enum_to_string(o) <<
     467             :                        " selected for LAGRANGE FE family!");
     468             : 
     469          81 :   libmesh_error_msg("ERROR: Bad ElemType = " << Utility::enum_to_string(t) <<
     470             :                     " for " << Utility::enum_to_string(o) << " order approximation!");
     471             : }
     472             : 
     473             : 
     474             : 
     475   337655100 : unsigned int lagrange_n_dofs_at_node(const ElemType t,
     476             :                                      const Order o,
     477             :                                      const unsigned int n)
     478             : {
     479   337655100 :   switch (o)
     480             :     {
     481             :       // lagrange can only be constant on a single node
     482           0 :     case CONSTANT:
     483             :       {
     484           0 :         switch (t)
     485             :           {
     486           0 :           case NODEELEM:
     487           0 :             return 1;
     488             : 
     489           0 :           default:
     490           0 :             libmesh_error_msg("ERROR: Bad ElemType = " << Utility::enum_to_string(t) << " for " << Utility::enum_to_string(o) << " order approximation!");
     491             :           }
     492             :       }
     493             : 
     494             :       // linear Lagrange shape functions
     495   236392649 :     case FIRST:
     496             :       {
     497   236392649 :         switch (t)
     498             :           {
     499        1667 :           case NODEELEM:
     500        1667 :             return 1;
     501             : 
     502     5825758 :           case EDGE2:
     503             :           case EDGE3:
     504             :           case EDGE4:
     505             :             {
     506     5825758 :               switch (n)
     507             :                 {
     508     1316133 :                 case 0:
     509             :                 case 1:
     510     1316133 :                   return 1;
     511             : 
     512     1209436 :                 default:
     513     1209436 :                   return 0;
     514             :                 }
     515             :             }
     516             : 
     517    18333350 :           case TRI3:
     518             :           case TRISHELL3:
     519             :           case TRI3SUBDIVISION:
     520             :           case TRI6:
     521             :           case TRI7:
     522             :             {
     523    18333350 :               switch (n)
     524             :                 {
     525     4808961 :                 case 0:
     526             :                 case 1:
     527             :                 case 2:
     528     4808961 :                   return 1;
     529             : 
     530       21401 :                 default:
     531       21401 :                   return 0;
     532             :                 }
     533             :             }
     534             : 
     535   143799757 :           case QUAD4:
     536             :           case QUADSHELL4:
     537             :           case QUAD8:
     538             :           case QUADSHELL8:
     539             :           case QUAD9:
     540             :           case QUADSHELL9:
     541             :             {
     542   143799757 :               switch (n)
     543             :                 {
     544    42855563 :                 case 0:
     545             :                 case 1:
     546             :                 case 2:
     547             :                 case 3:
     548    42855563 :                   return 1;
     549             : 
     550     6336681 :                 default:
     551     6336681 :                   return 0;
     552             :                 }
     553             :             }
     554             : 
     555        3612 :           case C0POLYGON:
     556             :           case C0POLYHEDRON:
     557        3612 :             return 1;
     558             : 
     559             : 
     560    15772926 :           case TET4:
     561             :           case TET10:
     562             :           case TET14:
     563             :             {
     564    15772926 :               switch (n)
     565             :                 {
     566     4777104 :                 case 0:
     567             :                 case 1:
     568             :                 case 2:
     569             :                 case 3:
     570     4777104 :                   return 1;
     571             : 
     572           0 :                 default:
     573           0 :                   return 0;
     574             :                 }
     575             :             }
     576             : 
     577    50109285 :           case HEX8:
     578             :           case HEX20:
     579             :           case HEX27:
     580             :             {
     581    50109285 :               switch (n)
     582             :                 {
     583    11996012 :                 case 0:
     584             :                 case 1:
     585             :                 case 2:
     586             :                 case 3:
     587             :                 case 4:
     588             :                 case 5:
     589             :                 case 6:
     590             :                 case 7:
     591    11996012 :                   return 1;
     592             : 
     593     2577892 :                 default:
     594     2577892 :                   return 0;
     595             :                 }
     596             :             }
     597             : 
     598     1412249 :           case PRISM6:
     599             :           case PRISM15:
     600             :           case PRISM18:
     601             :           case PRISM20:
     602             :           case PRISM21:
     603             :             {
     604     1412249 :               switch (n)
     605             :                 {
     606      339817 :                 case 0:
     607             :                 case 1:
     608             :                 case 2:
     609             :                 case 3:
     610             :                 case 4:
     611             :                 case 5:
     612      339817 :                   return 1;
     613             : 
     614       54208 :                 default:
     615       54208 :                   return 0;
     616             :                 }
     617             :             }
     618             : 
     619     1119730 :           case PYRAMID5:
     620             :           case PYRAMID13:
     621             :           case PYRAMID14:
     622             :           case PYRAMID18:
     623             :             {
     624     1119730 :               switch (n)
     625             :                 {
     626      284812 :                 case 0:
     627             :                 case 1:
     628             :                 case 2:
     629             :                 case 3:
     630             :                 case 4:
     631      284812 :                   return 1;
     632             : 
     633           0 :                 default:
     634           0 :                   return 0;
     635             :                 }
     636             :             }
     637             : 
     638           0 :           case INVALID_ELEM:
     639           0 :             return 0;
     640             : 
     641           0 :           default:
     642           0 :             libmesh_error_msg("ERROR: Bad ElemType = " << Utility::enum_to_string(t) << " for " << Utility::enum_to_string(o) << " order approximation!");
     643             :           }
     644             :       }
     645             : 
     646             :       // quadratic Lagrange shape functions
     647    98384953 :     case SECOND:
     648             :       {
     649    98384953 :         switch (t)
     650             :           {
     651             :             // quadratic lagrange has one dof at each node
     652    25818908 :           case NODEELEM:
     653             :           case EDGE3:
     654             :           case TRI6:
     655             :           case QUAD8:
     656             :           case QUADSHELL8:
     657             :           case QUAD9:
     658             :           case QUADSHELL9:
     659             :           case TET10:
     660             :           case HEX20:
     661             :           case HEX27:
     662             :           case PRISM15:
     663             :           case PRISM18:
     664             :           case PYRAMID13:
     665             :           case PYRAMID14:
     666    25818908 :             return 1;
     667             : 
     668     1114792 :           case PRISM20:
     669             :           case PRISM21:
     670     1114792 :             return (n < 18);
     671             : 
     672      177870 :           case PYRAMID18:
     673      177870 :             return (n < 14);
     674             : 
     675       14434 :           case TRI7:
     676       14434 :             return (n < 6);
     677             : 
     678      209174 :           case TET14:
     679      209174 :             return (n < 10);
     680             : 
     681           0 :           case INVALID_ELEM:
     682           0 :             return 0;
     683             : 
     684           0 :           default:
     685           0 :             libmesh_error_msg("ERROR: Bad ElemType = " << Utility::enum_to_string(t) << " for " << Utility::enum_to_string(o) << " order approximation!");
     686             :           }
     687             :       }
     688             : 
     689     2877498 :     case THIRD:
     690             :       {
     691     2121514 :         switch (t)
     692             :           {
     693      756488 :           case NODEELEM:
     694             :           case EDGE4:
     695             :           case PRISM20:
     696             :           case PRISM21:
     697             :           case PYRAMID18:
     698             :           case TRI7:
     699             :           case TET14:
     700      756488 :             return 1;
     701             : 
     702           0 :           case INVALID_ELEM:
     703           0 :             return 0;
     704             : 
     705           0 :           default:
     706           0 :             libmesh_error_msg("ERROR: Bad ElemType = " << Utility::enum_to_string(t) << " for " << Utility::enum_to_string(o) << " order approximation!");
     707             :           }
     708             :       }
     709             : 
     710           0 :     default:
     711           0 :       libmesh_error_msg("Unsupported order: " << o );
     712             :     }
     713             : }
     714             : 
     715             : 
     716             : 
     717    16181447 : unsigned int lagrange_n_dofs_at_node(const Elem & e,
     718             :                                      const Order o,
     719             :                                      const unsigned int n)
     720             : {
     721    22855477 :   return lagrange_n_dofs_at_node(e.type(), o, n);
     722             : }
     723             : 
     724             : 
     725             : #ifdef LIBMESH_ENABLE_AMR
     726     1560892 : void lagrange_compute_constraints (DofConstraints & constraints,
     727             :                                    DofMap & dof_map,
     728             :                                    const unsigned int variable_number,
     729             :                                    const Elem * elem,
     730             :                                    const unsigned Dim)
     731             : {
     732             :   // Only constrain elements in 2,3D.
     733     1560892 :   if (Dim == 1)
     734      139112 :     return;
     735             : 
     736      423004 :   libmesh_assert(elem);
     737             : 
     738             :   // Only constrain active and ancestor elements
     739     1560892 :   if (elem->subactive())
     740       36396 :     return;
     741             : 
     742             : #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
     743     1076650 :    if (elem->infinite())
     744             :    {
     745        3212 :       const FEType fe_t = dof_map.variable_type(variable_number);
     746             : 
     747             :       // expand the infinite_compute_constraint in its template-arguments.
     748        3212 :       switch(Dim)
     749             :       {
     750           0 :          case 2:
     751             :             {
     752           0 :             inf_fe_family_mapping_switch(2, inf_compute_constraints (constraints, dof_map, variable_number, elem) , ,; break;);
     753           0 :             break;
     754             :           }
     755        3212 :          case 3:
     756             :             {
     757        3212 :             inf_fe_family_mapping_switch(3, inf_compute_constraints (constraints, dof_map, variable_number, elem) , ,; break;);
     758        1056 :             break;
     759             :             }
     760           0 :          default:
     761           0 :            libmesh_error_msg("Invalid dim = " << Dim);
     762             :       }
     763        1056 :       return;
     764             :    }
     765             : #endif
     766             : 
     767     1421780 :   const Variable & var = dof_map.variable(variable_number);
     768     1421780 :   const FEType fe_type = var.type();
     769     1421780 :   const bool add_p_level = fe_type.p_refinement;
     770             : 
     771             :   // Pull objects out of the loop to reduce heap operations
     772      771104 :   std::vector<dof_id_type> my_dof_indices, parent_dof_indices;
     773     1724114 :   std::unique_ptr<const Elem> my_side, parent_side;
     774             : 
     775             :   // Look at the element faces.  Check to see if we need to
     776             :   // build constraints.
     777     7310450 :   for (auto s : elem->side_index_range())
     778     7484068 :     if (const Elem * const neigh = elem->neighbor_ptr(s);
     779     5538180 :         neigh && neigh != remote_elem)
     780             :       {
     781             :         // constrain dofs shared between this element and ones coarser
     782     5574294 :         if (neigh->level() < elem->level() &&
     783      124700 :             var.active_on_subdomain(neigh->subdomain_id()))
     784             :           {
     785             :             // than this element.
     786             :             // Get pointers to the elements of interest and its parent.
     787       72172 :             const Elem * parent = elem->parent();
     788             : 
     789             :             // This can't happen...  Only level-0 elements have nullptr
     790             :             // parents, and no level-0 elements can be at a higher
     791             :             // level than their neighbors!
     792       36086 :             libmesh_assert(parent);
     793             : 
     794      124588 :             elem->build_side_ptr(my_side, s);
     795      124588 :             parent->build_side_ptr(parent_side, s);
     796             : 
     797             :             // We have some elements with interior bubble function bases
     798             :             // and lower-order sides.  We need to only ask for the lower
     799             :             // order in those cases.
     800      124588 :             FEType side_fe_type = fe_type;
     801       36086 :             int extra_order = 0;
     802      124588 :             if (my_side->default_order() < fe_type.order)
     803             :               {
     804         368 :                 side_fe_type.order = my_side->default_order();
     805         460 :                 extra_order = (int)(side_fe_type.order) -
     806          92 :                               (int)(fe_type.order);
     807             :               }
     808             : 
     809             :             // This function gets called element-by-element, so there
     810             :             // will be a lot of memory allocation going on.  We can
     811             :             // at least minimize this for the case of the dof indices
     812             :             // by efficiently preallocating the requisite storage.
     813      124588 :             my_dof_indices.reserve (my_side->n_nodes());
     814      124588 :             parent_dof_indices.reserve (parent_side->n_nodes());
     815             : 
     816      124588 :             dof_map.dof_indices (my_side.get(), my_dof_indices,
     817       72172 :                                  variable_number, extra_order);
     818      124588 :             dof_map.dof_indices (parent_side.get(), parent_dof_indices,
     819       72172 :                                  variable_number, extra_order);
     820             : 
     821             :             const unsigned int n_side_dofs =
     822      124588 :               FEInterface::n_dofs(side_fe_type, my_side.get());
     823             :             const unsigned int n_parent_side_dofs =
     824      124588 :               FEInterface::n_dofs(side_fe_type, parent_side.get());
     825      444322 :             for (unsigned int my_dof=0; my_dof != n_side_dofs; my_dof++)
     826             :               {
     827       93642 :                 libmesh_assert_less (my_dof, my_side->n_nodes());
     828             : 
     829             :                 // My global dof index.
     830      413376 :                 const dof_id_type my_dof_g = my_dof_indices[my_dof];
     831             : 
     832             :                 // Hunt for "constraining against myself" cases before
     833             :                 // we bother creating a constraint row
     834       93642 :                 bool self_constraint = false;
     835      950486 :                 for (unsigned int their_dof=0;
     836     1044128 :                      their_dof != n_parent_side_dofs; their_dof++)
     837             :                   {
     838      256305 :                     libmesh_assert_less (their_dof, parent_side->n_nodes());
     839             : 
     840             :                     // Their global dof index.
     841             :                     const dof_id_type their_dof_g =
     842      864876 :                       parent_dof_indices[their_dof];
     843             : 
     844      864876 :                     if (their_dof_g == my_dof_g)
     845             :                       {
     846       40746 :                         self_constraint = true;
     847       40746 :                         break;
     848             :                       }
     849             :                   }
     850             : 
     851      319734 :                 if (self_constraint)
     852      240097 :                   continue;
     853             : 
     854             :                 DofConstraintRow * constraint_row;
     855             : 
     856             :                 // we may be running constraint methods concurrently
     857             :                 // on multiple threads, so we need a lock to
     858             :                 // ensure that this constraint is "ours"
     859             :                 {
     860       52896 :                   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     861             : 
     862      179252 :                   if (dof_map.is_constrained_dof(my_dof_g))
     863       29675 :                     continue;
     864             : 
     865       79637 :                   constraint_row = &(constraints[my_dof_g]);
     866       23221 :                   libmesh_assert(constraint_row->empty());
     867             :                 }
     868             : 
     869             :                 // The support point of the DOF
     870       46442 :                 const Point & support_point = my_side->point(my_dof);
     871             : 
     872             :                 // Figure out where my node lies on their reference element.
     873       33195 :                 const Point mapped_point = FEMap::inverse_map(Dim-1,
     874             :                                                               parent_side.get(),
     875       46442 :                                                               support_point);
     876             : 
     877             :                 // Compute the parent's side shape function values.
     878      273126 :                 for (unsigned int their_dof=0;
     879      329542 :                      their_dof != n_parent_side_dofs; their_dof++)
     880             :                   {
     881       73426 :                     libmesh_assert_less (their_dof, parent_side->n_nodes());
     882             : 
     883             :                     // Their global dof index.
     884             :                     const dof_id_type their_dof_g =
     885      323331 :                       parent_dof_indices[their_dof];
     886             : 
     887      249905 :                     const Real their_dof_value = FEInterface::shape(side_fe_type,
     888             :                                                                     parent_side.get(),
     889             :                                                                     their_dof,
     890      249905 :                                                                     mapped_point);
     891             : 
     892             :                     // Only add non-zero and non-identity values
     893             :                     // for Lagrange basis functions.
     894      307979 :                     if ((std::abs(their_dof_value) > 1.e-5) &&
     895       58074 :                         (std::abs(their_dof_value) < .999))
     896             :                       {
     897       58074 :                         constraint_row->emplace(their_dof_g, their_dof_value);
     898             :                       }
     899             :   #ifdef DEBUG
     900             :                     // Protect for the case u_i = 0.999 u_j,
     901             :                     // in which case i better equal j.
     902       15352 :                     else if (their_dof_value >= .999)
     903           0 :                       libmesh_assert_equal_to (my_dof_g, their_dof_g);
     904             :   #endif
     905             :                   }
     906             :               }
     907             :           }
     908             : 
     909     4982201 :         if (elem->active() && add_p_level)
     910             :           {
     911             :             // p refinement constraints:
     912             :             // constrain dofs shared between
     913             :             // active elements and neighbors with
     914             :             // lower polynomial degrees
     915             :             const unsigned int min_p_level =
     916     6051057 :               neigh->min_p_level_by_neighbor(elem, elem->p_level());
     917     6051057 :             if (min_p_level < elem->p_level())
     918           0 :               libmesh_error_msg(
     919             :                 "Mismatched p-refinement levels for LAGRANGE is not currently supported");
     920             :           }
     921             :       }
     922      348342 : } // lagrange_compute_constraints()
     923             : #endif // #ifdef LIBMESH_ENABLE_AMR
     924             : 
     925             : } // anonymous namespace
     926             : 
     927             : 
     928             : // Instantiate (side_) nodal_soln() function for every dimension
     929     2629588 : LIBMESH_FE_NODAL_SOLN(LAGRANGE, lagrange_nodal_soln)
     930         528 : LIBMESH_FE_SIDE_NODAL_SOLN(LAGRANGE)
     931             : 
     932             : 
     933             : // Do full-specialization for every dimension, instead
     934             : // of explicit instantiation at the end of this function.
     935             : // This could be macro-ified.
     936           0 : template <> unsigned int FE<0,LAGRANGE>::n_dofs(const ElemType t, const Order o) { return lagrange_n_dofs(t, nullptr, o); }
     937          21 : template <> unsigned int FE<1,LAGRANGE>::n_dofs(const ElemType t, const Order o) { return lagrange_n_dofs(t, nullptr, o); }
     938        1623 : template <> unsigned int FE<2,LAGRANGE>::n_dofs(const ElemType t, const Order o) { return lagrange_n_dofs(t, nullptr, o); }
     939          21 : template <> unsigned int FE<3,LAGRANGE>::n_dofs(const ElemType t, const Order o) { return lagrange_n_dofs(t, nullptr, o); }
     940             : 
     941       50999 : template <> unsigned int FE<0,LAGRANGE>::n_dofs(const Elem * e, const Order o) { return lagrange_n_dofs(e->type(), e, o); }
     942    33014761 : template <> unsigned int FE<1,LAGRANGE>::n_dofs(const Elem * e, const Order o) { return lagrange_n_dofs(e->type(), e, o); }
     943   232683789 : template <> unsigned int FE<2,LAGRANGE>::n_dofs(const Elem * e, const Order o) { return lagrange_n_dofs(e->type(), e, o); }
     944   155956067 : template <> unsigned int FE<3,LAGRANGE>::n_dofs(const Elem * e, const Order o) { return lagrange_n_dofs(e->type(), e, o); }
     945             : 
     946             : 
     947             : // Do full-specialization for every dimension, instead
     948             : // of explicit instantiation at the end of this function.
     949        4552 : template <> unsigned int FE<0,LAGRANGE>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return lagrange_n_dofs_at_node(t, o, n); }
     950     5885890 : template <> unsigned int FE<1,LAGRANGE>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return lagrange_n_dofs_at_node(t, o, n); }
     951   236027785 : template <> unsigned int FE<2,LAGRANGE>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return lagrange_n_dofs_at_node(t, o, n); }
     952    72881396 : template <> unsigned int FE<3,LAGRANGE>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return lagrange_n_dofs_at_node(t, o, n); }
     953             : 
     954        2820 : template <> unsigned int FE<0,LAGRANGE>::n_dofs_at_node(const Elem & e, const Order o, const unsigned int n) { return lagrange_n_dofs_at_node(e, o, n); }
     955       32218 : template <> unsigned int FE<1,LAGRANGE>::n_dofs_at_node(const Elem & e, const Order o, const unsigned int n) { return lagrange_n_dofs_at_node(e, o, n); }
     956    16100806 : template <> unsigned int FE<2,LAGRANGE>::n_dofs_at_node(const Elem & e, const Order o, const unsigned int n) { return lagrange_n_dofs_at_node(e, o, n); }
     957     6719633 : template <> unsigned int FE<3,LAGRANGE>::n_dofs_at_node(const Elem & e, const Order o, const unsigned int n) { return lagrange_n_dofs_at_node(e, o, n); }
     958             : 
     959             : 
     960             : // Lagrange elements have no dofs per element
     961             : // (just at the nodes)
     962           0 : template <> unsigned int FE<0,LAGRANGE>::n_dofs_per_elem(const ElemType, const Order) { return 0; }
     963           0 : template <> unsigned int FE<1,LAGRANGE>::n_dofs_per_elem(const ElemType, const Order) { return 0; }
     964           0 : template <> unsigned int FE<2,LAGRANGE>::n_dofs_per_elem(const ElemType, const Order) { return 0; }
     965           0 : template <> unsigned int FE<3,LAGRANGE>::n_dofs_per_elem(const ElemType, const Order) { return 0; }
     966             : 
     967        5962 : template <> unsigned int FE<0,LAGRANGE>::n_dofs_per_elem(const Elem &, const Order) { return 0; }
     968     2030382 : template <> unsigned int FE<1,LAGRANGE>::n_dofs_per_elem(const Elem &, const Order) { return 0; }
     969    49472421 : template <> unsigned int FE<2,LAGRANGE>::n_dofs_per_elem(const Elem &, const Order) { return 0; }
     970    10158673 : template <> unsigned int FE<3,LAGRANGE>::n_dofs_per_elem(const Elem &, const Order) { return 0; }
     971             : 
     972             : // Lagrange FEMs are always C^0 continuous
     973           0 : template <> FEContinuity FE<0,LAGRANGE>::get_continuity() const { return C_ZERO; }
     974        2372 : template <> FEContinuity FE<1,LAGRANGE>::get_continuity() const { return C_ZERO; }
     975      147824 : template <> FEContinuity FE<2,LAGRANGE>::get_continuity() const { return C_ZERO; }
     976       26570 : template <> FEContinuity FE<3,LAGRANGE>::get_continuity() const { return C_ZERO; }
     977             : 
     978             : // Lagrange FEMs are not hierarchic
     979           0 : template <> bool FE<0,LAGRANGE>::is_hierarchic() const { return false; }
     980          12 : template <> bool FE<1,LAGRANGE>::is_hierarchic() const { return false; }
     981          58 : template <> bool FE<2,LAGRANGE>::is_hierarchic() const { return false; }
     982         156 : template <> bool FE<3,LAGRANGE>::is_hierarchic() const { return false; }
     983             : 
     984             : // Lagrange FEM shapes do not need reinit (is this always true?)
     985        1028 : template <> bool FE<0,LAGRANGE>::shapes_need_reinit() const { return false; }
     986       10658 : template <> bool FE<1,LAGRANGE>::shapes_need_reinit() const { return false; }
     987    41180906 : template <> bool FE<2,LAGRANGE>::shapes_need_reinit() const { return false; }
     988     2231603 : template <> bool FE<3,LAGRANGE>::shapes_need_reinit() const { return false; }
     989             : 
     990             : // Methods for computing Lagrange constraints.  Note: we pass the
     991             : // dimension as the last argument to the anonymous helper function.
     992             : // Also note: we only need instantiations of this function for
     993             : // Dim==2 and 3.
     994             : #ifdef LIBMESH_ENABLE_AMR
     995             : template <>
     996     1146319 : void FE<2,LAGRANGE>::compute_constraints (DofConstraints & constraints,
     997             :                                           DofMap & dof_map,
     998             :                                           const unsigned int variable_number,
     999             :                                           const Elem * elem)
    1000     1146319 : { lagrange_compute_constraints(constraints, dof_map, variable_number, elem, /*Dim=*/2); }
    1001             : 
    1002             : template <>
    1003      414573 : void FE<3,LAGRANGE>::compute_constraints (DofConstraints & constraints,
    1004             :                                           DofMap & dof_map,
    1005             :                                           const unsigned int variable_number,
    1006             :                                           const Elem * elem)
    1007      414573 : { lagrange_compute_constraints(constraints, dof_map, variable_number, elem, /*Dim=*/3); }
    1008             : #endif // LIBMESH_ENABLE_AMR
    1009             : 
    1010             : } // namespace libMesh

Generated by: LCOV version 1.14