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