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
|