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

Generated by: LCOV version 1.14