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

Generated by: LCOV version 1.14