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