LCOV - code coverage report
Current view: top level - src/fe - fe_lagrange_vec.C (source / functions) Hit Total Coverage
Test: libMesh/libmesh: #4573 (924896) with base 3f0912 Lines: 278 632 44.0 %
Date: 2026-11-18 21:52:26 Functions: 58 190 30.5 %
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/tensor_value.h"
      28             : 
      29             : 
      30             : namespace libMesh
      31             : {
      32             : 
      33             : 
      34           0 : LIBMESH_DEFAULT_VECTORIZED_FE(0,LAGRANGE_VEC)
      35           0 : LIBMESH_DEFAULT_VECTORIZED_FE(1,LAGRANGE_VEC)
      36       73365 : LIBMESH_DEFAULT_VECTORIZED_FE(2,LAGRANGE_VEC)
      37      778545 : LIBMESH_DEFAULT_VECTORIZED_FE(3,LAGRANGE_VEC)
      38           0 : LIBMESH_DEFAULT_VECTORIZED_FE(0,L2_LAGRANGE_VEC)
      39           0 : LIBMESH_DEFAULT_VECTORIZED_FE(1,L2_LAGRANGE_VEC)
      40     1774830 : LIBMESH_DEFAULT_VECTORIZED_FE(2,L2_LAGRANGE_VEC)
      41    12662820 : LIBMESH_DEFAULT_VECTORIZED_FE(3,L2_LAGRANGE_VEC)
      42             : 
      43             : 
      44             : // ------------------------------------------------------------
      45             : // Lagrange-specific implementations
      46             : 
      47             : 
      48             : // Anonymous namespace for local helper functions
      49             : namespace {
      50       28098 : void lagrange_vec_nodal_soln(const Elem * elem,
      51             :                              const Order order,
      52             :                              const std::vector<Number> & elem_soln,
      53             :                              const int dim,
      54             :                              std::vector<Number> &       nodal_soln,
      55             :                              const bool add_p_level)
      56             : {
      57       28098 :   const unsigned int n_nodes = elem->n_nodes();
      58       28098 :   const ElemType type        = elem->type();
      59             : 
      60       35337 :   const Order totalorder = order + add_p_level*elem->p_level();
      61             : 
      62       28098 :   nodal_soln.resize(dim*n_nodes);
      63             : 
      64       28098 :   switch (totalorder)
      65             :     {
      66             :       // linear Lagrange shape functions
      67       22329 :     case FIRST:
      68             :       {
      69       22329 :         switch (type)
      70             :           {
      71        1380 :           case TRI7:
      72         462 :             libmesh_assert_equal_to (nodal_soln.size(), 14);
      73        1842 :             nodal_soln[12] = (elem_soln[0] + elem_soln[2] + elem_soln[4])/3.;
      74        1842 :             nodal_soln[13] = (elem_soln[1] + elem_soln[3] + elem_soln[5])/3.;
      75             :             libmesh_fallthrough();
      76        6252 :           case TRI6:
      77             :             {
      78        1630 :               libmesh_assert (type == TRI7 || nodal_soln.size() == 12);
      79        1630 :               libmesh_assert_equal_to (elem_soln.size(), 2*3);
      80             : 
      81             :               // node 0 components
      82        6252 :               nodal_soln[0] = elem_soln[0];
      83        6252 :               nodal_soln[1] = elem_soln[1];
      84             : 
      85             :               // node 1 components
      86        6252 :               nodal_soln[2] = elem_soln[2];
      87        6252 :               nodal_soln[3] = elem_soln[3];
      88             : 
      89             :               // node 2 components
      90        6252 :               nodal_soln[4] = elem_soln[4];
      91        6252 :               nodal_soln[5] = elem_soln[5];
      92             : 
      93             :               // node 3 components
      94        6252 :               nodal_soln[6] = .5*(elem_soln[0] + elem_soln[2]);
      95        6252 :               nodal_soln[7] = .5*(elem_soln[1] + elem_soln[3]);
      96             : 
      97             :               // node 4 components
      98        6252 :               nodal_soln[8] = .5*(elem_soln[2] + elem_soln[4]);
      99        6252 :               nodal_soln[9] = .5*(elem_soln[3] + elem_soln[5]);
     100             : 
     101             :               // node 5 components
     102        6252 :               nodal_soln[10] = .5*(elem_soln[0] + elem_soln[4]);
     103        6252 :               nodal_soln[11] = .5*(elem_soln[1] + elem_soln[5]);
     104             : 
     105        6252 :               return;
     106             :             }
     107             : 
     108             : 
     109         450 :           case QUAD8:
     110             :           case QUAD9:
     111             :             {
     112         450 :               libmesh_assert_equal_to (elem_soln.size(), 2*4);
     113             : 
     114         450 :               if (type == QUAD8)
     115           0 :                 libmesh_assert_equal_to (nodal_soln.size(), 2*8);
     116             :               else
     117         450 :                 libmesh_assert_equal_to (nodal_soln.size(), 2*9);
     118             : 
     119             :               // node 0 components
     120        1800 :               nodal_soln[0] = elem_soln[0];
     121        1800 :               nodal_soln[1] = elem_soln[1];
     122             : 
     123             :               // node 1 components
     124        1800 :               nodal_soln[2] = elem_soln[2];
     125        1800 :               nodal_soln[3] = elem_soln[3];
     126             : 
     127             :               // node 2 components
     128        1800 :               nodal_soln[4] = elem_soln[4];
     129        1800 :               nodal_soln[5] = elem_soln[5];
     130             : 
     131             :               // node 3 components
     132        1800 :               nodal_soln[6] = elem_soln[6];
     133        1800 :               nodal_soln[7] = elem_soln[7];
     134             : 
     135             :               // node 4 components
     136        1800 :               nodal_soln[8] = .5*(elem_soln[0] + elem_soln[2]);
     137        1800 :               nodal_soln[9] = .5*(elem_soln[1] + elem_soln[3]);
     138             : 
     139             :               // node 5 components
     140        1800 :               nodal_soln[10] = .5*(elem_soln[2] + elem_soln[4]);
     141        1800 :               nodal_soln[11] = .5*(elem_soln[3] + elem_soln[5]);
     142             : 
     143             :               // node 6 components
     144        1800 :               nodal_soln[12] = .5*(elem_soln[4] + elem_soln[6]);
     145        1800 :               nodal_soln[13] = .5*(elem_soln[5] + elem_soln[7]);
     146             : 
     147             :               // node 7 components
     148        1800 :               nodal_soln[14] = .5*(elem_soln[6] + elem_soln[0]);
     149        1800 :               nodal_soln[15] = .5*(elem_soln[7] + elem_soln[1]);
     150             : 
     151        1800 :               if (type == QUAD9)
     152             :                 {
     153             :                   // node 8 components
     154        1800 :                   nodal_soln[16] = .25*(elem_soln[0] + elem_soln[2] + elem_soln[4] + elem_soln[6]);
     155        1800 :                   nodal_soln[17] = .25*(elem_soln[1] + elem_soln[3] + elem_soln[5] + elem_soln[7]);
     156             :                 }
     157             : 
     158         450 :               return;
     159             :             }
     160             : 
     161             : 
     162        6144 :           case TET14:
     163        3072 :             libmesh_assert_equal_to (nodal_soln.size(), 3*14);
     164             : 
     165             :             // node 10 components
     166       12288 :             nodal_soln[30] = 1./3. * (elem_soln[0] + elem_soln[3] + elem_soln[6]);
     167       12288 :             nodal_soln[31] = 1./3. * (elem_soln[1] + elem_soln[4] + elem_soln[7]);
     168       12288 :             nodal_soln[32] = 1./3. * (elem_soln[2] + elem_soln[5] + elem_soln[8]);
     169             : 
     170             :             // node 11 components
     171       12288 :             nodal_soln[33] = 1./3. * (elem_soln[0] + elem_soln[3] + elem_soln[9]);
     172       12288 :             nodal_soln[34] = 1./3. * (elem_soln[1] + elem_soln[4] + elem_soln[10]);
     173       12288 :             nodal_soln[35] = 1./3. * (elem_soln[2] + elem_soln[5] + elem_soln[11]);
     174             : 
     175             :             // node 12 components
     176       12288 :             nodal_soln[36] = 1./3. * (elem_soln[3] + elem_soln[6] + elem_soln[9]);
     177       12288 :             nodal_soln[37] = 1./3. * (elem_soln[4] + elem_soln[7] + elem_soln[10]);
     178       12288 :             nodal_soln[38] = 1./3. * (elem_soln[5] + elem_soln[8] + elem_soln[11]);
     179             : 
     180             :             // node 13 components
     181       12288 :             nodal_soln[39] = 1./3. * (elem_soln[0] + elem_soln[6] + elem_soln[9]);
     182       12288 :             nodal_soln[40] = 1./3. * (elem_soln[1] + elem_soln[7] + elem_soln[10]);
     183       12288 :             nodal_soln[41] = 1./3. * (elem_soln[2] + elem_soln[8] + elem_soln[11]);
     184             : 
     185             :             libmesh_fallthrough();
     186       12288 :           case TET10:
     187             :             {
     188        3072 :               libmesh_assert (type == TET14 || nodal_soln.size() == 3*10);
     189        3072 :               libmesh_assert_equal_to (elem_soln.size(), 3*4);
     190             : 
     191             :               // node 0 components
     192       12288 :               nodal_soln[0] = elem_soln[0];
     193       12288 :               nodal_soln[1] = elem_soln[1];
     194       12288 :               nodal_soln[2] = elem_soln[2];
     195             : 
     196             :               // node 1 components
     197       12288 :               nodal_soln[3] = elem_soln[3];
     198       12288 :               nodal_soln[4] = elem_soln[4];
     199       12288 :               nodal_soln[5] = elem_soln[5];
     200             : 
     201             :               // node 2 components
     202       12288 :               nodal_soln[6] = elem_soln[6];
     203       12288 :               nodal_soln[7] = elem_soln[7];
     204       12288 :               nodal_soln[8] = elem_soln[8];
     205             : 
     206             :               // node 3 components
     207       12288 :               nodal_soln[9]  = elem_soln[9];
     208       12288 :               nodal_soln[10] = elem_soln[10];
     209       12288 :               nodal_soln[11] = elem_soln[11];
     210             : 
     211             :               // node 4 components
     212       12288 :               nodal_soln[12] = .5*(elem_soln[0] + elem_soln[3]);
     213       12288 :               nodal_soln[13] = .5*(elem_soln[1] + elem_soln[4]);
     214       12288 :               nodal_soln[14] = .5*(elem_soln[2] + elem_soln[5]);
     215             : 
     216             :               // node 5 components
     217       12288 :               nodal_soln[15] = .5*(elem_soln[3] + elem_soln[6]);
     218       12288 :               nodal_soln[16] = .5*(elem_soln[4] + elem_soln[7]);
     219       12288 :               nodal_soln[17] = .5*(elem_soln[5] + elem_soln[8]);
     220             : 
     221             :               // node 6 components
     222       12288 :               nodal_soln[18] = .5*(elem_soln[6] + elem_soln[0]);
     223       12288 :               nodal_soln[19] = .5*(elem_soln[7] + elem_soln[1]);
     224       12288 :               nodal_soln[20] = .5*(elem_soln[8] + elem_soln[2]);
     225             : 
     226             :               // node 7 components
     227       12288 :               nodal_soln[21] = .5*(elem_soln[9]  + elem_soln[0]);
     228       12288 :               nodal_soln[22] = .5*(elem_soln[10] + elem_soln[1]);
     229       12288 :               nodal_soln[23] = .5*(elem_soln[11] + elem_soln[2]);
     230             : 
     231             :               // node 8 components
     232       12288 :               nodal_soln[24] = .5*(elem_soln[9]  + elem_soln[3]);
     233       12288 :               nodal_soln[25] = .5*(elem_soln[10] + elem_soln[4]);
     234       12288 :               nodal_soln[26] = .5*(elem_soln[11] + elem_soln[5]);
     235             : 
     236             :               // node 9 components
     237       12288 :               nodal_soln[27] = .5*(elem_soln[9]  + elem_soln[6]);
     238       12288 :               nodal_soln[28] = .5*(elem_soln[10] + elem_soln[7]);
     239       12288 :               nodal_soln[29] = .5*(elem_soln[11] + elem_soln[8]);
     240             : 
     241       12288 :               return;
     242             :             }
     243             : 
     244             : 
     245           0 :           case HEX20:
     246             :           case HEX27:
     247             :             {
     248           0 :               libmesh_assert_equal_to (elem_soln.size(), 3*8);
     249             : 
     250           0 :               if (type == HEX20)
     251           0 :                 libmesh_assert_equal_to (nodal_soln.size(), 3*20);
     252             :               else
     253           0 :                 libmesh_assert_equal_to (nodal_soln.size(), 3*27);
     254             : 
     255             :               // node 0 components
     256           0 :               nodal_soln[0]  = elem_soln[0];
     257           0 :               nodal_soln[1]  = elem_soln[1];
     258           0 :               nodal_soln[2]  = elem_soln[2];
     259             : 
     260             :               // node 1 components
     261           0 :               nodal_soln[3]  = elem_soln[3];
     262           0 :               nodal_soln[4]  = elem_soln[4];
     263           0 :               nodal_soln[5]  = elem_soln[5];
     264             : 
     265             :               // node 2 components
     266           0 :               nodal_soln[6]  = elem_soln[6];
     267           0 :               nodal_soln[7]  = elem_soln[7];
     268           0 :               nodal_soln[8]  = elem_soln[8];
     269             : 
     270             :               // node 3 components
     271           0 :               nodal_soln[9]   = elem_soln[9];
     272           0 :               nodal_soln[10]  = elem_soln[10];
     273           0 :               nodal_soln[11]  = elem_soln[11];
     274             : 
     275             :               // node 4 components
     276           0 :               nodal_soln[12]  = elem_soln[12];
     277           0 :               nodal_soln[13]  = elem_soln[13];
     278           0 :               nodal_soln[14]  = elem_soln[14];
     279             : 
     280             :               // node 5 components
     281           0 :               nodal_soln[15]  = elem_soln[15];
     282           0 :               nodal_soln[16]  = elem_soln[16];
     283           0 :               nodal_soln[17]  = elem_soln[17];
     284             : 
     285             :               // node 6 components
     286           0 :               nodal_soln[18]  = elem_soln[18];
     287           0 :               nodal_soln[19]  = elem_soln[19];
     288           0 :               nodal_soln[20]  = elem_soln[20];
     289             : 
     290             :               // node 7 components
     291           0 :               nodal_soln[21]  = elem_soln[21];
     292           0 :               nodal_soln[22]  = elem_soln[22];
     293           0 :               nodal_soln[23]  = elem_soln[23];
     294             : 
     295             :               // node 8 components
     296           0 :               nodal_soln[24]  = .5*(elem_soln[0] + elem_soln[3]);
     297           0 :               nodal_soln[25]  = .5*(elem_soln[1] + elem_soln[4]);
     298           0 :               nodal_soln[26]  = .5*(elem_soln[2] + elem_soln[5]);
     299             : 
     300             :               // node 9 components
     301           0 :               nodal_soln[27]  = .5*(elem_soln[3] + elem_soln[6]);
     302           0 :               nodal_soln[28]  = .5*(elem_soln[4] + elem_soln[7]);
     303           0 :               nodal_soln[29]  = .5*(elem_soln[5] + elem_soln[8]);
     304             : 
     305             :               // node 10 components
     306           0 :               nodal_soln[30]  = .5*(elem_soln[6] + elem_soln[9]);
     307           0 :               nodal_soln[31]  = .5*(elem_soln[7] + elem_soln[10]);
     308           0 :               nodal_soln[32]  = .5*(elem_soln[8] + elem_soln[11]);
     309             : 
     310             :               // node 11 components
     311           0 :               nodal_soln[33]  = .5*(elem_soln[9]  + elem_soln[0]);
     312           0 :               nodal_soln[34]  = .5*(elem_soln[10] + elem_soln[1]);
     313           0 :               nodal_soln[35]  = .5*(elem_soln[11] + elem_soln[2]);
     314             : 
     315             :               // node 12 components
     316           0 :               nodal_soln[36]  = .5*(elem_soln[0] + elem_soln[12]);
     317           0 :               nodal_soln[37]  = .5*(elem_soln[1] + elem_soln[13]);
     318           0 :               nodal_soln[38]  = .5*(elem_soln[2] + elem_soln[14]);
     319             : 
     320             :               // node 13 components
     321           0 :               nodal_soln[39]  = .5*(elem_soln[3] + elem_soln[15]);
     322           0 :               nodal_soln[40]  = .5*(elem_soln[4] + elem_soln[16]);
     323           0 :               nodal_soln[41]  = .5*(elem_soln[5] + elem_soln[17]);
     324             : 
     325             :               // node 14 components
     326           0 :               nodal_soln[42]  = .5*(elem_soln[6] + elem_soln[18]);
     327           0 :               nodal_soln[43]  = .5*(elem_soln[7] + elem_soln[19]);
     328           0 :               nodal_soln[44]  = .5*(elem_soln[8] + elem_soln[20]);
     329             : 
     330             :               // node 15 components
     331           0 :               nodal_soln[45]  = .5*(elem_soln[9]  + elem_soln[21]);
     332           0 :               nodal_soln[46]  = .5*(elem_soln[10] + elem_soln[22]);
     333           0 :               nodal_soln[47]  = .5*(elem_soln[11] + elem_soln[23]);
     334             : 
     335             :               // node 16 components
     336           0 :               nodal_soln[48]  = .5*(elem_soln[12] + elem_soln[15]);
     337           0 :               nodal_soln[49]  = .5*(elem_soln[13] + elem_soln[16]);
     338           0 :               nodal_soln[50]  = .5*(elem_soln[14] + elem_soln[17]);
     339             : 
     340             :               // node 17 components
     341           0 :               nodal_soln[51]  = .5*(elem_soln[15] + elem_soln[18]);
     342           0 :               nodal_soln[52]  = .5*(elem_soln[16] + elem_soln[19]);
     343           0 :               nodal_soln[53]  = .5*(elem_soln[17] + elem_soln[20]);
     344             : 
     345             :               // node 18 components
     346           0 :               nodal_soln[54]  = .5*(elem_soln[18] + elem_soln[21]);
     347           0 :               nodal_soln[55]  = .5*(elem_soln[19] + elem_soln[22]);
     348           0 :               nodal_soln[56]  = .5*(elem_soln[20] + elem_soln[23]);
     349             : 
     350             :               // node 19 components
     351           0 :               nodal_soln[57]  = .5*(elem_soln[12] + elem_soln[21]);
     352           0 :               nodal_soln[58]  = .5*(elem_soln[13] + elem_soln[22]);
     353           0 :               nodal_soln[59]  = .5*(elem_soln[14] + elem_soln[23]);
     354             : 
     355           0 :               if (type == HEX27)
     356             :                 {
     357             :                   // node 20 components
     358           0 :                   nodal_soln[60]  = .25*(elem_soln[0] + elem_soln[3] + elem_soln[6] + elem_soln[9]);
     359           0 :                   nodal_soln[61]  = .25*(elem_soln[1] + elem_soln[4] + elem_soln[7] + elem_soln[10]);
     360           0 :                   nodal_soln[62]  = .25*(elem_soln[2] + elem_soln[5] + elem_soln[8] + elem_soln[11]);
     361             : 
     362             :                   // node 21 components
     363           0 :                   nodal_soln[63]  = .25*(elem_soln[0] + elem_soln[3] + elem_soln[12] + elem_soln[15]);
     364           0 :                   nodal_soln[64]  = .25*(elem_soln[1] + elem_soln[4] + elem_soln[13] + elem_soln[16]);
     365           0 :                   nodal_soln[65]  = .25*(elem_soln[2] + elem_soln[5] + elem_soln[14] + elem_soln[17]);
     366             : 
     367             :                   // node 22 components
     368           0 :                   nodal_soln[66]  = .25*(elem_soln[3] + elem_soln[6] + elem_soln[15] + elem_soln[18]);
     369           0 :                   nodal_soln[67]  = .25*(elem_soln[4] + elem_soln[7] + elem_soln[16] + elem_soln[19]);
     370           0 :                   nodal_soln[68]  = .25*(elem_soln[5] + elem_soln[8] + elem_soln[17] + elem_soln[20]);
     371             : 
     372             :                   // node 23 components
     373           0 :                   nodal_soln[69]  = .25*(elem_soln[6] + elem_soln[9]  + elem_soln[18] + elem_soln[21]);
     374           0 :                   nodal_soln[70]  = .25*(elem_soln[7] + elem_soln[10] + elem_soln[19] + elem_soln[22]);
     375           0 :                   nodal_soln[71]  = .25*(elem_soln[8] + elem_soln[11] + elem_soln[20] + elem_soln[23]);
     376             : 
     377             :                   // node 24 components
     378           0 :                   nodal_soln[72]  = .25*(elem_soln[9]  + elem_soln[0] + elem_soln[21] + elem_soln[12]);
     379           0 :                   nodal_soln[73]  = .25*(elem_soln[10] + elem_soln[1] + elem_soln[22] + elem_soln[13]);
     380           0 :                   nodal_soln[74]  = .25*(elem_soln[11] + elem_soln[2] + elem_soln[23] + elem_soln[14]);
     381             : 
     382             :                   // node 25 components
     383           0 :                   nodal_soln[75]  = .25*(elem_soln[12] + elem_soln[15] + elem_soln[18] + elem_soln[21]);
     384           0 :                   nodal_soln[76]  = .25*(elem_soln[13] + elem_soln[16] + elem_soln[19] + elem_soln[22]);
     385           0 :                   nodal_soln[77]  = .25*(elem_soln[14] + elem_soln[17] + elem_soln[20] + elem_soln[23]);
     386             : 
     387             :                   // node 26 components
     388           0 :                   nodal_soln[78]  = .125*(elem_soln[0]  + elem_soln[3]  + elem_soln[6]  + elem_soln[9] +
     389           0 :                                           elem_soln[12] + elem_soln[15] + elem_soln[18] + elem_soln[21]);
     390             : 
     391           0 :                   nodal_soln[79]  = .125*(elem_soln[1]  + elem_soln[4]  + elem_soln[7]  + elem_soln[10] +
     392           0 :                                           elem_soln[13] + elem_soln[16] + elem_soln[19] + elem_soln[22]);
     393             : 
     394           0 :                   nodal_soln[80]  = .125*(elem_soln[2]  + elem_soln[5]  + elem_soln[8]  + elem_soln[11] +
     395           0 :                                           elem_soln[14] + elem_soln[17] + elem_soln[20] + elem_soln[23]);
     396             :                 }
     397             : 
     398           0 :               return;
     399             :             }
     400             : 
     401             : 
     402          90 :           case PRISM21:
     403          36 :             libmesh_assert_equal_to (nodal_soln.size(), 3*21);
     404             : 
     405             :             // node 20 components
     406         162 :             nodal_soln[60]  = (elem_soln[0] + elem_soln[3] + elem_soln[6] +
     407         108 :                                elem_soln[9] + elem_soln[12] + elem_soln[15])/Real(6);
     408         162 :             nodal_soln[61]  = (elem_soln[1] + elem_soln[4] + elem_soln[7] +
     409         108 :                                elem_soln[10] + elem_soln[13] + elem_soln[16])/Real(6);
     410         198 :             nodal_soln[62]  = (elem_soln[2] + elem_soln[5] + elem_soln[8] +
     411         108 :                                elem_soln[11] + elem_soln[14] + elem_soln[17])/Real(6);
     412             :             libmesh_fallthrough();
     413          72 :           case PRISM20:
     414          72 :             if (type == PRISM20)
     415          36 :               libmesh_assert_equal_to (nodal_soln.size(), 3*20);
     416             : 
     417             :             // node 18 components
     418         252 :             nodal_soln[54]  = (elem_soln[0] + elem_soln[3] + elem_soln[6])/Real(3);
     419         252 :             nodal_soln[55]  = (elem_soln[1] + elem_soln[4] + elem_soln[7])/Real(3);
     420         252 :             nodal_soln[56]  = (elem_soln[2] + elem_soln[5] + elem_soln[8])/Real(3);
     421             : 
     422             :             // node 19 components
     423         252 :             nodal_soln[57]  = (elem_soln[9] + elem_soln[12] + elem_soln[15])/Real(3);
     424         252 :             nodal_soln[58]  = (elem_soln[10] + elem_soln[13] + elem_soln[16])/Real(3);
     425         252 :             nodal_soln[59]  = (elem_soln[11] + elem_soln[14] + elem_soln[17])/Real(3);
     426             : 
     427             :             libmesh_fallthrough();
     428         108 :           case PRISM18:
     429         108 :             if (type == PRISM18)
     430          36 :               libmesh_assert_equal_to (nodal_soln.size(), 3*18);
     431             : 
     432             :             // node 15 components
     433         378 :             nodal_soln[45]  = .25*(elem_soln[0] + elem_soln[3] + elem_soln[12] + elem_soln[9]);
     434         378 :             nodal_soln[46]  = .25*(elem_soln[1] + elem_soln[4] + elem_soln[13] + elem_soln[10]);
     435         378 :             nodal_soln[47]  = .25*(elem_soln[2] + elem_soln[5] + elem_soln[14] + elem_soln[11]);
     436             : 
     437             :             // node 16 components
     438         378 :             nodal_soln[48]  = .25*(elem_soln[3] + elem_soln[6] + elem_soln[15] + elem_soln[12]);
     439         378 :             nodal_soln[49]  = .25*(elem_soln[4] + elem_soln[7] + elem_soln[16] + elem_soln[13]);
     440         378 :             nodal_soln[50]  = .25*(elem_soln[5] + elem_soln[8] + elem_soln[17] + elem_soln[14]);
     441             : 
     442             :             // node 17 components
     443         378 :             nodal_soln[51]  = .25*(elem_soln[6] + elem_soln[0] + elem_soln[9]  + elem_soln[15]);
     444         378 :             nodal_soln[52]  = .25*(elem_soln[7] + elem_soln[1] + elem_soln[10] + elem_soln[16]);
     445         378 :             nodal_soln[53]  = .25*(elem_soln[8] + elem_soln[2] + elem_soln[11] + elem_soln[17]);
     446             : 
     447             :             libmesh_fallthrough();
     448         144 :           case PRISM15:
     449             :             {
     450         144 :               libmesh_assert_equal_to (elem_soln.size(), 3*6);
     451             : 
     452         144 :               if (type == PRISM15)
     453          36 :                 libmesh_assert_equal_to (nodal_soln.size(), 3*15);
     454             : 
     455             :               // node 0 components
     456         504 :               nodal_soln[0]  = elem_soln[0];
     457         504 :               nodal_soln[1]  = elem_soln[1];
     458         504 :               nodal_soln[2]  = elem_soln[2];
     459             : 
     460             :               // node 1 components
     461         504 :               nodal_soln[3]  = elem_soln[3];
     462         504 :               nodal_soln[4]  = elem_soln[4];
     463         504 :               nodal_soln[5]  = elem_soln[5];
     464             : 
     465             :               // node 2 components
     466         504 :               nodal_soln[6]  = elem_soln[6];
     467         504 :               nodal_soln[7]  = elem_soln[7];
     468         504 :               nodal_soln[8]  = elem_soln[8];
     469             : 
     470             :               // node 3 components
     471         504 :               nodal_soln[9]   = elem_soln[9];
     472         504 :               nodal_soln[10]  = elem_soln[10];
     473         504 :               nodal_soln[11]  = elem_soln[11];
     474             : 
     475             :               // node 4 components
     476         504 :               nodal_soln[12]  = elem_soln[12];
     477         504 :               nodal_soln[13]  = elem_soln[13];
     478         504 :               nodal_soln[14]  = elem_soln[14];
     479             : 
     480             :               // node 5 components
     481         504 :               nodal_soln[15]  = elem_soln[15];
     482         504 :               nodal_soln[16]  = elem_soln[16];
     483         504 :               nodal_soln[17]  = elem_soln[17];
     484             : 
     485             :               // node 6 components
     486         504 :               nodal_soln[18]  = .5*(elem_soln[0] + elem_soln[3]);
     487         504 :               nodal_soln[19]  = .5*(elem_soln[1] + elem_soln[4]);
     488         504 :               nodal_soln[20]  = .5*(elem_soln[2] + elem_soln[5]);
     489             : 
     490             :               // node 7 components
     491         504 :               nodal_soln[21]  = .5*(elem_soln[3] + elem_soln[6]);
     492         504 :               nodal_soln[22]  = .5*(elem_soln[4] + elem_soln[7]);
     493         504 :               nodal_soln[23]  = .5*(elem_soln[5] + elem_soln[8]);
     494             : 
     495             :               // node 8 components
     496         504 :               nodal_soln[24]  = .5*(elem_soln[0] + elem_soln[6]);
     497         504 :               nodal_soln[25]  = .5*(elem_soln[1] + elem_soln[7]);
     498         504 :               nodal_soln[26]  = .5*(elem_soln[2] + elem_soln[8]);
     499             : 
     500             :               // node 9 components
     501         504 :               nodal_soln[27]  = .5*(elem_soln[0] + elem_soln[9]);
     502         504 :               nodal_soln[28]  = .5*(elem_soln[1] + elem_soln[10]);
     503         504 :               nodal_soln[29]  = .5*(elem_soln[2] + elem_soln[11]);
     504             : 
     505             :               // node 10 components
     506         504 :               nodal_soln[30]  = .5*(elem_soln[3] + elem_soln[12]);
     507         504 :               nodal_soln[31]  = .5*(elem_soln[4] + elem_soln[13]);
     508         504 :               nodal_soln[32]  = .5*(elem_soln[5] + elem_soln[14]);
     509             : 
     510             :               // node 11 components
     511         504 :               nodal_soln[33]  = .5*(elem_soln[6] + elem_soln[15]);
     512         504 :               nodal_soln[34]  = .5*(elem_soln[7] + elem_soln[16]);
     513         504 :               nodal_soln[35]  = .5*(elem_soln[8] + elem_soln[17]);
     514             : 
     515             :               // node 12 components
     516         504 :               nodal_soln[36]  = .5*(elem_soln[9]  + elem_soln[12]);
     517         504 :               nodal_soln[37]  = .5*(elem_soln[10] + elem_soln[13]);
     518         504 :               nodal_soln[38]  = .5*(elem_soln[11] + elem_soln[14]);
     519             : 
     520             :               // node 13 components
     521         504 :               nodal_soln[39]  = .5*(elem_soln[12] + elem_soln[15]);
     522         504 :               nodal_soln[40]  = .5*(elem_soln[13] + elem_soln[16]);
     523         504 :               nodal_soln[41]  = .5*(elem_soln[14] + elem_soln[17]);
     524             : 
     525             :               // node 14 components
     526         504 :               nodal_soln[42]  = .5*(elem_soln[9] + elem_soln[15]);
     527         504 :               nodal_soln[43]  = .5*(elem_soln[10] + elem_soln[16]);
     528         504 :               nodal_soln[44]  = .5*(elem_soln[11] + elem_soln[17]);
     529             : 
     530         504 :               return;
     531             :             }
     532             : 
     533        1485 :           default:
     534             :             {
     535             :               // By default the element solution _is_ nodal,
     536             :               // so just copy it.
     537        1485 :               nodal_soln = elem_soln;
     538             : 
     539        1485 :               return;
     540             :             }
     541             :           }
     542             :       }
     543             : 
     544        4138 :     case SECOND:
     545             :       {
     546        4138 :         switch (type)
     547             :           {
     548          24 :           case TRI7:
     549             :             {
     550          24 :               libmesh_assert_equal_to (elem_soln.size(), 12);
     551          24 :               libmesh_assert_equal_to (nodal_soln.size(), 14);
     552             : 
     553        1092 :               for (int i=0; i != 12; ++i)
     554        1584 :                 nodal_soln[i] = elem_soln[i];
     555             : 
     556         108 :               nodal_soln[12] = -1./9. * (elem_soln[0] + elem_soln[2] + elem_soln[4])
     557          72 :                                +4./9. * (elem_soln[6] + elem_soln[8] + elem_soln[10]);
     558         108 :               nodal_soln[13] = -1./9. * (elem_soln[1] + elem_soln[3] + elem_soln[5])
     559          72 :                                +4./9. * (elem_soln[7] + elem_soln[9] + elem_soln[11]);
     560             : 
     561          84 :               return;
     562             :             }
     563             : 
     564           0 :           case TET14:
     565             :             {
     566           0 :               libmesh_assert_equal_to (elem_soln.size(), 10*3);
     567           0 :               libmesh_assert_equal_to (nodal_soln.size(), 14*3);
     568             : 
     569           0 :               for (int i=0; i != 10*3; ++i)
     570           0 :                 nodal_soln[i] = elem_soln[i];
     571             : 
     572             :               // node 10 components
     573           0 :               nodal_soln[30] = -1./9. * (elem_soln[0] + elem_soln[3] + elem_soln[6])
     574           0 :                                +4./9. * (elem_soln[12] + elem_soln[15] + elem_soln[18]);
     575           0 :               nodal_soln[31] = -1./9. * (elem_soln[1] + elem_soln[4] + elem_soln[7])
     576           0 :                                +4./9. * (elem_soln[13] + elem_soln[16] + elem_soln[19]);
     577           0 :               nodal_soln[32] = -1./9. * (elem_soln[2] + elem_soln[5] + elem_soln[8])
     578           0 :                                +4./9. * (elem_soln[14] + elem_soln[17] + elem_soln[20]);
     579             : 
     580             :               // node 11 components
     581           0 :               nodal_soln[33] = -1./9. * (elem_soln[0] + elem_soln[3] + elem_soln[9])
     582           0 :                                +4./9. * (elem_soln[12] + elem_soln[21] + elem_soln[24]);
     583           0 :               nodal_soln[34] = -1./9. * (elem_soln[1] + elem_soln[4] + elem_soln[10])
     584           0 :                                +4./9. * (elem_soln[13] + elem_soln[22] + elem_soln[25]);
     585           0 :               nodal_soln[35] = -1./9. * (elem_soln[2] + elem_soln[5] + elem_soln[11])
     586           0 :                                +4./9. * (elem_soln[14] + elem_soln[23] + elem_soln[26]);
     587             : 
     588             :               // node 12 components
     589           0 :               nodal_soln[36] = -1./9. * (elem_soln[3] + elem_soln[6] + elem_soln[9])
     590           0 :                                +4./9. * (elem_soln[15] + elem_soln[24] + elem_soln[27]);
     591           0 :               nodal_soln[37] = -1./9. * (elem_soln[4] + elem_soln[7] + elem_soln[10])
     592           0 :                                +4./9. * (elem_soln[16] + elem_soln[25] + elem_soln[28]);
     593           0 :               nodal_soln[38] = -1./9. * (elem_soln[5] + elem_soln[8] + elem_soln[11])
     594           0 :                                +4./9. * (elem_soln[17] + elem_soln[26] + elem_soln[29]);
     595             : 
     596             :               // node 13 components
     597           0 :               nodal_soln[39] = -1./9. * (elem_soln[0] + elem_soln[6] + elem_soln[9])
     598           0 :                                +4./9. * (elem_soln[12] + elem_soln[21] + elem_soln[27]);
     599           0 :               nodal_soln[40] = -1./9. * (elem_soln[1] + elem_soln[7] + elem_soln[10])
     600           0 :                                +4./9. * (elem_soln[13] + elem_soln[22] + elem_soln[28]);
     601           0 :               nodal_soln[41] = -1./9. * (elem_soln[2] + elem_soln[8] + elem_soln[11])
     602           0 :                                +4./9. * (elem_soln[14] + elem_soln[23] + elem_soln[29]);
     603             : 
     604           0 :               return;
     605             :             }
     606             : 
     607        4054 :           default:
     608             :             {
     609             :               // By default the element solution _is_ nodal,
     610             :               // so just copy it.
     611        4054 :               nodal_soln = elem_soln;
     612             : 
     613        4054 :               return;
     614             :             }
     615             :           }
     616             :       }
     617             : 
     618        1631 :     case THIRD:
     619             :       {
     620             :         // By default the element solution _is_ nodal,
     621             :         // so just copy it.
     622        1631 :         nodal_soln = elem_soln;
     623             : 
     624        1631 :         return;
     625             :       }
     626             : 
     627           0 :     default:
     628           0 :       libmesh_error_msg("ERROR: Invalid Order " << Utility::enum_to_string(totalorder) << " selected for LAGRANGE FE family!");
     629             :     } // switch(totalorder)
     630             : 
     631             : }// void lagrange_vec_nodal_soln
     632             : 
     633             : } // anonymous namespace
     634             : 
     635             : 
     636             :   // Do full-specialization for every dimension, instead
     637             :   // of explicit instantiation at the end of this file.
     638             :   // This could be macro-ified so that it fits on one line...
     639           0 : LIBMESH_FE_NODAL_SOLN_DIM(LAGRANGE_VEC, (FE<0, LAGRANGE>::nodal_soln), 0)
     640           0 : LIBMESH_FE_NODAL_SOLN_DIM(LAGRANGE_VEC, (FE<1, LAGRANGE>::nodal_soln), 1)
     641             : 
     642             : template <>
     643       10328 : void FE<2,LAGRANGE_VEC>::nodal_soln(const Elem * elem,
     644             :                                     const Order order,
     645             :                                     const std::vector<Number> & elem_soln,
     646             :                                     std::vector<Number> & nodal_soln,
     647             :                                     const bool add_p_level,
     648             :                                     const unsigned)
     649       10328 : { lagrange_vec_nodal_soln(elem, order, elem_soln, 2 /*dim*/, nodal_soln, add_p_level); }
     650             : 
     651             : template <>
     652       17770 : void FE<3,LAGRANGE_VEC>::nodal_soln(const Elem * elem,
     653             :                                     const Order order,
     654             :                                     const std::vector<Number> & elem_soln,
     655             :                                     std::vector<Number> & nodal_soln,
     656             :                                     const bool add_p_level,
     657             :                                     const unsigned)
     658       17770 : { lagrange_vec_nodal_soln(elem, order, elem_soln, 3 /*dim*/, nodal_soln, add_p_level); }
     659             : 
     660           0 : LIBMESH_FE_SIDE_NODAL_SOLN(LAGRANGE_VEC)
     661             : 
     662           0 : LIBMESH_FE_NODAL_SOLN_DIM(L2_LAGRANGE_VEC, (FE<0, LAGRANGE_VEC>::nodal_soln), 0)
     663           0 : LIBMESH_FE_NODAL_SOLN_DIM(L2_LAGRANGE_VEC, (FE<1, LAGRANGE_VEC>::nodal_soln), 1)
     664        6168 : LIBMESH_FE_NODAL_SOLN_DIM(L2_LAGRANGE_VEC, (FE<2, LAGRANGE_VEC>::nodal_soln), 2)
     665       12288 : LIBMESH_FE_NODAL_SOLN_DIM(L2_LAGRANGE_VEC, (FE<3, LAGRANGE_VEC>::nodal_soln), 3)
     666             : 
     667           0 : LIBMESH_FE_SIDE_NODAL_SOLN(L2_LAGRANGE_VEC)
     668             : 
     669             : 
     670             : // Specialize for shape function routines by leveraging scalar LAGRANGE elements
     671             : 
     672             : // 0-D
     673           0 : template <> RealGradient FE<0,LAGRANGE_VEC>::shape(const ElemType type, const Order order,
     674             :                                                    const unsigned int i, const Point & p)
     675             : {
     676           0 :   Real value = FE<0,LAGRANGE>::shape( type, order, i, p );
     677           0 :   return libMesh::RealGradient( value );
     678             : }
     679           0 : template <> RealGradient FE<0,LAGRANGE_VEC>::shape_deriv(const ElemType type, const Order order,
     680             :                                                          const unsigned int i, const unsigned int j,
     681             :                                                          const Point & p)
     682             : {
     683           0 :   Real value = FE<0,LAGRANGE>::shape_deriv( type, order, i, j, p );
     684           0 :   return libMesh::RealGradient( value );
     685             : }
     686             : 
     687             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
     688             : 
     689           0 : template <> RealGradient FE<0,LAGRANGE_VEC>::shape_second_deriv(const ElemType type, const Order order,
     690             :                                                                 const unsigned int i, const unsigned int j,
     691             :                                                                 const Point & p)
     692             : {
     693           0 :   Real value = FE<0,LAGRANGE>::shape_second_deriv( type, order, i, j, p );
     694           0 :   return libMesh::RealGradient( value );
     695             : }
     696             : #endif
     697             : 
     698           0 : template <> RealGradient FE<0,L2_LAGRANGE_VEC>::shape(const ElemType type, const Order order,
     699             :                                                       const unsigned int i, const Point & p)
     700             : {
     701           0 :   return FE<0,LAGRANGE_VEC>::shape(type, order, i, p);
     702             : }
     703           0 : template <> RealGradient FE<0,L2_LAGRANGE_VEC>::shape_deriv(const ElemType type, const Order order,
     704             :                                                             const unsigned int i, const unsigned int j,
     705             :                                                             const Point & p)
     706             : {
     707           0 :   return FE<0,LAGRANGE_VEC>::shape_deriv(type, order, i, j, p);
     708             : }
     709             : 
     710             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
     711             : 
     712           0 : template <> RealGradient FE<0,L2_LAGRANGE_VEC>::shape_second_deriv(const ElemType type, const Order order,
     713             :                                                                    const unsigned int i, const unsigned int j,
     714             :                                                                    const Point & p)
     715             : {
     716           0 :   return FE<0,LAGRANGE_VEC>::shape_second_deriv(type, order, i, j, p);
     717             : }
     718             : #endif
     719             : 
     720             : // 1-D
     721           0 : template <> RealGradient FE<1,LAGRANGE_VEC>::shape(const ElemType type, const Order order,
     722             :                                                    const unsigned int i, const Point & p)
     723             : {
     724           0 :   Real value = FE<1,LAGRANGE>::shape( type, order, i, p );
     725           0 :   return libMesh::RealGradient( value );
     726             : }
     727           0 : template <> RealGradient FE<1,LAGRANGE_VEC>::shape_deriv(const ElemType type, const Order order,
     728             :                                                          const unsigned int i, const unsigned int j,
     729             :                                                          const Point & p)
     730             : {
     731           0 :   Real value = FE<1,LAGRANGE>::shape_deriv( type, order, i, j, p );
     732           0 :   return libMesh::RealGradient( value );
     733             : }
     734             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
     735           0 : template <> RealGradient FE<1,LAGRANGE_VEC>::shape_second_deriv(const ElemType type, const Order order,
     736             :                                                                 const unsigned int i, const unsigned int j,
     737             :                                                                 const Point & p)
     738             : {
     739           0 :   Real value = FE<1,LAGRANGE>::shape_second_deriv( type, order, i, j, p );
     740           0 :   return libMesh::RealGradient( value );
     741             : }
     742             : 
     743             : #endif
     744             : 
     745           0 : template <> RealGradient FE<1,L2_LAGRANGE_VEC>::shape(const ElemType type, const Order order,
     746             :                                                       const unsigned int i, const Point & p)
     747             : {
     748           0 :   return FE<1,LAGRANGE_VEC>::shape(type, order, i, p);
     749             : }
     750           0 : template <> RealGradient FE<1,L2_LAGRANGE_VEC>::shape_deriv(const ElemType type, const Order order,
     751             :                                                             const unsigned int i, const unsigned int j,
     752             :                                                             const Point & p)
     753             : {
     754           0 :   return FE<1,LAGRANGE_VEC>::shape_deriv(type, order, i, j, p);
     755             : }
     756             : 
     757             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
     758             : 
     759           0 : template <> RealGradient FE<1,L2_LAGRANGE_VEC>::shape_second_deriv(const ElemType type, const Order order,
     760             :                                                                    const unsigned int i, const unsigned int j,
     761             :                                                                    const Point & p)
     762             : {
     763           0 :   return FE<1,LAGRANGE_VEC>::shape_second_deriv(type, order, i, j, p);
     764             : }
     765             : #endif
     766             : 
     767             : // 2-D
     768           0 : template <> RealGradient FE<2,LAGRANGE_VEC>::shape(const ElemType type, const Order order,
     769             :                                                    const unsigned int i, const Point & p)
     770             : {
     771           0 :   Real value = FE<2,LAGRANGE>::shape( type, order, i/2, p );
     772             : 
     773           0 :   switch( i%2 )
     774             :     {
     775           0 :     case 0:
     776           0 :       return libMesh::RealGradient( value );
     777             : 
     778           0 :     case 1:
     779           0 :       return libMesh::RealGradient( Real(0), value );
     780             : 
     781           0 :     default:
     782           0 :       libmesh_error_msg("i%2 must be either 0 or 1!");
     783             :     }
     784             : 
     785             :   //dummy
     786             :   return libMesh::RealGradient();
     787             : }
     788           0 : template <> RealGradient FE<2,LAGRANGE_VEC>::shape_deriv(const ElemType type, const Order order,
     789             :                                                          const unsigned int i, const unsigned int j,
     790             :                                                          const Point & p)
     791             : {
     792           0 :   Real value = FE<2,LAGRANGE>::shape_deriv( type, order, i/2, j, p );
     793             : 
     794           0 :   switch( i%2 )
     795             :     {
     796           0 :     case 0:
     797           0 :       return libMesh::RealGradient( value );
     798             : 
     799           0 :     case 1:
     800           0 :       return libMesh::RealGradient( Real(0), value );
     801             : 
     802           0 :     default:
     803           0 :       libmesh_error_msg("i%2 must be either 0 or 1!");
     804             :     }
     805             : 
     806             :   //dummy
     807             :   return libMesh::RealGradient();
     808             : }
     809             : 
     810             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
     811           0 : template <> RealGradient FE<2,LAGRANGE_VEC>::shape_second_deriv(const ElemType type, const Order order,
     812             :                                                                 const unsigned int i, const unsigned int j,
     813             :                                                                 const Point & p)
     814             : {
     815           0 :   Real value = FE<2,LAGRANGE>::shape_second_deriv( type, order, i/2, j, p );
     816             : 
     817           0 :   switch( i%2 )
     818             :     {
     819           0 :     case 0:
     820           0 :       return libMesh::RealGradient( value );
     821             : 
     822           0 :     case 1:
     823           0 :       return libMesh::RealGradient( Real(0), value );
     824             : 
     825           0 :     default:
     826           0 :       libmesh_error_msg("i%2 must be either 0 or 1!");
     827             :     }
     828             : 
     829             :   //dummy
     830             :   return libMesh::RealGradient();
     831             : }
     832             : 
     833             : #endif
     834             : 
     835           0 : template <> RealGradient FE<2,L2_LAGRANGE_VEC>::shape(const ElemType type, const Order order,
     836             :                                                       const unsigned int i, const Point & p)
     837             : {
     838           0 :   return FE<2,LAGRANGE_VEC>::shape(type, order, i, p);
     839             : }
     840             : 
     841           0 : template <> RealGradient FE<2,L2_LAGRANGE_VEC>::shape_deriv(const ElemType type, const Order order,
     842             :                                                             const unsigned int i, const unsigned int j,
     843             :                                                             const Point & p)
     844             : {
     845           0 :   return FE<2,LAGRANGE_VEC>::shape_deriv(type, order, i, j, p);
     846             : }
     847             : 
     848             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
     849           0 : template <> RealGradient FE<2,L2_LAGRANGE_VEC>::shape_second_deriv(const ElemType type, const Order order,
     850             :                                                                    const unsigned int i, const unsigned int j,
     851             :                                                                    const Point & p)
     852             : {
     853           0 :   return FE<2,LAGRANGE_VEC>::shape_second_deriv(type, order, i, j, p);
     854             : }
     855             : 
     856             : #endif
     857             : 
     858             : // 3-D
     859           0 : template <> RealGradient FE<3,LAGRANGE_VEC>::shape(const ElemType type, const Order order,
     860             :                                                    const unsigned int i, const Point & p)
     861             : {
     862           0 :   Real value = FE<3,LAGRANGE>::shape( type, order, i/3, p );
     863             : 
     864           0 :   switch( i%3 )
     865             :     {
     866           0 :     case 0:
     867           0 :       return libMesh::RealGradient( value );
     868             : 
     869           0 :     case 1:
     870           0 :       return libMesh::RealGradient( Real(0), value );
     871             : 
     872           0 :     case 2:
     873           0 :       return libMesh::RealGradient( Real(0), Real(0), value );
     874             : 
     875           0 :     default:
     876           0 :       libmesh_error_msg("i%3 must be 0, 1, or 2!");
     877             :     }
     878             : 
     879             :   //dummy
     880             :   return libMesh::RealGradient();
     881             : }
     882           0 : template <> RealGradient FE<3,LAGRANGE_VEC>::shape_deriv(const ElemType type, const Order order,
     883             :                                                          const unsigned int i, const unsigned int j,
     884             :                                                          const Point & p)
     885             : {
     886           0 :   Real value = FE<3,LAGRANGE>::shape_deriv( type, order, i/3, j, p );
     887             : 
     888           0 :   switch( i%3 )
     889             :     {
     890           0 :     case 0:
     891           0 :       return libMesh::RealGradient( value );
     892             : 
     893           0 :     case 1:
     894           0 :       return libMesh::RealGradient( Real(0), value );
     895             : 
     896           0 :     case 2:
     897           0 :       return libMesh::RealGradient( Real(0), Real(0), value );
     898             : 
     899           0 :     default:
     900           0 :       libmesh_error_msg("i%3 must be 0, 1, or 2!");
     901             :     }
     902             : 
     903             :   //dummy
     904             :   return libMesh::RealGradient();
     905             : }
     906             : 
     907             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
     908             : 
     909           0 : template <> RealGradient FE<3,LAGRANGE_VEC>::shape_second_deriv(const ElemType type, const Order order,
     910             :                                                                 const unsigned int i, const unsigned int j,
     911             :                                                                 const Point & p)
     912             : {
     913           0 :   Real value = FE<3,LAGRANGE>::shape_second_deriv( type, order, i/3, j, p );
     914             : 
     915           0 :   switch( i%3 )
     916             :     {
     917           0 :     case 0:
     918           0 :       return libMesh::RealGradient( value );
     919             : 
     920           0 :     case 1:
     921           0 :       return libMesh::RealGradient( Real(0), value );
     922             : 
     923           0 :     case 2:
     924           0 :       return libMesh::RealGradient( Real(0), Real(0), value );
     925             : 
     926           0 :     default:
     927           0 :       libmesh_error_msg("i%3 must be 0, 1, or 2!");
     928             :     }
     929             : 
     930             :   //dummy
     931             :   return libMesh::RealGradient();
     932             : }
     933             : 
     934             : #endif
     935             : 
     936           0 : template <> RealGradient FE<3,L2_LAGRANGE_VEC>::shape(const ElemType type, const Order order,
     937             :                                                       const unsigned int i, const Point & p)
     938             : {
     939           0 :   return FE<3,LAGRANGE_VEC>::shape(type, order, i, p);
     940             : }
     941             : 
     942           0 : template <> RealGradient FE<3,L2_LAGRANGE_VEC>::shape_deriv(const ElemType type, const Order order,
     943             :                                                             const unsigned int i, const unsigned int j,
     944             :                                                             const Point & p)
     945             : {
     946           0 :   return FE<3,LAGRANGE_VEC>::shape_deriv(type, order, i, j, p);
     947             : }
     948             : 
     949             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
     950           0 : template <> RealGradient FE<3,L2_LAGRANGE_VEC>::shape_second_deriv(const ElemType type, const Order order,
     951             :                                                                    const unsigned int i, const unsigned int j,
     952             :                                                                    const Point & p)
     953             : {
     954           0 :   return FE<3,LAGRANGE_VEC>::shape_second_deriv(type, order, i, j, p);
     955             : }
     956             : 
     957             : #endif
     958             : 
     959             : 
     960             : // 0-D
     961           0 : template <> RealGradient FE<0,LAGRANGE_VEC>::shape(const Elem * elem, const Order order,
     962             :                                                    const unsigned int i, const Point & p,
     963             :                                                    const bool add_p_level)
     964             : {
     965           0 :   Real value = FE<0,LAGRANGE>::shape( elem->type(), order + add_p_level*elem->p_level(), i, p);
     966           0 :   return libMesh::RealGradient( value );
     967             : }
     968           0 : template <> RealGradient FE<0,LAGRANGE_VEC>::shape_deriv(const Elem * elem, const Order order,
     969             :                                                          const unsigned int i, const unsigned int j,
     970             :                                                          const Point & p,
     971             :                                                          const bool add_p_level)
     972             : {
     973           0 :   Real value = FE<0,LAGRANGE>::shape_deriv( elem->type(), order + add_p_level*elem->p_level(), i, j, p);
     974           0 :   return libMesh::RealGradient( value );
     975             : }
     976             : 
     977             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
     978             : 
     979           0 : template <> RealGradient FE<0,LAGRANGE_VEC>::shape_second_deriv(const Elem * elem, const Order order,
     980             :                                                                 const unsigned int i, const unsigned int j,
     981             :                                                                 const Point & p,
     982             :                                                                 const bool add_p_level)
     983             : {
     984           0 :   Real value = FE<0,LAGRANGE>::shape_second_deriv( elem->type(), order + add_p_level*elem->p_level(), i, j, p);
     985           0 :   return libMesh::RealGradient( value );
     986             : }
     987             : 
     988             : #endif
     989             : 
     990           0 : template <> RealGradient FE<0,L2_LAGRANGE_VEC>::shape(const Elem * elem, const Order order,
     991             :                                                       const unsigned int i, const Point & p,
     992             :                                                       const bool add_p_level)
     993             : {
     994           0 :   return FE<0,LAGRANGE_VEC>::shape(elem, order, i, p, add_p_level);
     995             : }
     996           0 : template <> RealGradient FE<0,L2_LAGRANGE_VEC>::shape_deriv(const Elem * elem, const Order order,
     997             :                                                             const unsigned int i, const unsigned int j,
     998             :                                                             const Point & p,
     999             :                                                             const bool add_p_level)
    1000             : {
    1001           0 :   return FE<0,LAGRANGE_VEC>::shape_deriv(elem, order, i, j, p, add_p_level);
    1002             : }
    1003             : 
    1004             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
    1005             : 
    1006           0 : template <> RealGradient FE<0,L2_LAGRANGE_VEC>::shape_second_deriv(const Elem * elem, const Order order,
    1007             :                                                                    const unsigned int i, const unsigned int j,
    1008             :                                                                    const Point & p,
    1009             :                                                                    const bool add_p_level)
    1010             : {
    1011           0 :   return FE<0,LAGRANGE_VEC>::shape_second_deriv(elem, order, i, j, p, add_p_level);
    1012             : }
    1013             : 
    1014             : #endif
    1015             : 
    1016             : // 1-D
    1017           0 : template <> RealGradient FE<1,LAGRANGE_VEC>::shape(const Elem * elem, const Order order,
    1018             :                                                    const unsigned int i, const Point & p,
    1019             :                                                    const bool add_p_level)
    1020             : {
    1021           0 :   Real value = FE<1,LAGRANGE>::shape( elem->type(), order + add_p_level*elem->p_level(), i, p);
    1022           0 :   return libMesh::RealGradient( value );
    1023             : }
    1024           0 : template <> RealGradient FE<1,LAGRANGE_VEC>::shape_deriv(const Elem * elem, const Order order,
    1025             :                                                          const unsigned int i, const unsigned int j,
    1026             :                                                          const Point & p,
    1027             :                                                          const bool add_p_level)
    1028             : {
    1029           0 :   Real value = FE<1,LAGRANGE>::shape_deriv( elem->type(), order + add_p_level*elem->p_level(), i, j, p);
    1030           0 :   return libMesh::RealGradient( value );
    1031             : }
    1032             : 
    1033             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
    1034           0 : template <> RealGradient FE<1,LAGRANGE_VEC>::shape_second_deriv(const Elem * elem, const Order order,
    1035             :                                                                 const unsigned int i, const unsigned int j,
    1036             :                                                                 const Point & p,
    1037             :                                                                 const bool add_p_level)
    1038             : {
    1039           0 :   Real value = FE<1,LAGRANGE>::shape_second_deriv( elem->type(), order + add_p_level*elem->p_level(), i, j, p);
    1040           0 :   return libMesh::RealGradient( value );
    1041             : }
    1042             : 
    1043             : #endif
    1044             : 
    1045           0 : template <> RealGradient FE<1,L2_LAGRANGE_VEC>::shape(const Elem * elem, const Order order,
    1046             :                                                       const unsigned int i, const Point & p,
    1047             :                                                       const bool add_p_level)
    1048             : {
    1049           0 :   return FE<1,LAGRANGE_VEC>::shape(elem, order, i, p, add_p_level);
    1050             : }
    1051           0 : template <> RealGradient FE<1,L2_LAGRANGE_VEC>::shape_deriv(const Elem * elem, const Order order,
    1052             :                                                             const unsigned int i, const unsigned int j,
    1053             :                                                             const Point & p,
    1054             :                                                             const bool add_p_level)
    1055             : {
    1056           0 :   return FE<1,LAGRANGE_VEC>::shape_deriv(elem, order, i, j, p, add_p_level);
    1057             : }
    1058             : 
    1059             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
    1060             : 
    1061           0 : template <> RealGradient FE<1,L2_LAGRANGE_VEC>::shape_second_deriv(const Elem * elem, const Order order,
    1062             :                                                                    const unsigned int i, const unsigned int j,
    1063             :                                                                    const Point & p,
    1064             :                                                                    const bool add_p_level)
    1065             : {
    1066           0 :   return FE<1,LAGRANGE_VEC>::shape_second_deriv(elem, order, i, j, p, add_p_level);
    1067             : }
    1068             : 
    1069             : #endif
    1070             : 
    1071             : // 2-D
    1072     4103754 : template <> RealGradient FE<2,LAGRANGE_VEC>::shape(const Elem * elem, const Order order,
    1073             :                                                    const unsigned int i, const Point & p,
    1074             :                                                    const bool add_p_level)
    1075             : {
    1076     6211202 :   Real value = FE<2,LAGRANGE>::shape( elem->type(), order + add_p_level*elem->p_level(), i/2, p );
    1077             : 
    1078     4103754 :   switch( i%2 )
    1079             :     {
    1080     2051877 :     case 0:
    1081      526862 :       return libMesh::RealGradient( value );
    1082             : 
    1083     2051877 :     case 1:
    1084      526862 :       return libMesh::RealGradient( Real(0), value );
    1085             : 
    1086           0 :     default:
    1087           0 :       libmesh_error_msg("i%2 must be either 0 or 1!");
    1088             :     }
    1089             : 
    1090             :   //dummy
    1091             :   return libMesh::RealGradient();
    1092             : }
    1093       13804 : template <> RealGradient FE<2,LAGRANGE_VEC>::shape_deriv(const Elem * elem, const Order order,
    1094             :                                                          const unsigned int i, const unsigned int j,
    1095             :                                                          const Point & p,
    1096             :                                                          const bool add_p_level)
    1097             : {
    1098       22076 :   Real value = FE<2,LAGRANGE>::shape_deriv( elem->type(), order + add_p_level*elem->p_level(), i/2, j, p );
    1099             : 
    1100       13804 :   switch( i%2 )
    1101             :     {
    1102        6902 :     case 0:
    1103        2068 :       return libMesh::RealGradient( value );
    1104             : 
    1105        6902 :     case 1:
    1106        2068 :       return libMesh::RealGradient( Real(0), value );
    1107             : 
    1108           0 :     default:
    1109           0 :       libmesh_error_msg("i%2 must be either 0 or 1!");
    1110             :     }
    1111             : 
    1112             :   //dummy
    1113             :   return libMesh::RealGradient();
    1114             : }
    1115             : 
    1116             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
    1117           0 : template <> RealGradient FE<2,LAGRANGE_VEC>::shape_second_deriv(const Elem * elem, const Order order,
    1118             :                                                                 const unsigned int i, const unsigned int j,
    1119             :                                                                 const Point & p,
    1120             :                                                                 const bool add_p_level)
    1121             : {
    1122           0 :   Real value = FE<2,LAGRANGE>::shape_second_deriv( elem->type(), order + add_p_level*elem->p_level(), i/2, j, p );
    1123             : 
    1124           0 :   switch( i%2 )
    1125             :     {
    1126           0 :     case 0:
    1127           0 :       return libMesh::RealGradient( value );
    1128             : 
    1129           0 :     case 1:
    1130           0 :       return libMesh::RealGradient( Real(0), value );
    1131             : 
    1132           0 :     default:
    1133           0 :       libmesh_error_msg("i%2 must be either 0 or 1!");
    1134             :     }
    1135             : 
    1136             :   //dummy
    1137             :   return libMesh::RealGradient();
    1138             : }
    1139             : 
    1140             : #endif
    1141             : 
    1142     3722976 : template <> RealGradient FE<2,L2_LAGRANGE_VEC>::shape(const Elem * elem, const Order order,
    1143             :                                                       const unsigned int i, const Point & p,
    1144             :                                                       const bool add_p_level)
    1145             : {
    1146     3722976 :   return FE<2,LAGRANGE_VEC>::shape(elem, order, i, p, add_p_level);
    1147             : }
    1148       11088 : template <> RealGradient FE<2,L2_LAGRANGE_VEC>::shape_deriv(const Elem * elem, const Order order,
    1149             :                                                             const unsigned int i, const unsigned int j,
    1150             :                                                             const Point & p,
    1151             :                                                             const bool add_p_level)
    1152             : {
    1153       11088 :   return FE<2,LAGRANGE_VEC>::shape_deriv(elem, order, i, j, p, add_p_level);
    1154             : }
    1155             : 
    1156             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
    1157             : 
    1158           0 : template <> RealGradient FE<2,L2_LAGRANGE_VEC>::shape_second_deriv(const Elem * elem, const Order order,
    1159             :                                                                    const unsigned int i, const unsigned int j,
    1160             :                                                                    const Point & p,
    1161             :                                                                    const bool add_p_level)
    1162             : {
    1163           0 :   return FE<2,LAGRANGE_VEC>::shape_second_deriv(elem, order, i, j, p, add_p_level);
    1164             : }
    1165             : 
    1166             : #endif
    1167             : 
    1168             : // 3-D
    1169    52050516 : template <> RealGradient FE<3,LAGRANGE_VEC>::shape(const Elem * elem, const Order order,
    1170             :                                                    const unsigned int i, const Point & p,
    1171             :                                                    const bool add_p_level)
    1172             : {
    1173    78085872 :   Real value = FE<3,LAGRANGE>::shape( elem->type(), order + add_p_level*elem->p_level(), i/3, p );
    1174             : 
    1175    52050516 :   switch( i%3 )
    1176             :     {
    1177    17350172 :     case 0:
    1178     4339226 :       return libMesh::RealGradient( value );
    1179             : 
    1180    17350172 :     case 1:
    1181     4339226 :       return libMesh::RealGradient( Real(0), value );
    1182             : 
    1183    17350172 :     case 2:
    1184     4339226 :       return libMesh::RealGradient( Real(0), Real(0), value );
    1185             : 
    1186           0 :     default:
    1187           0 :       libmesh_error_msg("i%3 must be 0, 1, or 2!");
    1188             :     }
    1189             : 
    1190             :   //dummy
    1191             :   return libMesh::RealGradient();
    1192             : }
    1193       64512 : template <> RealGradient FE<3,LAGRANGE_VEC>::shape_deriv(const Elem * elem, const Order order,
    1194             :                                                          const unsigned int i, const unsigned int j,
    1195             :                                                          const Point & p,
    1196             :                                                          const bool add_p_level)
    1197             : {
    1198      101376 :   Real value = FE<3,LAGRANGE>::shape_deriv( elem->type(), order + add_p_level*elem->p_level(), i/3, j, p );
    1199             : 
    1200       64512 :   switch( i%3 )
    1201             :     {
    1202       21504 :     case 0:
    1203        6144 :       return libMesh::RealGradient( value );
    1204             : 
    1205       21504 :     case 1:
    1206        6144 :       return libMesh::RealGradient( Real(0), value );
    1207             : 
    1208       21504 :     case 2:
    1209        6144 :       return libMesh::RealGradient( Real(0), Real(0), value );
    1210             : 
    1211           0 :     default:
    1212           0 :       libmesh_error_msg("i%3 must be 0, 1, or 2!");
    1213             :     }
    1214             : 
    1215             :   //dummy
    1216             :   return libMesh::RealGradient();
    1217             : }
    1218             : 
    1219             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
    1220             : 
    1221           0 : template <> RealGradient FE<3,LAGRANGE_VEC>::shape_second_deriv(const Elem * elem, const Order order,
    1222             :                                                                 const unsigned int i, const unsigned int j,
    1223             :                                                                 const Point & p,
    1224             :                                                                 const bool add_p_level)
    1225             : {
    1226           0 :   Real value = FE<3,LAGRANGE>::shape_second_deriv( elem->type(), order + add_p_level*elem->p_level(), i/3, j, p );
    1227             : 
    1228           0 :   switch( i%3 )
    1229             :     {
    1230           0 :     case 0:
    1231           0 :       return libMesh::RealGradient( value );
    1232             : 
    1233           0 :     case 1:
    1234           0 :       return libMesh::RealGradient( Real(0), value );
    1235             : 
    1236           0 :     case 2:
    1237           0 :       return libMesh::RealGradient( Real(0), Real(0), value );
    1238             : 
    1239           0 :     default:
    1240           0 :       libmesh_error_msg("i%3 must be 0, 1, or 2!");
    1241             :     }
    1242             : 
    1243             :   //dummy
    1244             :   return libMesh::RealGradient();
    1245             : }
    1246             : 
    1247             : #endif
    1248             : 
    1249    50282496 : template <> RealGradient FE<3,L2_LAGRANGE_VEC>::shape(const Elem * elem, const Order order,
    1250             :                                                       const unsigned int i, const Point & p,
    1251             :                                                       const bool add_p_level)
    1252             : {
    1253    50282496 :   return FE<3,LAGRANGE_VEC>::shape(elem, order, i, p, add_p_level);
    1254             : }
    1255       24192 : template <> RealGradient FE<3,L2_LAGRANGE_VEC>::shape_deriv(const Elem * elem, const Order order,
    1256             :                                                             const unsigned int i, const unsigned int j,
    1257             :                                                             const Point & p,
    1258             :                                                             const bool add_p_level)
    1259             : {
    1260       24192 :   return FE<3,LAGRANGE_VEC>::shape_deriv(elem, order, i, j, p, add_p_level);
    1261             : }
    1262             : 
    1263             : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
    1264             : 
    1265           0 : template <> RealGradient FE<3,L2_LAGRANGE_VEC>::shape_second_deriv(const Elem * elem, const Order order,
    1266             :                                                                    const unsigned int i, const unsigned int j,
    1267             :                                                                    const Point & p,
    1268             :                                                                    const bool add_p_level)
    1269             : {
    1270           0 :   return FE<3,LAGRANGE_VEC>::shape_second_deriv(elem, order, i, j, p, add_p_level);
    1271             : }
    1272             : 
    1273             : #endif
    1274             : 
    1275             : // Do full-specialization for every dimension, instead
    1276             : // of explicit instantiation at the end of this function.
    1277           0 : template <> unsigned int FE<0,LAGRANGE_VEC>::n_dofs(const ElemType t, const Order o) { return FE<0,LAGRANGE>::n_dofs(t,o); }
    1278           0 : template <> unsigned int FE<1,LAGRANGE_VEC>::n_dofs(const ElemType t, const Order o) { return FE<1,LAGRANGE>::n_dofs(t,o); }
    1279           0 : template <> unsigned int FE<2,LAGRANGE_VEC>::n_dofs(const ElemType t, const Order o) { return 2*FE<2,LAGRANGE>::n_dofs(t,o); }
    1280           0 : template <> unsigned int FE<3,LAGRANGE_VEC>::n_dofs(const ElemType t, const Order o) { return 3*FE<3,LAGRANGE>::n_dofs(t,o); }
    1281             : 
    1282           0 : template <> unsigned int FE<0,LAGRANGE_VEC>::n_dofs(const Elem * e, const Order o) { return FE<0,LAGRANGE>::n_dofs(e,o); }
    1283           0 : template <> unsigned int FE<1,LAGRANGE_VEC>::n_dofs(const Elem * e, const Order o) { return FE<1,LAGRANGE>::n_dofs(e,o); }
    1284        6019 : template <> unsigned int FE<2,LAGRANGE_VEC>::n_dofs(const Elem * e, const Order o) { return 2*FE<2,LAGRANGE>::n_dofs(e,o); }
    1285       31597 : template <> unsigned int FE<3,LAGRANGE_VEC>::n_dofs(const Elem * e, const Order o) { return 3*FE<3,LAGRANGE>::n_dofs(e,o); }
    1286             : 
    1287           0 : template <> unsigned int FE<0,L2_LAGRANGE_VEC>::n_dofs(const ElemType t, const Order o) { return FE<0,L2_LAGRANGE>::n_dofs(t,o); }
    1288           0 : template <> unsigned int FE<1,L2_LAGRANGE_VEC>::n_dofs(const ElemType t, const Order o) { return FE<1,L2_LAGRANGE>::n_dofs(t,o); }
    1289           0 : template <> unsigned int FE<2,L2_LAGRANGE_VEC>::n_dofs(const ElemType t, const Order o) { return 2*FE<2,L2_LAGRANGE>::n_dofs(t,o); }
    1290           0 : template <> unsigned int FE<3,L2_LAGRANGE_VEC>::n_dofs(const ElemType t, const Order o) { return 3*FE<3,L2_LAGRANGE>::n_dofs(t,o); }
    1291             : 
    1292           0 : template <> unsigned int FE<0,L2_LAGRANGE_VEC>::n_dofs(const Elem * e, const Order o) { return FE<0,L2_LAGRANGE>::n_dofs(e,o); }
    1293           0 : template <> unsigned int FE<1,L2_LAGRANGE_VEC>::n_dofs(const Elem * e, const Order o) { return FE<1,L2_LAGRANGE>::n_dofs(e,o); }
    1294      376584 : template <> unsigned int FE<2,L2_LAGRANGE_VEC>::n_dofs(const Elem * e, const Order o) { return 2*FE<2,L2_LAGRANGE>::n_dofs(e,o); }
    1295     1226920 : template <> unsigned int FE<3,L2_LAGRANGE_VEC>::n_dofs(const Elem * e, const Order o) { return 3*FE<3,L2_LAGRANGE>::n_dofs(e,o); }
    1296             : 
    1297             : 
    1298             : // Do full-specialization for every dimension, instead
    1299             : // of explicit instantiation at the end of this function.
    1300           0 : template <> unsigned int FE<0,LAGRANGE_VEC>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return FE<0,LAGRANGE>::n_dofs_at_node(t,o,n); }
    1301           0 : template <> unsigned int FE<1,LAGRANGE_VEC>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return FE<1,LAGRANGE>::n_dofs_at_node(t,o,n); }
    1302      141399 : template <> unsigned int FE<2,LAGRANGE_VEC>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return 2*FE<2,LAGRANGE>::n_dofs_at_node(t,o,n); }
    1303     1110042 : template <> unsigned int FE<3,LAGRANGE_VEC>::n_dofs_at_node(const ElemType t, const Order o, const unsigned int n) { return 3*FE<3,LAGRANGE>::n_dofs_at_node(t,o,n); }
    1304             : 
    1305           0 : template <> unsigned int FE<0,LAGRANGE_VEC>::n_dofs_at_node(const Elem & e, const Order o, const unsigned int n) { return FE<0,LAGRANGE>::n_dofs_at_node(e,o,n); }
    1306           0 : template <> unsigned int FE<1,LAGRANGE_VEC>::n_dofs_at_node(const Elem & e, const Order o, const unsigned int n) { return FE<1,LAGRANGE>::n_dofs_at_node(e,o,n); }
    1307       51846 : template <> unsigned int FE<2,LAGRANGE_VEC>::n_dofs_at_node(const Elem & e, const Order o, const unsigned int n) { return 2*FE<2,LAGRANGE>::n_dofs_at_node(e,o,n); }
    1308      137851 : template <> unsigned int FE<3,LAGRANGE_VEC>::n_dofs_at_node(const Elem & e, const Order o, const unsigned int n) { return 3*FE<3,LAGRANGE>::n_dofs_at_node(e,o,n); }
    1309             : 
    1310           0 : template <> unsigned int FE<0,L2_LAGRANGE_VEC>::n_dofs_at_node(const ElemType, const Order, const unsigned int) { return 0; }
    1311           0 : template <> unsigned int FE<1,L2_LAGRANGE_VEC>::n_dofs_at_node(const ElemType, const Order, const unsigned int) { return 0; }
    1312      742938 : template <> unsigned int FE<2,L2_LAGRANGE_VEC>::n_dofs_at_node(const ElemType, const Order, const unsigned int) { return 0; }
    1313     3408384 : template <> unsigned int FE<3,L2_LAGRANGE_VEC>::n_dofs_at_node(const ElemType, const Order, const unsigned int) { return 0; }
    1314             : 
    1315           0 : template <> unsigned int FE<0,L2_LAGRANGE_VEC>::n_dofs_at_node(const Elem &, const Order, const unsigned int) { return 0; }
    1316           0 : template <> unsigned int FE<1,L2_LAGRANGE_VEC>::n_dofs_at_node(const Elem &, const Order, const unsigned int) { return 0; }
    1317       95112 : template <> unsigned int FE<2,L2_LAGRANGE_VEC>::n_dofs_at_node(const Elem &, const Order, const unsigned int) { return 0; }
    1318      387072 : template <> unsigned int FE<3,L2_LAGRANGE_VEC>::n_dofs_at_node(const Elem &, const Order, const unsigned int) { return 0; }
    1319             : 
    1320             : 
    1321             : // Lagrange elements have no dofs per element
    1322             : // (just at the nodes)
    1323           0 : template <> unsigned int FE<0,LAGRANGE_VEC>::n_dofs_per_elem(const ElemType, const Order) { return 0; }
    1324           0 : template <> unsigned int FE<1,LAGRANGE_VEC>::n_dofs_per_elem(const ElemType, const Order) { return 0; }
    1325           0 : template <> unsigned int FE<2,LAGRANGE_VEC>::n_dofs_per_elem(const ElemType, const Order) { return 0; }
    1326           0 : template <> unsigned int FE<3,LAGRANGE_VEC>::n_dofs_per_elem(const ElemType, const Order) { return 0; }
    1327             : 
    1328           0 : template <> unsigned int FE<0,LAGRANGE_VEC>::n_dofs_per_elem(const Elem &, const Order) { return 0; }
    1329           0 : template <> unsigned int FE<1,LAGRANGE_VEC>::n_dofs_per_elem(const Elem &, const Order) { return 0; }
    1330       22995 : template <> unsigned int FE<2,LAGRANGE_VEC>::n_dofs_per_elem(const Elem &, const Order) { return 0; }
    1331      101567 : template <> unsigned int FE<3,LAGRANGE_VEC>::n_dofs_per_elem(const Elem &, const Order) { return 0; }
    1332             : 
    1333             : // L2 Lagrange elements have all their dofs on the element
    1334           0 : template <> unsigned int FE<0,L2_LAGRANGE_VEC>::n_dofs_per_elem(const ElemType t, const Order o) { return FE<0,L2_LAGRANGE_VEC>::n_dofs(t, o); }
    1335           0 : template <> unsigned int FE<1,L2_LAGRANGE_VEC>::n_dofs_per_elem(const ElemType t, const Order o) { return FE<1,L2_LAGRANGE_VEC>::n_dofs(t, o); }
    1336           0 : template <> unsigned int FE<2,L2_LAGRANGE_VEC>::n_dofs_per_elem(const ElemType t, const Order o) { return FE<2,L2_LAGRANGE_VEC>::n_dofs(t, o); }
    1337           0 : template <> unsigned int FE<3,L2_LAGRANGE_VEC>::n_dofs_per_elem(const ElemType t, const Order o) { return FE<3,L2_LAGRANGE_VEC>::n_dofs(t, o); }
    1338             : 
    1339           0 : template <> unsigned int FE<0,L2_LAGRANGE_VEC>::n_dofs_per_elem(const Elem & e, const Order o) { return FE<0,L2_LAGRANGE_VEC>::n_dofs(&e, o); }
    1340           0 : template <> unsigned int FE<1,L2_LAGRANGE_VEC>::n_dofs_per_elem(const Elem & e, const Order o) { return FE<1,L2_LAGRANGE_VEC>::n_dofs(&e, o); }
    1341      128100 : template <> unsigned int FE<2,L2_LAGRANGE_VEC>::n_dofs_per_elem(const Elem & e, const Order o) { return FE<2,L2_LAGRANGE_VEC>::n_dofs(&e, o); }
    1342      264960 : template <> unsigned int FE<3,L2_LAGRANGE_VEC>::n_dofs_per_elem(const Elem & e, const Order o) { return FE<3,L2_LAGRANGE_VEC>::n_dofs(&e, o); }
    1343             : 
    1344             : // Lagrange FEMs are always C^0 continuous
    1345           0 : template <> FEContinuity FE<0,LAGRANGE_VEC>::get_continuity() const { return C_ZERO; }
    1346           0 : template <> FEContinuity FE<1,LAGRANGE_VEC>::get_continuity() const { return C_ZERO; }
    1347        3576 : template <> FEContinuity FE<2,LAGRANGE_VEC>::get_continuity() const { return C_ZERO; }
    1348        4760 : template <> FEContinuity FE<3,LAGRANGE_VEC>::get_continuity() const { return C_ZERO; }
    1349             : 
    1350             : // L2 Lagrange FEMs are always discontinuous
    1351           0 : template <> FEContinuity FE<0,L2_LAGRANGE_VEC>::get_continuity() const { return DISCONTINUOUS; }
    1352           0 : template <> FEContinuity FE<1,L2_LAGRANGE_VEC>::get_continuity() const { return DISCONTINUOUS; }
    1353           0 : template <> FEContinuity FE<2,L2_LAGRANGE_VEC>::get_continuity() const { return DISCONTINUOUS; }
    1354           0 : template <> FEContinuity FE<3,L2_LAGRANGE_VEC>::get_continuity() const { return DISCONTINUOUS; }
    1355             : 
    1356             : // Lagrange FEMs are not hierarchic
    1357           0 : template <> bool FE<0,LAGRANGE_VEC>::is_hierarchic() const { return false; }
    1358           0 : template <> bool FE<1,LAGRANGE_VEC>::is_hierarchic() const { return false; }
    1359           0 : template <> bool FE<2,LAGRANGE_VEC>::is_hierarchic() const { return false; }
    1360           0 : template <> bool FE<3,LAGRANGE_VEC>::is_hierarchic() const { return false; }
    1361           0 : template <> bool FE<0,L2_LAGRANGE_VEC>::is_hierarchic() const { return false; }
    1362           0 : template <> bool FE<1,L2_LAGRANGE_VEC>::is_hierarchic() const { return false; }
    1363           0 : template <> bool FE<2,L2_LAGRANGE_VEC>::is_hierarchic() const { return false; }
    1364           0 : template <> bool FE<3,L2_LAGRANGE_VEC>::is_hierarchic() const { return false; }
    1365             : 
    1366             : // Lagrange FEM shapes do not need reinit (is this always true?)
    1367           0 : template <> bool FE<0,LAGRANGE_VEC>::shapes_need_reinit() const { return false; }
    1368           0 : template <> bool FE<1,LAGRANGE_VEC>::shapes_need_reinit() const { return false; }
    1369        7638 : template <> bool FE<2,LAGRANGE_VEC>::shapes_need_reinit() const { return false; }
    1370        5158 : template <> bool FE<3,LAGRANGE_VEC>::shapes_need_reinit() const { return false; }
    1371           0 : template <> bool FE<0,L2_LAGRANGE_VEC>::shapes_need_reinit() const { return false; }
    1372           0 : template <> bool FE<1,L2_LAGRANGE_VEC>::shapes_need_reinit() const { return false; }
    1373      353952 : template <> bool FE<2,L2_LAGRANGE_VEC>::shapes_need_reinit() const { return false; }
    1374     1194784 : template <> bool FE<3,L2_LAGRANGE_VEC>::shapes_need_reinit() const { return false; }
    1375             : 
    1376             : // Methods for computing Lagrange constraints.  Note: we pass the
    1377             : // dimension as the last argument to the anonymous helper function.
    1378             : // Also note: we only need instantiations of this function for
    1379             : // Dim==2 and 3.
    1380             : #ifdef LIBMESH_ENABLE_AMR
    1381             : template <>
    1382        2352 : void FE<2,LAGRANGE_VEC>::compute_constraints (DofConstraints & constraints,
    1383             :                                               DofMap & dof_map,
    1384             :                                               const unsigned int variable_number,
    1385             :                                               const Elem * elem)
    1386             : { //libmesh_not_implemented();
    1387        2352 :   FEVectorBase::compute_proj_constraints(constraints, dof_map, variable_number, elem);
    1388        2352 : }
    1389             : 
    1390             : template <>
    1391        3800 : void FE<3,LAGRANGE_VEC>::compute_constraints (DofConstraints & constraints,
    1392             :                                               DofMap & dof_map,
    1393             :                                               const unsigned int variable_number,
    1394             :                                               const Elem * elem)
    1395             : { //libmesh_not_implemented();
    1396        3800 :   FEVectorBase::compute_proj_constraints(constraints, dof_map, variable_number, elem);
    1397        3800 : }
    1398             : 
    1399             : template <>
    1400           0 : void FE<2,L2_LAGRANGE_VEC>::compute_constraints (DofConstraints & constraints,
    1401             :                                                  DofMap & dof_map,
    1402             :                                                  const unsigned int variable_number,
    1403             :                                                  const Elem * elem)
    1404             : { //libmesh_not_implemented();
    1405           0 :   FEVectorBase::compute_proj_constraints(constraints, dof_map, variable_number, elem);
    1406           0 : }
    1407             : 
    1408             : template <>
    1409           0 : void FE<3,L2_LAGRANGE_VEC>::compute_constraints (DofConstraints & constraints,
    1410             :                                                  DofMap & dof_map,
    1411             :                                                  const unsigned int variable_number,
    1412             :                                                  const Elem * elem)
    1413             : { //libmesh_not_implemented();
    1414           0 :   FEVectorBase::compute_proj_constraints(constraints, dof_map, variable_number, elem);
    1415           0 : }
    1416             : #endif // LIBMESH_ENABLE_AMR
    1417             : 
    1418             : } // namespace libMesh

Generated by: LCOV version 1.14