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