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 : // Local includes
20 : #include "libmesh/fe.h"
21 : #include "libmesh/elem.h"
22 : #include "libmesh/fe_lagrange_shape_1D.h"
23 : #include "libmesh/fe_simplex_lagrange.h"
24 : #include "libmesh/fe_tensor_product_lagrange.h"
25 : #include "libmesh/enum_to_string.h"
26 : #include "libmesh/cell_c0polyhedron.h"
27 : #include "libmesh/tensor_value.h"
28 :
29 : // Anonymous namespace for functions shared by LAGRANGE and
30 : // L2_LAGRANGE implementations. Implementations appear at the bottom
31 : // of this file.
32 : namespace
33 : {
34 : using namespace libMesh;
35 :
36 : template <FEFamily T>
37 : Real fe_lagrange_3D_shape(const ElemType,
38 : const Order order,
39 : const Elem * elem,
40 : const unsigned int i,
41 : const Point & p);
42 :
43 : template <FEFamily T>
44 : Real fe_lagrange_3D_shape_deriv(const ElemType type,
45 : const Order order,
46 : const Elem * elem,
47 : const unsigned int i,
48 : const unsigned int j,
49 : const Point & p);
50 :
51 : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
52 :
53 : template <FEFamily T>
54 : Real fe_lagrange_3D_shape_second_deriv(const ElemType type,
55 : const Order order,
56 : const Elem * elem,
57 : const unsigned int i,
58 : const unsigned int j,
59 : const Point & p);
60 :
61 : #endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
62 :
63 : } // anonymous namespace
64 :
65 : namespace libMesh
66 : {
67 :
68 :
69 : // TODO: If optimizations for LAGRANGE work well we should do
70 : // L2_LAGRANGE too...
71 15341866 : LIBMESH_DEFAULT_VECTORIZED_FE(3,L2_LAGRANGE)
72 :
73 :
74 : template<>
75 6194143 : void FE<3,LAGRANGE>::all_shapes
76 : (const Elem * elem,
77 : const Order o,
78 : const std::vector<Point> & p,
79 : std::vector<std::vector<OutputShape>> & v,
80 : const bool add_p_level)
81 : {
82 6194143 : const ElemType type = elem->type();
83 :
84 : // Just loop on the harder-to-optimize cases
85 6194143 : if (type != HEX8 && type != HEX27)
86 : {
87 : FE<3,LAGRANGE>::default_all_shapes
88 5011492 : (elem,o,p,v,add_p_level);
89 5011492 : return;
90 : }
91 :
92 : #if LIBMESH_DIM == 3
93 :
94 1182651 : const unsigned int n_sf = v.size();
95 :
96 1182651 : switch (o)
97 : {
98 : // linear Lagrange shape functions
99 936822 : case FIRST:
100 : {
101 492518 : switch (type)
102 : {
103 : // trilinear hexahedral shape functions
104 246259 : case HEX8:
105 : case HEX20:
106 : case HEX27:
107 : {
108 246259 : libmesh_assert_less_equal (n_sf, 8);
109 :
110 7112705 : for (auto qp : index_range(p))
111 : {
112 1630894 : const Point & q_point = p[qp];
113 :
114 55582947 : for (unsigned int i : make_range(n_sf))
115 75501368 : v[i][qp] = libMesh::detail::fe_lagrange_hex8_shape(i, q_point(0), q_point(1), q_point(2));
116 : }
117 246259 : return;
118 : }
119 :
120 0 : default:
121 0 : libmesh_error(); // How did we get here?
122 : }
123 : }
124 :
125 :
126 : // quadratic Lagrange shape functions
127 245829 : case SECOND:
128 : {
129 245829 : switch (type)
130 : {
131 : // triquadratic hexahedral shape functions
132 59996 : case HEX8:
133 : // TODO: refactor to optimize this
134 : // libmesh_assert_msg(T == L2_LAGRANGE,
135 : // "High order on first order elements only supported for L2 families");
136 : libmesh_fallthrough();
137 : case HEX27:
138 : {
139 59996 : libmesh_assert_less_equal (n_sf, 27);
140 :
141 2475692 : for (auto qp : index_range(p))
142 : {
143 532195 : const Point & q_point = p[qp];
144 :
145 62436164 : for (unsigned int i : make_range(n_sf))
146 88944831 : v[i][qp] = libMesh::detail::fe_lagrange_hex27_shape(i, q_point(0), q_point(1), q_point(2));
147 : }
148 59996 : return;
149 : }
150 :
151 0 : default:
152 0 : libmesh_error(); // How did we get here?
153 : }
154 : }
155 :
156 : // unsupported order
157 0 : default:
158 0 : libmesh_error_msg("ERROR: Unsupported 3D FE order on HEX!: " << o);
159 : }
160 : #else // LIBMESH_DIM != 3
161 : libmesh_ignore(elem, o, p, v, add_p_level);
162 : libmesh_not_implemented();
163 : #endif // LIBMESH_DIM == 3
164 : }
165 :
166 : template<>
167 69777923 : void FE<3,LAGRANGE>::shapes
168 : (const Elem * elem,
169 : const Order o,
170 : const unsigned int i,
171 : const std::vector<Point> & p,
172 : std::vector<OutputShape> & v,
173 : const bool add_p_level)
174 : {
175 : FE<3,LAGRANGE>::default_shapes
176 69777923 : (elem,o,i,p,v,add_p_level);
177 69777923 : }
178 :
179 : template<>
180 265005600 : void FE<3,LAGRANGE>::shape_derivs
181 : (const Elem * elem,
182 : const Order o,
183 : const unsigned int i,
184 : const unsigned int j,
185 : const std::vector<Point> & p,
186 : std::vector<OutputShape> & v,
187 : const bool add_p_level)
188 : {
189 : FE<3,LAGRANGE>::default_shape_derivs
190 265005600 : (elem,o,i,j,p,v,add_p_level);
191 265005600 : }
192 :
193 : template<>
194 8980939 : void FE<3,LAGRANGE>::all_shape_derivs
195 : (const Elem * elem,
196 : const Order o,
197 : const std::vector<Point> & p,
198 : std::vector<std::vector<OutputShape>> * comps[3],
199 : const bool add_p_level)
200 : {
201 8980939 : const ElemType type = elem->type();
202 :
203 : // Just loop on the harder-to-optimize cases
204 8980939 : if (type != HEX8 && type != HEX27)
205 : {
206 : FE<3,LAGRANGE>::default_all_shape_derivs
207 6149557 : (elem,o,p,comps,add_p_level);
208 6149557 : return;
209 : }
210 :
211 : #if LIBMESH_DIM == 3
212 :
213 709143 : libmesh_assert(comps[0]);
214 709143 : libmesh_assert(comps[1]);
215 709143 : libmesh_assert(comps[2]);
216 2831382 : const unsigned int n_sf = comps[0]->size();
217 :
218 2831382 : switch (o)
219 : {
220 : // linear Lagrange shape functions
221 2174955 : case FIRST:
222 : {
223 1094670 : switch (type)
224 : {
225 : // trilinear hexahedral shape functions
226 547335 : case HEX8:
227 : case HEX20:
228 : case HEX27:
229 : {
230 547335 : libmesh_assert_equal_to (n_sf, 8);
231 :
232 5830946 : for (auto qp : index_range(p))
233 : {
234 932097 : const Point & q_point = p[qp];
235 32903919 : for (unsigned int i : make_range(n_sf))
236 : {
237 36704704 : (*comps[0])[i][qp] = libMesh::detail::fe_lagrange_hex8_shape_deriv(i, 0, q_point(0), q_point(1), q_point(2));
238 36704704 : (*comps[1])[i][qp] = libMesh::detail::fe_lagrange_hex8_shape_deriv(i, 1, q_point(0), q_point(1), q_point(2));
239 44161480 : (*comps[2])[i][qp] = libMesh::detail::fe_lagrange_hex8_shape_deriv(i, 2, q_point(0), q_point(1), q_point(2));
240 : }
241 : }
242 547335 : return;
243 : }
244 :
245 0 : default:
246 0 : libmesh_error(); // How did we get here?
247 : }
248 : }
249 :
250 :
251 : // quadratic Lagrange shape functions
252 656427 : case SECOND:
253 : {
254 656427 : switch (type)
255 : {
256 : // triquadratic hexahedral shape functions
257 161808 : case HEX8:
258 : // TODO: refactor to optimize this
259 : // libmesh_assert_msg(T == L2_LAGRANGE,
260 : // "High order on first order elements only supported for L2 families");
261 : libmesh_fallthrough();
262 : case HEX27:
263 : {
264 161808 : libmesh_assert_less_equal (n_sf, 27);
265 :
266 4061841 : for (auto qp : index_range(p))
267 : {
268 803892 : const Point & q_point = p[qp];
269 95351592 : for (unsigned int i : make_range(n_sf))
270 : {
271 113651262 : (*comps[0])[i][qp] = libMesh::detail::fe_lagrange_hex27_shape_deriv(i, 0, q_point(0), q_point(1), q_point(2));
272 113651262 : (*comps[1])[i][qp] = libMesh::detail::fe_lagrange_hex27_shape_deriv(i, 1, q_point(0), q_point(1), q_point(2));
273 135356346 : (*comps[2])[i][qp] = libMesh::detail::fe_lagrange_hex27_shape_deriv(i, 2, q_point(0), q_point(1), q_point(2));
274 : }
275 : }
276 161808 : return;
277 : }
278 :
279 0 : default:
280 0 : libmesh_error(); // How did we get here?
281 : }
282 : }
283 :
284 : // unsupported order
285 0 : default:
286 0 : libmesh_error_msg("ERROR: Unsupported 3D FE order on HEX!: " << o);
287 : }
288 : #else // LIBMESH_DIM != 3
289 : libmesh_ignore(elem, o, p, v, add_p_level);
290 : libmesh_not_implemented();
291 : #endif // LIBMESH_DIM == 3
292 : }
293 :
294 :
295 :
296 :
297 : template <>
298 80062236 : Real FE<3,LAGRANGE>::shape(const ElemType type,
299 : const Order order,
300 : const unsigned int i,
301 : const Point & p)
302 : {
303 80062236 : return fe_lagrange_3D_shape<LAGRANGE>(type, order, nullptr, i, p);
304 : }
305 :
306 :
307 :
308 : template <>
309 0 : Real FE<3,L2_LAGRANGE>::shape(const ElemType type,
310 : const Order order,
311 : const unsigned int i,
312 : const Point & p)
313 : {
314 0 : return fe_lagrange_3D_shape<L2_LAGRANGE>(type, order, nullptr, i, p);
315 : }
316 :
317 :
318 :
319 : template <>
320 352417346 : Real FE<3,LAGRANGE>::shape(const Elem * elem,
321 : const Order order,
322 : const unsigned int i,
323 : const Point & p,
324 : const bool add_p_level)
325 : {
326 88905631 : libmesh_assert(elem);
327 :
328 : // call the orientation-independent shape functions
329 530228608 : return fe_lagrange_3D_shape<LAGRANGE>(elem->type(), order + add_p_level*elem->p_level(), elem, i, p);
330 : }
331 :
332 :
333 :
334 : template <>
335 22439589 : Real FE<3,L2_LAGRANGE>::shape(const Elem * elem,
336 : const Order order,
337 : const unsigned int i,
338 : const Point & p,
339 : const bool add_p_level)
340 : {
341 5660926 : libmesh_assert(elem);
342 :
343 : // call the orientation-independent shape functions
344 33761441 : return fe_lagrange_3D_shape<L2_LAGRANGE>(elem->type(), order + add_p_level*elem->p_level(), elem, i, p);
345 : }
346 :
347 :
348 :
349 : template <>
350 482993387 : Real FE<3,LAGRANGE>::shape(const FEType fet,
351 : const Elem * elem,
352 : const unsigned int i,
353 : const Point & p,
354 : const bool add_p_level)
355 : {
356 141560480 : libmesh_assert(elem);
357 731410495 : return fe_lagrange_3D_shape<LAGRANGE>(elem->type(), fet.order + add_p_level*elem->p_level(), elem, i, p);
358 : }
359 :
360 :
361 :
362 : template <>
363 0 : Real FE<3,L2_LAGRANGE>::shape(const FEType fet,
364 : const Elem * elem,
365 : const unsigned int i,
366 : const Point & p,
367 : const bool add_p_level)
368 : {
369 0 : libmesh_assert(elem);
370 0 : return fe_lagrange_3D_shape<L2_LAGRANGE>(elem->type(), fet.order + add_p_level*elem->p_level(), elem, i, p);
371 : }
372 :
373 : template <>
374 90721512 : Real FE<3,LAGRANGE>::shape_deriv(const ElemType type,
375 : const Order order,
376 : const unsigned int i,
377 : const unsigned int j,
378 : const Point & p)
379 : {
380 90721512 : return fe_lagrange_3D_shape_deriv<LAGRANGE>(type, order, nullptr, i, j, p);
381 : }
382 :
383 :
384 :
385 : template <>
386 0 : Real FE<3,L2_LAGRANGE>::shape_deriv(const ElemType type,
387 : const Order order,
388 : const unsigned int i,
389 : const unsigned int j,
390 : const Point & p)
391 : {
392 0 : return fe_lagrange_3D_shape_deriv<L2_LAGRANGE>(type, order, nullptr, i, j, p);
393 : }
394 :
395 :
396 :
397 : template <>
398 1170702942 : Real FE<3,LAGRANGE>::shape_deriv(const Elem * elem,
399 : const Order order,
400 : const unsigned int i,
401 : const unsigned int j,
402 : const Point & p,
403 : const bool add_p_level)
404 : {
405 301912758 : libmesh_assert(elem);
406 :
407 : // call the orientation-independent shape function derivatives
408 1754128698 : return fe_lagrange_3D_shape_deriv<LAGRANGE>(elem->type(), order + add_p_level*elem->p_level(), elem, i, j, p);
409 : }
410 :
411 :
412 : template <>
413 13769610 : Real FE<3,L2_LAGRANGE>::shape_deriv(const Elem * elem,
414 : const Order order,
415 : const unsigned int i,
416 : const unsigned int j,
417 : const Point & p,
418 : const bool add_p_level)
419 : {
420 3593712 : libmesh_assert(elem);
421 :
422 : // call the orientation-independent shape function derivatives
423 20957034 : return fe_lagrange_3D_shape_deriv<L2_LAGRANGE>(elem->type(), order + add_p_level*elem->p_level(), elem, i, j, p);
424 : }
425 :
426 :
427 : template <>
428 3703424766 : Real FE<3,LAGRANGE>::shape_deriv(const FEType fet,
429 : const Elem * elem,
430 : const unsigned int i,
431 : const unsigned int j,
432 : const Point & p,
433 : const bool add_p_level)
434 : {
435 949846761 : libmesh_assert(elem);
436 5601201402 : return fe_lagrange_3D_shape_deriv<LAGRANGE>(elem->type(), fet.order + add_p_level*elem->p_level(), elem, i, j, p);
437 : }
438 :
439 :
440 : template <>
441 0 : Real FE<3,L2_LAGRANGE>::shape_deriv(const FEType fet,
442 : const Elem * elem,
443 : const unsigned int i,
444 : const unsigned int j,
445 : const Point & p,
446 : const bool add_p_level)
447 : {
448 0 : libmesh_assert(elem);
449 0 : return fe_lagrange_3D_shape_deriv<L2_LAGRANGE>(elem->type(), fet.order + add_p_level*elem->p_level(), elem, i, j, p);
450 : }
451 :
452 : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
453 :
454 : template <>
455 31940760 : Real FE<3,LAGRANGE>::shape_second_deriv(const ElemType type,
456 : const Order order,
457 : const unsigned int i,
458 : const unsigned int j,
459 : const Point & p)
460 : {
461 31940760 : return fe_lagrange_3D_shape_second_deriv<LAGRANGE>(type, order, nullptr, i, j, p);
462 : }
463 :
464 :
465 :
466 : template <>
467 0 : Real FE<3,L2_LAGRANGE>::shape_second_deriv(const ElemType type,
468 : const Order order,
469 : const unsigned int i,
470 : const unsigned int j,
471 : const Point & p)
472 : {
473 0 : return fe_lagrange_3D_shape_second_deriv<L2_LAGRANGE>(type, order, nullptr, i, j, p);
474 : }
475 :
476 :
477 :
478 : template <>
479 38132688 : Real FE<3,LAGRANGE>::shape_second_deriv(const Elem * elem,
480 : const Order order,
481 : const unsigned int i,
482 : const unsigned int j,
483 : const Point & p,
484 : const bool add_p_level)
485 : {
486 9932010 : libmesh_assert(elem);
487 :
488 : // call the orientation-independent shape function derivatives
489 : return fe_lagrange_3D_shape_second_deriv<LAGRANGE>
490 57996708 : (elem->type(), order + add_p_level*elem->p_level(), elem, i, j, p);
491 : }
492 :
493 :
494 :
495 : template <>
496 16229172 : Real FE<3,L2_LAGRANGE>::shape_second_deriv(const Elem * elem,
497 : const Order order,
498 : const unsigned int i,
499 : const unsigned int j,
500 : const Point & p,
501 : const bool add_p_level)
502 : {
503 4359504 : libmesh_assert(elem);
504 :
505 : // call the orientation-independent shape function derivatives
506 : return fe_lagrange_3D_shape_second_deriv<L2_LAGRANGE>
507 24948180 : (elem->type(), order + add_p_level*elem->p_level(), elem, i, j, p);
508 : }
509 :
510 :
511 : template <>
512 643274106 : Real FE<3,LAGRANGE>::shape_second_deriv(const FEType fet,
513 : const Elem * elem,
514 : const unsigned int i,
515 : const unsigned int j,
516 : const Point & p,
517 : const bool add_p_level)
518 : {
519 156721902 : libmesh_assert(elem);
520 : return fe_lagrange_3D_shape_second_deriv<LAGRANGE>
521 956717910 : (elem->type(), fet.order + add_p_level*elem->p_level(), elem, i, j, p);
522 : }
523 :
524 :
525 :
526 : template <>
527 0 : Real FE<3,L2_LAGRANGE>::shape_second_deriv(const FEType fet,
528 : const Elem * elem,
529 : const unsigned int i,
530 : const unsigned int j,
531 : const Point & p,
532 : const bool add_p_level)
533 : {
534 0 : libmesh_assert(elem);
535 : return fe_lagrange_3D_shape_second_deriv<L2_LAGRANGE>
536 0 : (elem->type(), fet.order + add_p_level*elem->p_level(), elem, i, j, p);
537 : }
538 :
539 :
540 : #endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
541 :
542 : } // namespace libMesh
543 :
544 :
545 :
546 : namespace
547 : {
548 : using namespace libMesh;
549 :
550 : template <FEFamily T>
551 1016787226 : Real fe_lagrange_3D_shape(const ElemType type,
552 : const Order order,
553 : const Elem * elem,
554 : const unsigned int i,
555 : const Point & p)
556 : {
557 : #if LIBMESH_DIM == 3
558 :
559 1016787226 : switch (order)
560 : {
561 : // linear Lagrange shape functions
562 156159755 : case FIRST:
563 : {
564 156159755 : switch (type)
565 : {
566 : // trilinear hexahedral shape functions
567 83076088 : case HEX8:
568 : case HEX20:
569 : case HEX27:
570 : {
571 23678696 : libmesh_assert_less (i, 8);
572 :
573 83076088 : return libMesh::detail::fe_lagrange_hex8_shape(i, p(0), p(1), p(2));
574 : }
575 :
576 : // linear tetrahedral shape functions
577 62092164 : case TET4:
578 : case TET10:
579 : case TET14:
580 : {
581 15737976 : libmesh_assert_less (i, 4);
582 62092164 : return libMesh::detail::fe_lagrange_tet4_shape(i, p(0), p(1), p(2));
583 : }
584 :
585 : // linear prism shape functions
586 5780754 : case PRISM6:
587 : case PRISM15:
588 : case PRISM18:
589 : case PRISM20:
590 : case PRISM21:
591 : {
592 1737090 : libmesh_assert_less (i, 6);
593 :
594 : // Compute prism shape functions as a tensor-product
595 : // of a triangle and an edge
596 :
597 5780754 : Point p2d(p(0),p(1));
598 5780754 : Real p1d = p(2);
599 :
600 : // 0 1 2 3 4 5
601 : static const unsigned int i0[] = {0, 0, 0, 1, 1, 1};
602 : static const unsigned int i1[] = {0, 1, 2, 0, 1, 2};
603 :
604 5780754 : return (FE<2,LAGRANGE>::shape(TRI3, FIRST, i1[i], p2d)*
605 9824418 : fe_lagrange_1D_linear_shape(i0[i], p1d));
606 : }
607 :
608 : // linear pyramid shape functions
609 330335 : case PYRAMID5:
610 : case PYRAMID13:
611 : case PYRAMID14:
612 : case PYRAMID18:
613 : {
614 93140 : libmesh_assert_less (i, 5);
615 :
616 330335 : const Real xi = p(0);
617 330335 : const Real eta = p(1);
618 330335 : const Real zeta = p(2);
619 93140 : const Real eps = 1.e-35;
620 :
621 330335 : switch(i)
622 : {
623 66067 : case 0:
624 66067 : return .25*(zeta + xi - 1.)*(zeta + eta - 1.)/((1. - zeta) + eps);
625 :
626 66067 : case 1:
627 66067 : return .25*(zeta - xi - 1.)*(zeta + eta - 1.)/((1. - zeta) + eps);
628 :
629 66067 : case 2:
630 66067 : return .25*(zeta - xi - 1.)*(zeta - eta - 1.)/((1. - zeta) + eps);
631 :
632 66067 : case 3:
633 66067 : return .25*(zeta + xi - 1.)*(zeta - eta - 1.)/((1. - zeta) + eps);
634 :
635 18628 : case 4:
636 18628 : return zeta;
637 :
638 0 : default:
639 0 : libmesh_error_msg("Invalid i = " << i);
640 : }
641 : }
642 :
643 4880414 : case C0POLYHEDRON:
644 : {
645 : // Polyhedra require using newer FE APIs
646 4880414 : if (!elem)
647 0 : libmesh_error_msg("Code (see stack trace) used an outdated FE function overload.\n"
648 : "Shape functions on a polyhedron are not defined by ElemType alone.");
649 :
650 1364801 : libmesh_assert(elem->type() == C0POLYHEDRON);
651 :
652 1364801 : const C0Polyhedron & poly = *cast_ptr<const C0Polyhedron *>(elem);
653 :
654 : // We can't use a small tolerance here, because in
655 : // inverse_map() Newton might hand us intermediate
656 : // iterates outside the polyhedron.
657 4880414 : const auto [s, a, b, c] = poly.subelement_coordinates(p, 100);
658 4880414 : if (s == invalid_uint)
659 0 : return 0;
660 1364801 : libmesh_assert_less(s, poly.n_subelements());
661 :
662 4880414 : const auto subtet = poly.subelement(s);
663 :
664 : // Avoid signed/unsigned comparison warnings
665 4880414 : const int nodei = i;
666 4880414 : if (nodei == subtet[0])
667 578398 : return 1-a-b-c;
668 4302016 : if (nodei == subtet[1])
669 578398 : return a;
670 3723618 : if (nodei == subtet[2])
671 578398 : return b;
672 3145220 : if (nodei == subtet[3])
673 578398 : return c;
674 :
675 : // Basis function i is not supported on p's subtet
676 717733 : return 0;
677 : }
678 :
679 0 : default:
680 0 : libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
681 : }
682 : }
683 :
684 :
685 : // quadratic Lagrange shape functions
686 293655121 : case SECOND:
687 : {
688 293655121 : switch (type)
689 : {
690 :
691 : // serendipity hexahedral quadratic shape functions
692 22257160 : case HEX20:
693 : {
694 6207020 : libmesh_assert_less (i, 20);
695 22257160 : return libMesh::detail::fe_lagrange_hex20_shape(i, p(0), p(1), p(2));
696 : }
697 :
698 : // triquadratic hexahedral shape functions
699 111160431 : case HEX8:
700 859761 : libmesh_assert_msg(T == L2_LAGRANGE,
701 : "High order on first order elements only supported for L2 families");
702 : libmesh_fallthrough();
703 42839820 : case HEX27:
704 : {
705 43823754 : libmesh_assert_less (i, 27);
706 :
707 154124424 : return libMesh::detail::fe_lagrange_hex27_shape(i, p(0), p(1), p(2));
708 : }
709 :
710 : // quadratic tetrahedral shape functions
711 35193050 : case TET4:
712 54360 : libmesh_assert_msg(T == L2_LAGRANGE,
713 : "High order on first order elements only supported for L2 families");
714 : libmesh_fallthrough();
715 12078110 : case TET10:
716 12186800 : libmesh_assert_less (i, 10);
717 : libmesh_fallthrough();
718 : case TET14:
719 : {
720 13576570 : libmesh_assert_less (i, 14);
721 48715260 : return libMesh::detail::fe_lagrange_tet10_shape(i, p(0), p(1), p(2));
722 : }
723 :
724 : // "serendipity" prism
725 18605640 : case PRISM15:
726 : {
727 5641470 : libmesh_assert_less (i, 15);
728 :
729 18605640 : const Real xi = p(0);
730 18605640 : const Real eta = p(1);
731 18605640 : const Real zeta = p(2);
732 :
733 18605640 : switch(i)
734 : {
735 1240376 : case 0:
736 1240376 : return (1. - zeta)*(xi + eta - 1.)*(xi + eta + 0.5*zeta);
737 :
738 1240376 : case 1:
739 1240376 : return (1. - zeta)*xi*(xi - 1. - 0.5*zeta);
740 :
741 1240376 : case 2: // phi1 with xi <- eta
742 1240376 : return (1. - zeta)*eta*(eta - 1. - 0.5*zeta);
743 :
744 1240376 : case 3: // phi0 with zeta <- (-zeta)
745 1240376 : return (1. + zeta)*(xi + eta - 1.)*(xi + eta - 0.5*zeta);
746 :
747 1240376 : case 4: // phi1 with zeta <- (-zeta)
748 1240376 : return (1. + zeta)*xi*(xi - 1. + 0.5*zeta);
749 :
750 1240376 : case 5: // phi4 with xi <- eta
751 1240376 : return (1. + zeta)*eta*(eta - 1. + 0.5*zeta);
752 :
753 1240376 : case 6:
754 1240376 : return 2.*(1. - zeta)*xi*(1. - xi - eta);
755 :
756 1240376 : case 7:
757 1240376 : return 2.*(1. - zeta)*xi*eta;
758 :
759 1240376 : case 8:
760 1240376 : return 2.*(1. - zeta)*eta*(1. - xi - eta);
761 :
762 1240376 : case 9:
763 1240376 : return (1. - zeta)*(1. + zeta)*(1. - xi - eta);
764 :
765 1240376 : case 10:
766 1240376 : return (1. - zeta)*(1. + zeta)*xi;
767 :
768 1240376 : case 11: // phi10 with xi <-> eta
769 1240376 : return (1. - zeta)*(1. + zeta)*eta;
770 :
771 1240376 : case 12: // phi6 with zeta <- (-zeta)
772 1240376 : return 2.*(1. + zeta)*xi*(1. - xi - eta);
773 :
774 1240376 : case 13: // phi7 with zeta <- (-zeta)
775 1240376 : return 2.*(1. + zeta)*xi*eta;
776 :
777 1240376 : case 14: // phi8 with zeta <- (-zeta)
778 1240376 : return 2.*(1. + zeta)*eta*(1. - xi - eta);
779 :
780 0 : default:
781 0 : libmesh_error_msg("Invalid i = " << i);
782 : }
783 : }
784 :
785 : // quadratic prism shape functions
786 28545174 : case PRISM6:
787 80460 : libmesh_assert_msg(T == L2_LAGRANGE,
788 : "High order on first order elements only supported for L2 families");
789 : libmesh_fallthrough();
790 12548304 : case PRISM18:
791 : case PRISM20:
792 : case PRISM21:
793 : {
794 12871620 : libmesh_assert_less (i, 18);
795 :
796 : // Compute prism shape functions as a tensor-product
797 : // of a triangle and an edge
798 :
799 41336334 : Point p2d(p(0),p(1));
800 41336334 : Real p1d = p(2);
801 :
802 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
803 : static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2};
804 : static const unsigned int i1[] = {0, 1, 2, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 3, 4, 5};
805 :
806 41336334 : return (FE<2,LAGRANGE>::shape(TRI6, SECOND, i1[i], p2d)*
807 53132238 : fe_lagrange_1D_quadratic_shape(i0[i], p1d));
808 : }
809 :
810 : // G. Bedrosian, "Shape functions and integration formulas for
811 : // three-dimensional finite element analysis", Int. J. Numerical
812 : // Methods Engineering, vol 35, p. 95-108, 1992.
813 4044911 : case PYRAMID13:
814 : {
815 1146548 : libmesh_assert_less (i, 13);
816 :
817 4044911 : const Real xi = p(0);
818 4044911 : const Real eta = p(1);
819 4044911 : const Real zeta = p(2);
820 1146548 : const Real eps = 1.e-35;
821 :
822 : // Denominators are perturbed by epsilon to avoid
823 : // divide-by-zero issues.
824 4044911 : Real den = (1. - zeta + eps);
825 :
826 4044911 : switch(i)
827 : {
828 311147 : case 0:
829 311147 : return 0.25*(-xi - eta - 1.)*((1. - xi)*(1. - eta) - zeta + xi*eta*zeta/den);
830 :
831 311147 : case 1:
832 311147 : return 0.25*(-eta + xi - 1.)*((1. + xi)*(1. - eta) - zeta - xi*eta*zeta/den);
833 :
834 311147 : case 2:
835 311147 : return 0.25*(xi + eta - 1.)*((1. + xi)*(1. + eta) - zeta + xi*eta*zeta/den);
836 :
837 311147 : case 3:
838 311147 : return 0.25*(eta - xi - 1.)*((1. - xi)*(1. + eta) - zeta - xi*eta*zeta/den);
839 :
840 311147 : case 4:
841 311147 : return zeta*(2.*zeta - 1.);
842 :
843 311147 : case 5:
844 311147 : return 0.5*(1. + xi - zeta)*(1. - xi - zeta)*(1. - eta - zeta)/den;
845 :
846 311147 : case 6:
847 311147 : return 0.5*(1. + eta - zeta)*(1. - eta - zeta)*(1. + xi - zeta)/den;
848 :
849 311147 : case 7:
850 311147 : return 0.5*(1. + xi - zeta)*(1. - xi - zeta)*(1. + eta - zeta)/den;
851 :
852 311147 : case 8:
853 311147 : return 0.5*(1. + eta - zeta)*(1. - eta - zeta)*(1. - xi - zeta)/den;
854 :
855 311147 : case 9:
856 311147 : return zeta*(1. - xi - zeta)*(1. - eta - zeta)/den;
857 :
858 311147 : case 10:
859 311147 : return zeta*(1. + xi - zeta)*(1. - eta - zeta)/den;
860 :
861 311147 : case 11:
862 311147 : return zeta*(1. + eta - zeta)*(1. + xi - zeta)/den;
863 :
864 311147 : case 12:
865 311147 : return zeta*(1. - xi - zeta)*(1. + eta - zeta)/den;
866 :
867 0 : default:
868 0 : libmesh_error_msg("Invalid i = " << i);
869 : }
870 : }
871 :
872 : // Quadratic shape functions, as defined in R. Graglia, "Higher order
873 : // bases on pyramidal elements", IEEE Trans Antennas and Propagation,
874 : // vol 47, no 5, May 1999.
875 3276336 : case PYRAMID5:
876 0 : libmesh_assert_msg(T == L2_LAGRANGE,
877 : "High order on first order elements only supported for L2 families");
878 : libmesh_fallthrough();
879 1295056 : case PYRAMID14:
880 : case PYRAMID18:
881 : {
882 1295056 : libmesh_assert_less (i, 14);
883 :
884 4571392 : const Real xi = p(0);
885 4571392 : const Real eta = p(1);
886 4571392 : const Real zeta = p(2);
887 1295056 : const Real eps = 1.e-35;
888 :
889 : // The "normalized coordinates" defined by Graglia. These are
890 : // the planes which define the faces of the pyramid.
891 : Real
892 4571392 : p1 = 0.5*(1. - eta - zeta), // back
893 4571392 : p2 = 0.5*(1. + xi - zeta), // left
894 4571392 : p3 = 0.5*(1. + eta - zeta), // front
895 4571392 : p4 = 0.5*(1. - xi - zeta); // right
896 :
897 : // Denominators are perturbed by epsilon to avoid
898 : // divide-by-zero issues.
899 : Real
900 4571392 : den = (-1. + zeta + eps),
901 4571392 : den2 = den*den;
902 :
903 4571392 : switch(i)
904 : {
905 326528 : case 0:
906 326528 : return p4*p1*(xi*eta - zeta + zeta*zeta)/den2;
907 :
908 326528 : case 1:
909 326528 : return -p1*p2*(xi*eta + zeta - zeta*zeta)/den2;
910 :
911 326528 : case 2:
912 326528 : return p2*p3*(xi*eta - zeta + zeta*zeta)/den2;
913 :
914 326528 : case 3:
915 326528 : return -p3*p4*(xi*eta + zeta - zeta*zeta)/den2;
916 :
917 326528 : case 4:
918 326528 : return zeta*(2.*zeta - 1.);
919 :
920 326528 : case 5:
921 326528 : return -4.*p2*p1*p4*eta/den2;
922 :
923 326528 : case 6:
924 326528 : return 4.*p1*p2*p3*xi/den2;
925 :
926 326528 : case 7:
927 326528 : return 4.*p2*p3*p4*eta/den2;
928 :
929 326528 : case 8:
930 326528 : return -4.*p3*p4*p1*xi/den2;
931 :
932 326528 : case 9:
933 326528 : return -4.*p1*p4*zeta/den;
934 :
935 326528 : case 10:
936 326528 : return -4.*p2*p1*zeta/den;
937 :
938 326528 : case 11:
939 326528 : return -4.*p3*p2*zeta/den;
940 :
941 326528 : case 12:
942 326528 : return -4.*p4*p3*zeta/den;
943 :
944 326528 : case 13:
945 326528 : return 16.*p1*p2*p3*p4/den2;
946 :
947 0 : default:
948 0 : libmesh_error_msg("Invalid i = " << i);
949 : }
950 : }
951 :
952 :
953 0 : default:
954 0 : libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
955 : }
956 : }
957 :
958 566972350 : case THIRD:
959 : {
960 566972350 : switch (type)
961 : {
962 : // quadratic Lagrange shape functions with cubic bubbles
963 28011720 : case PRISM20:
964 : {
965 8307120 : libmesh_assert_less (i, 20);
966 :
967 : // Compute Prism21 shape functions as a tensor-product
968 : // of a triangle and an edge, then redistribute the
969 : // central bubble function over the other Tri6 nodes
970 : // around it (in a way consistent with the Tri7 shape
971 : // function definitions).
972 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
973 : static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2, 0, 1};
974 :
975 28011720 : Point p2d(p(0),p(1));
976 28011720 : Real p1d = p(2);
977 :
978 28011720 : const Real mainval = FE<3,LAGRANGE>::shape(PRISM21, THIRD, i, p);
979 :
980 28011720 : if (i0[i] != 2)
981 5814984 : return mainval;
982 :
983 8403516 : const Real bubbleval =
984 8403516 : FE<2,LAGRANGE>::shape(TRI7, THIRD, 6, p2d) *
985 2492136 : fe_lagrange_1D_quadratic_shape(2, p1d);
986 :
987 8403516 : if (i < 12) // vertices
988 4201758 : return mainval - bubbleval / 9;
989 :
990 4201758 : return mainval + bubbleval * (Real(4) / 9);
991 : }
992 :
993 : // quadratic Lagrange shape functions with cubic bubbles
994 72085470 : case PRISM21:
995 : {
996 21349086 : libmesh_assert_less (i, 21);
997 :
998 : // Compute prism shape functions as a tensor-product
999 : // of a triangle and an edge
1000 :
1001 72085470 : Point p2d(p(0),p(1));
1002 72085470 : Real p1d = p(2);
1003 :
1004 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
1005 : static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2, 0, 1, 2};
1006 : static const unsigned int i1[] = {0, 1, 2, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 3, 4, 5, 6, 6, 6};
1007 :
1008 72085470 : return (FE<2,LAGRANGE>::shape(TRI7, THIRD, i1[i], p2d)*
1009 91409082 : fe_lagrange_1D_quadratic_shape(i0[i], p1d));
1010 : }
1011 :
1012 : // Weird rational shape functions with weirder bubbles...
1013 90004050 : case PYRAMID18:
1014 : {
1015 25210692 : libmesh_assert_less (i, 18);
1016 :
1017 90004050 : const Real xi = p(0);
1018 90004050 : const Real eta = p(1);
1019 90004050 : const Real zeta = p(2);
1020 25210692 : const Real eps = 1.e-35;
1021 :
1022 : // The "normalized coordinates" defined by Graglia. These are
1023 : // the planes which define the faces of the pyramid.
1024 : const Real
1025 90004050 : p1 = 0.5*(1. - eta - zeta), // back
1026 90004050 : p2 = 0.5*(1. + xi - zeta), // left
1027 90004050 : p3 = 0.5*(1. + eta - zeta), // front
1028 90004050 : p4 = 0.5*(1. - xi - zeta); // right
1029 :
1030 : // Denominators are perturbed by epsilon to avoid
1031 : // divide-by-zero issues.
1032 : const Real
1033 90004050 : den = (-1. + zeta + eps),
1034 90004050 : den2 = den*den;
1035 :
1036 : // Bubble functions on triangular sides. We actually
1037 : // have a degree of freedom to play with here, and I'm
1038 : // not certain how best to use it, so let's leave it
1039 : // as a variable in case we figure that out later.
1040 25210692 : constexpr Real alpha = 0.5;
1041 : const Real
1042 90004050 : bub_f1 = ((1-alpha)*(1-zeta) + alpha*(-eta)),
1043 90004050 : bub_f2 = ((1-alpha)*(1-zeta) + alpha*(xi)),
1044 90004050 : bub_f3 = ((1-alpha)*(1-zeta) + alpha*(eta)),
1045 90004050 : bub_f4 = ((1-alpha)*(1-zeta) + alpha*(-xi));
1046 :
1047 : const Real
1048 90004050 : bub1 = bub_f1*p1*p2*p4*zeta/den2,
1049 90004050 : bub2 = bub_f2*p1*p2*p3*zeta/den2,
1050 90004050 : bub3 = bub_f3*p2*p3*p4*zeta/den2,
1051 90004050 : bub4 = bub_f4*p1*p3*p4*zeta/den2;
1052 :
1053 90004050 : switch(i)
1054 : {
1055 5000225 : case 0:
1056 5000225 : return p4*p1*(xi*eta - zeta + zeta*zeta)/den2 + 3*(bub1+bub4);
1057 :
1058 5000225 : case 1:
1059 5000225 : return -p1*p2*(xi*eta + zeta - zeta*zeta)/den2 + 3*(bub1+bub2);
1060 :
1061 5000225 : case 2:
1062 5000225 : return p2*p3*(xi*eta - zeta + zeta*zeta)/den2 + 3*(bub2+bub3);
1063 :
1064 5000225 : case 3:
1065 5000225 : return -p3*p4*(xi*eta + zeta - zeta*zeta)/den2 + 3*(bub3+bub4);
1066 :
1067 5000225 : case 4:
1068 5000225 : return zeta*(2.*zeta - 1.) + 3*(bub1+bub2+bub3+bub4);
1069 :
1070 5000225 : case 5:
1071 5000225 : return -4.*p2*p1*p4*eta/den2 - 12*bub1;
1072 :
1073 5000225 : case 6:
1074 5000225 : return 4.*p1*p2*p3*xi/den2 - 12*bub2;
1075 :
1076 5000225 : case 7:
1077 5000225 : return 4.*p2*p3*p4*eta/den2 - 12*bub3;
1078 :
1079 5000225 : case 8:
1080 5000225 : return -4.*p3*p4*p1*xi/den2 - 12*bub4;
1081 :
1082 5000225 : case 9:
1083 5000225 : return -4.*p1*p4*zeta/den - 12*(bub1+bub4);
1084 :
1085 5000225 : case 10:
1086 5000225 : return -4.*p2*p1*zeta/den - 12*(bub1+bub2);
1087 :
1088 5000225 : case 11:
1089 5000225 : return -4.*p3*p2*zeta/den - 12*(bub2+bub3);
1090 :
1091 5000225 : case 12:
1092 5000225 : return -4.*p4*p3*zeta/den - 12*(bub3+bub4);
1093 :
1094 5000225 : case 13:
1095 5000225 : return 16.*p1*p2*p3*p4/den2;
1096 :
1097 5000225 : case 14:
1098 5000225 : return 27*bub1;
1099 :
1100 5000225 : case 15:
1101 5000225 : return 27*bub2;
1102 :
1103 5000225 : case 16:
1104 5000225 : return 27*bub3;
1105 :
1106 5000225 : case 17:
1107 5000225 : return 27*bub4;
1108 :
1109 0 : default:
1110 0 : libmesh_error_msg("Invalid i = " << i);
1111 : }
1112 : }
1113 :
1114 : // quadratic Lagrange shape functions with cubic bubbles
1115 376871110 : case TET14:
1116 : {
1117 97469764 : libmesh_assert_less (i, 14);
1118 376871110 : return libMesh::detail::fe_lagrange_tet14_shape(i, p(0), p(1), p(2));
1119 : }
1120 :
1121 0 : default:
1122 0 : libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
1123 : }
1124 : }
1125 :
1126 : // unsupported order
1127 0 : default:
1128 0 : libmesh_error_msg("ERROR: Unsupported 3D FE order!: " << order);
1129 : }
1130 :
1131 : #else // LIBMESH_DIM != 3
1132 : libmesh_ignore(type, order, elem, i, p);
1133 : libmesh_not_implemented();
1134 : #endif
1135 : }
1136 :
1137 :
1138 :
1139 : template <FEFamily T>
1140 4982121918 : Real fe_lagrange_3D_shape_deriv(const ElemType type,
1141 : const Order order,
1142 : const Elem * elem,
1143 : const unsigned int i,
1144 : const unsigned int j,
1145 : const Point & p)
1146 : {
1147 : #if LIBMESH_DIM == 3
1148 :
1149 1281527751 : libmesh_assert_less (j, 3);
1150 :
1151 4982121918 : switch (order)
1152 : {
1153 : // linear Lagrange shape functions
1154 257383374 : case FIRST:
1155 : {
1156 257383374 : switch (type)
1157 : {
1158 : // trilinear hexahedral shape functions
1159 222224472 : case HEX8:
1160 : case HEX20:
1161 : case HEX27:
1162 : {
1163 55834056 : libmesh_assert_less (i, 8);
1164 :
1165 222224472 : return libMesh::detail::fe_lagrange_hex8_shape_deriv(i, j, p(0), p(1), p(2));
1166 : }
1167 :
1168 : // linear tetrahedral shape functions
1169 341676 : case TET4:
1170 : case TET10:
1171 : case TET14:
1172 : {
1173 341676 : libmesh_assert_less (i, 4);
1174 714204 : return libMesh::detail::fe_lagrange_tet4_shape_deriv(i, j);
1175 : }
1176 :
1177 : // linear prism shape functions
1178 17863290 : case PRISM6:
1179 : case PRISM15:
1180 : case PRISM18:
1181 : case PRISM20:
1182 : case PRISM21:
1183 : {
1184 4980024 : libmesh_assert_less (i, 6);
1185 :
1186 : // Compute prism shape functions as a tensor-product
1187 : // of a triangle and an edge
1188 :
1189 17863290 : Point p2d(p(0),p(1));
1190 17863290 : Real p1d = p(2);
1191 :
1192 : // 0 1 2 3 4 5
1193 : static const unsigned int i0[] = {0, 0, 0, 1, 1, 1};
1194 : static const unsigned int i1[] = {0, 1, 2, 0, 1, 2};
1195 :
1196 17863290 : switch (j)
1197 : {
1198 : // d()/dxi
1199 5954430 : case 0:
1200 5954430 : return (FE<2,LAGRANGE>::shape_deriv(TRI3, FIRST, i1[i], 0, p2d)*
1201 10248852 : fe_lagrange_1D_linear_shape(i0[i], p1d));
1202 :
1203 : // d()/deta
1204 5954430 : case 1:
1205 5954430 : return (FE<2,LAGRANGE>::shape_deriv(TRI3, FIRST, i1[i], 1, p2d)*
1206 10248852 : fe_lagrange_1D_linear_shape(i0[i], p1d));
1207 :
1208 : // d()/dzeta
1209 5954430 : case 2:
1210 5954430 : return (FE<2,LAGRANGE>::shape(TRI3, FIRST, i1[i], p2d)*
1211 8101641 : fe_lagrange_1D_linear_shape_deriv(i0[i], 0, p1d));
1212 :
1213 0 : default:
1214 0 : libmesh_error_msg("Invalid shape function derivative j = " << j);
1215 : }
1216 : }
1217 :
1218 : // linear pyramid shape functions
1219 1134600 : case PYRAMID5:
1220 : case PYRAMID13:
1221 : case PYRAMID14:
1222 : case PYRAMID18:
1223 : {
1224 308040 : libmesh_assert_less (i, 5);
1225 :
1226 1134600 : const Real xi = p(0);
1227 1134600 : const Real eta = p(1);
1228 1134600 : const Real zeta = p(2);
1229 308040 : const Real eps = 1.e-35;
1230 :
1231 1134600 : switch (j)
1232 : {
1233 : // d/dxi
1234 378200 : case 0:
1235 378200 : switch(i)
1236 : {
1237 75640 : case 0:
1238 75640 : return .25*(zeta + eta - 1.)/((1. - zeta) + eps);
1239 :
1240 75640 : case 1:
1241 75640 : return -.25*(zeta + eta - 1.)/((1. - zeta) + eps);
1242 :
1243 75640 : case 2:
1244 75640 : return -.25*(zeta - eta - 1.)/((1. - zeta) + eps);
1245 :
1246 75640 : case 3:
1247 75640 : return .25*(zeta - eta - 1.)/((1. - zeta) + eps);
1248 :
1249 20536 : case 4:
1250 20536 : return 0;
1251 :
1252 0 : default:
1253 0 : libmesh_error_msg("Invalid i = " << i);
1254 : }
1255 :
1256 :
1257 : // d/deta
1258 378200 : case 1:
1259 378200 : switch(i)
1260 : {
1261 75640 : case 0:
1262 75640 : return .25*(zeta + xi - 1.)/((1. - zeta) + eps);
1263 :
1264 75640 : case 1:
1265 75640 : return .25*(zeta - xi - 1.)/((1. - zeta) + eps);
1266 :
1267 75640 : case 2:
1268 75640 : return -.25*(zeta - xi - 1.)/((1. - zeta) + eps);
1269 :
1270 75640 : case 3:
1271 75640 : return -.25*(zeta + xi - 1.)/((1. - zeta) + eps);
1272 :
1273 20536 : case 4:
1274 20536 : return 0;
1275 :
1276 0 : default:
1277 0 : libmesh_error_msg("Invalid i = " << i);
1278 : }
1279 :
1280 :
1281 : // d/dzeta
1282 378200 : case 2:
1283 : {
1284 : // We computed the derivatives with general eps and
1285 : // then let eps tend to zero in the numerators...
1286 : Real
1287 378200 : num = zeta*(2. - zeta) - 1.,
1288 378200 : den = (1. - zeta + eps)*(1. - zeta + eps);
1289 :
1290 378200 : switch(i)
1291 : {
1292 151280 : case 0:
1293 : case 2:
1294 151280 : return .25*(num + xi*eta)/den;
1295 :
1296 151280 : case 1:
1297 : case 3:
1298 151280 : return .25*(num - xi*eta)/den;
1299 :
1300 20536 : case 4:
1301 20536 : return 1.;
1302 :
1303 0 : default:
1304 0 : libmesh_error_msg("Invalid i = " << i);
1305 : }
1306 : }
1307 :
1308 0 : default:
1309 0 : libmesh_error_msg("Invalid j = " << j);
1310 : }
1311 : }
1312 :
1313 15105036 : case C0POLYHEDRON:
1314 : {
1315 : // Polyhedra require using newer FE APIs
1316 15105036 : if (!elem)
1317 0 : libmesh_error_msg("Code (see stack trace) used an outdated FE function overload.\n"
1318 : "Shape functions on a polyhedron are not defined by ElemType alone.");
1319 :
1320 3777384 : libmesh_assert(elem->type() == C0POLYHEDRON);
1321 :
1322 3777384 : const C0Polyhedron & poly = *cast_ptr<const C0Polyhedron *>(elem);
1323 :
1324 : // We can't use a small tolerance here, because in
1325 : // inverse_map() Newton might hand us intermediate
1326 : // iterates outside the polyhedron.
1327 15105036 : const auto [s, a, b, c] = poly.subelement_coordinates(p, 100);
1328 15105036 : if (s == invalid_uint)
1329 0 : return 0;
1330 3777384 : libmesh_assert_less(s, poly.n_subelements());
1331 :
1332 15105036 : const auto subtet = poly.subelement(s);
1333 :
1334 : // Find derivatives w.r.t. subtriangle barycentric
1335 : // coordinates
1336 3777384 : Real du_da = 0, du_db = 0, du_dc = 0;
1337 :
1338 : // Avoid signed/unsigned comparison warnings
1339 15105036 : const int nodei = i;
1340 15105036 : if (nodei == subtet[0])
1341 447687 : du_da = du_db = du_dc = -1;
1342 13314663 : else if (nodei == subtet[1])
1343 447687 : du_da = 1;
1344 11524290 : else if (nodei == subtet[2])
1345 447687 : du_db = 1;
1346 9733917 : else if (nodei == subtet[3])
1347 447687 : du_dc = 1;
1348 : else
1349 : // Basis function i is not supported on p's subtet
1350 1986636 : return 0;
1351 :
1352 : // We want to return derivatives with respect to
1353 : // xi/eta/zeta for the polyhedron, but what we
1354 : // calculated above are with respect to xi and eta
1355 : // coordinates for a master *triangle*. We need to
1356 : // convert from one to the other.
1357 :
1358 7161492 : const auto master_points = poly.master_subelement(s);
1359 :
1360 1790748 : const RealTensor dXi_dA(
1361 7161492 : master_points[1](0) - master_points[0](0), master_points[2](0) - master_points[0](0), master_points[3](0) - master_points[0](0),
1362 7161492 : master_points[1](1) - master_points[0](1), master_points[2](1) - master_points[0](1), master_points[3](1) - master_points[0](1),
1363 7161492 : master_points[1](2) - master_points[0](2), master_points[2](2) - master_points[0](2), master_points[3](2) - master_points[0](2));
1364 :
1365 : // When we vectorize this we'll want a full inverse, but
1366 : // when we're querying one component at a time it's
1367 : // cheaper to manually compute a single column.
1368 : // const RealTensor dabc_dxietazeta_dabc = dxietazeta_dabc.inverse();
1369 7161492 : const Real jac = dXi_dA.det();
1370 :
1371 7161492 : switch (j)
1372 : {
1373 : // d()/dxi
1374 596916 : case 0:
1375 : {
1376 2387164 : const Real da_dxi = (dXi_dA(2,2)*dXi_dA(1,1) - dXi_dA(2,1)*dXi_dA(1,2)) / jac;
1377 2387164 : const Real db_dxi = -(dXi_dA(2,2)*dXi_dA(1,0) - dXi_dA(2,0)*dXi_dA(1,2)) / jac;
1378 2387164 : const Real dc_dxi = (dXi_dA(2,1)*dXi_dA(1,0) - dXi_dA(2,0)*dXi_dA(1,1)) / jac;
1379 2387164 : return du_da*da_dxi + du_db*db_dxi + du_dc*dc_dxi;
1380 : }
1381 : // d()/deta
1382 596916 : case 1:
1383 : {
1384 2387164 : const Real da_deta = -(dXi_dA(2,2)*dXi_dA(0,1) - dXi_dA(2,1)*dXi_dA(0,2) ) / jac;
1385 2387164 : const Real db_deta = (dXi_dA(2,2)*dXi_dA(0,0) - dXi_dA(2,0)*dXi_dA(0,2)) / jac;
1386 2387164 : const Real dc_deta = -(dXi_dA(2,1)*dXi_dA(0,0) - dXi_dA(2,0)*dXi_dA(0,1)) / jac;
1387 2387164 : return du_da*da_deta + du_db*db_deta + du_dc*dc_deta;
1388 : }
1389 : // d()/dzeta
1390 596916 : case 2:
1391 : {
1392 2387164 : const Real da_dzeta = (dXi_dA(1,2)*dXi_dA(0,1) - dXi_dA(1,1)*dXi_dA(0,2) ) / jac;
1393 2387164 : const Real db_dzeta = -(dXi_dA(1,2)*dXi_dA(0,0) - dXi_dA(1,0)*dXi_dA(0,2)) / jac;
1394 2387164 : const Real dc_dzeta = (dXi_dA(1,1)*dXi_dA(0,0) - dXi_dA(1,0)*dXi_dA(0,1)) / jac;
1395 2387164 : return du_da*da_dzeta + du_db*db_dzeta + du_dc*dc_dzeta;
1396 : }
1397 0 : default:
1398 0 : libmesh_error_msg("ERROR: Invalid derivative index j = " << j);
1399 : }
1400 : }
1401 :
1402 0 : default:
1403 0 : libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
1404 : }
1405 : }
1406 :
1407 :
1408 : // quadratic Lagrange shape functions
1409 3155602662 : case SECOND:
1410 : {
1411 3155602662 : switch (type)
1412 : {
1413 :
1414 : // serendipity hexahedral quadratic shape functions
1415 72681660 : case HEX20:
1416 : {
1417 18295380 : libmesh_assert_less (i, 20);
1418 72681660 : return libMesh::detail::fe_lagrange_hex20_shape_deriv(i, j, p(0), p(1), p(2));
1419 : }
1420 :
1421 : // triquadratic hexahedral shape functions
1422 2061043866 : case HEX8:
1423 1152711 : libmesh_assert_msg(T == L2_LAGRANGE,
1424 : "High order on first order elements only supported for L2 families");
1425 : libmesh_fallthrough();
1426 688484367 : case HEX27:
1427 : {
1428 689939613 : libmesh_assert_less (i, 27);
1429 :
1430 2749830768 : return libMesh::detail::fe_lagrange_hex27_shape_deriv(i, j, p(0), p(1), p(2));
1431 : }
1432 :
1433 : // quadratic tetrahedral shape functions
1434 96656370 : case TET4:
1435 20880 : libmesh_assert_msg(T == L2_LAGRANGE,
1436 : "High order on first order elements only supported for L2 families");
1437 : libmesh_fallthrough();
1438 37165380 : case TET10:
1439 : case TET14:
1440 : {
1441 37670370 : libmesh_assert_less (i, 10);
1442 134305860 : return libMesh::detail::fe_lagrange_tet10_shape_deriv(i, j, p(0), p(1), p(2));
1443 : }
1444 :
1445 :
1446 : // "serendipity" prism
1447 58933440 : case PRISM15:
1448 : {
1449 16614540 : libmesh_assert_less (i, 15);
1450 :
1451 58933440 : const Real xi = p(0);
1452 58933440 : const Real eta = p(1);
1453 58933440 : const Real zeta = p(2);
1454 :
1455 58933440 : switch (j)
1456 : {
1457 : // d()/dxi
1458 19644480 : case 0:
1459 : {
1460 19644480 : switch(i)
1461 : {
1462 1309632 : case 0:
1463 1309632 : return (2.*xi + 2.*eta + 0.5*zeta - 1.)*(1. - zeta);
1464 1309632 : case 1:
1465 1309632 : return (2.*xi - 1. - 0.5*zeta)*(1. - zeta);
1466 369212 : case 2:
1467 369212 : return 0.;
1468 1309632 : case 3:
1469 1309632 : return (2.*xi + 2.*eta - 0.5*zeta - 1.)*(1. + zeta);
1470 1309632 : case 4:
1471 1309632 : return (2.*xi - 1. + 0.5*zeta)*(1. + zeta);
1472 369212 : case 5:
1473 369212 : return 0.;
1474 1309632 : case 6:
1475 1309632 : return (4.*xi + 2.*eta - 2.)*(zeta - 1.);
1476 1309632 : case 7:
1477 1309632 : return -2.*(zeta - 1.)*eta;
1478 1309632 : case 8:
1479 1309632 : return 2.*(zeta - 1.)*eta;
1480 1309632 : case 9:
1481 1309632 : return (zeta - 1.)*(1. + zeta);
1482 1309632 : case 10:
1483 1309632 : return (1. - zeta)*(1. + zeta);
1484 369212 : case 11:
1485 369212 : return 0.;
1486 1309632 : case 12:
1487 1309632 : return (-4.*xi - 2.*eta + 2.)*(1. + zeta);
1488 1309632 : case 13:
1489 1309632 : return 2.*(1. + zeta)*eta;
1490 1309632 : case 14:
1491 1309632 : return -2.*(1. + zeta)*eta;
1492 0 : default:
1493 0 : libmesh_error_msg("Invalid i = " << i);
1494 : }
1495 : }
1496 :
1497 : // d()/deta
1498 19644480 : case 1:
1499 : {
1500 19644480 : switch(i)
1501 : {
1502 1309632 : case 0:
1503 1309632 : return (2.*xi + 2.*eta + 0.5*zeta - 1.)*(1. - zeta);
1504 369212 : case 1:
1505 369212 : return 0.;
1506 1309632 : case 2:
1507 1309632 : return (2.*eta - 1. - 0.5*zeta)*(1. - zeta);
1508 1309632 : case 3:
1509 1309632 : return (2.*xi + 2.*eta - 0.5*zeta - 1.)*(1. + zeta);
1510 369212 : case 4:
1511 369212 : return 0.;
1512 1309632 : case 5:
1513 1309632 : return (2.*eta - 1. + 0.5*zeta)*(1. + zeta);
1514 1309632 : case 6:
1515 1309632 : return 2.*(zeta - 1.)*xi;
1516 1309632 : case 7:
1517 1309632 : return 2.*(1. - zeta)*xi;
1518 1309632 : case 8:
1519 1309632 : return (2.*xi + 4.*eta - 2.)*(zeta - 1.);
1520 1309632 : case 9:
1521 1309632 : return (zeta - 1.)*(1. + zeta);
1522 369212 : case 10:
1523 369212 : return 0.;
1524 1309632 : case 11:
1525 1309632 : return (1. - zeta)*(1. + zeta);
1526 1309632 : case 12:
1527 1309632 : return -2.*(1. + zeta)*xi;
1528 1309632 : case 13:
1529 1309632 : return 2.*(1. + zeta)*xi;
1530 1309632 : case 14:
1531 1309632 : return (-2.*xi - 4.*eta + 2.)*(1. + zeta);
1532 :
1533 0 : default:
1534 0 : libmesh_error_msg("Invalid i = " << i);
1535 : }
1536 : }
1537 :
1538 : // d()/dzeta
1539 19644480 : case 2:
1540 : {
1541 19644480 : switch(i)
1542 : {
1543 1309632 : case 0:
1544 1309632 : return (-xi - eta - zeta + 0.5)*(xi + eta - 1.);
1545 1309632 : case 1:
1546 1309632 : return -0.5*xi*(2.*xi - 1. - 2.*zeta);
1547 1309632 : case 2:
1548 1309632 : return -0.5*eta*(2.*eta - 1. - 2.*zeta);
1549 1309632 : case 3:
1550 1309632 : return (xi + eta - zeta - 0.5)*(xi + eta - 1.);
1551 1309632 : case 4:
1552 1309632 : return 0.5*xi*(2.*xi - 1. + 2.*zeta);
1553 1309632 : case 5:
1554 1309632 : return 0.5*eta*(2.*eta - 1. + 2.*zeta);
1555 1309632 : case 6:
1556 1309632 : return 2.*xi*(xi + eta - 1.);
1557 1309632 : case 7:
1558 1309632 : return -2.*xi*eta;
1559 1309632 : case 8:
1560 1309632 : return 2.*eta*(xi + eta - 1.);
1561 1309632 : case 9:
1562 1309632 : return 2.*zeta*(xi + eta - 1.);
1563 1309632 : case 10:
1564 1309632 : return -2.*xi*zeta;
1565 1309632 : case 11:
1566 1309632 : return -2.*eta*zeta;
1567 1309632 : case 12:
1568 1309632 : return 2.*xi*(1. - xi - eta);
1569 1309632 : case 13:
1570 1309632 : return 2.*xi*eta;
1571 1309632 : case 14:
1572 1309632 : return 2.*eta*(1. - xi - eta);
1573 :
1574 0 : default:
1575 0 : libmesh_error_msg("Invalid i = " << i);
1576 : }
1577 : }
1578 :
1579 0 : default:
1580 0 : libmesh_error_msg("Invalid j = " << j);
1581 : }
1582 : }
1583 :
1584 :
1585 :
1586 : // quadratic prism shape functions
1587 79800444 : case PRISM6:
1588 206712 : libmesh_assert_msg(T == L2_LAGRANGE,
1589 : "High order on first order elements only supported for L2 families");
1590 : libmesh_fallthrough();
1591 32217372 : case PRISM18:
1592 : case PRISM20:
1593 : case PRISM21:
1594 : {
1595 33044220 : libmesh_assert_less (i, 18);
1596 :
1597 : // Compute prism shape functions as a tensor-product
1598 : // of a triangle and an edge
1599 :
1600 112637952 : Point p2d(p(0),p(1));
1601 112637952 : Real p1d = p(2);
1602 :
1603 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
1604 : static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2};
1605 : static const unsigned int i1[] = {0, 1, 2, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 3, 4, 5};
1606 :
1607 112637952 : switch (j)
1608 : {
1609 : // d()/dxi
1610 37545984 : case 0:
1611 37545984 : return (FE<2,LAGRANGE>::shape_deriv(TRI6, SECOND, i1[i], 0, p2d)*
1612 48560904 : fe_lagrange_1D_quadratic_shape(i0[i], p1d));
1613 :
1614 : // d()/deta
1615 37545984 : case 1:
1616 37545984 : return (FE<2,LAGRANGE>::shape_deriv(TRI6, SECOND, i1[i], 1, p2d)*
1617 48560904 : fe_lagrange_1D_quadratic_shape(i0[i], p1d));
1618 :
1619 : // d()/dzeta
1620 37545984 : case 2:
1621 37545984 : return (FE<2,LAGRANGE>::shape(TRI6, SECOND, i1[i], p2d)*
1622 64077228 : fe_lagrange_1D_quadratic_shape_deriv(i0[i], 0, p1d));
1623 :
1624 0 : default:
1625 0 : libmesh_error_msg("Invalid shape function derivative j = " << j);
1626 : }
1627 : }
1628 :
1629 : // G. Bedrosian, "Shape functions and integration formulas for
1630 : // three-dimensional finite element analysis", Int. J. Numerical
1631 : // Methods Engineering, vol 35, p. 95-108, 1992.
1632 12798162 : case PYRAMID13:
1633 : {
1634 3588468 : libmesh_assert_less (i, 13);
1635 :
1636 12798162 : const Real xi = p(0);
1637 12798162 : const Real eta = p(1);
1638 12798162 : const Real zeta = p(2);
1639 3588468 : const Real eps = 1.e-35;
1640 :
1641 : // Denominators are perturbed by epsilon to avoid
1642 : // divide-by-zero issues.
1643 : Real
1644 12798162 : den = (-1. + zeta + eps),
1645 12798162 : den2 = den*den,
1646 12798162 : xi2 = xi*xi,
1647 12798162 : eta2 = eta*eta,
1648 12798162 : zeta2 = zeta*zeta,
1649 12798162 : zeta3 = zeta2*zeta;
1650 :
1651 12798162 : switch (j)
1652 : {
1653 : // d/dxi
1654 4266054 : case 0:
1655 4266054 : switch(i)
1656 : {
1657 328158 : case 0:
1658 328158 : return 0.25*(-zeta - eta + 2.*eta*zeta - 2.*xi + 2.*zeta*xi + 2.*eta*xi + zeta2 + eta2)/den;
1659 :
1660 328158 : case 1:
1661 328158 : return -0.25*(-zeta - eta + 2.*eta*zeta + 2.*xi - 2.*zeta*xi - 2.*eta*xi + zeta2 + eta2)/den;
1662 :
1663 328158 : case 2:
1664 328158 : return -0.25*(-zeta + eta - 2.*eta*zeta + 2.*xi - 2.*zeta*xi + 2.*eta*xi + zeta2 + eta2)/den;
1665 :
1666 328158 : case 3:
1667 328158 : return 0.25*(-zeta + eta - 2.*eta*zeta - 2.*xi + 2.*zeta*xi - 2.*eta*xi + zeta2 + eta2)/den;
1668 :
1669 92012 : case 4:
1670 92012 : return 0.;
1671 :
1672 328158 : case 5:
1673 328158 : return -(-1. + eta + zeta)*xi/den;
1674 :
1675 328158 : case 6:
1676 328158 : return 0.5*(-1. + eta + zeta)*(1. + eta - zeta)/den;
1677 :
1678 328158 : case 7:
1679 328158 : return (1. + eta - zeta)*xi/den;
1680 :
1681 328158 : case 8:
1682 328158 : return -0.5*(-1. + eta + zeta)*(1. + eta - zeta)/den;
1683 :
1684 328158 : case 9:
1685 328158 : return -(-1. + eta + zeta)*zeta/den;
1686 :
1687 328158 : case 10:
1688 328158 : return (-1. + eta + zeta)*zeta/den;
1689 :
1690 328158 : case 11:
1691 328158 : return -(1. + eta - zeta)*zeta/den;
1692 :
1693 328158 : case 12:
1694 328158 : return (1. + eta - zeta)*zeta/den;
1695 :
1696 0 : default:
1697 0 : libmesh_error_msg("Invalid i = " << i);
1698 : }
1699 :
1700 : // d/deta
1701 4266054 : case 1:
1702 4266054 : switch(i)
1703 : {
1704 328158 : case 0:
1705 328158 : return 0.25*(-zeta - 2.*eta + 2.*eta*zeta - xi + 2.*zeta*xi + 2.*eta*xi + zeta2 + xi2)/den;
1706 :
1707 328158 : case 1:
1708 328158 : return -0.25*(zeta + 2.*eta - 2.*eta*zeta - xi + 2.*zeta*xi + 2.*eta*xi - zeta2 - xi2)/den;
1709 :
1710 328158 : case 2:
1711 328158 : return -0.25*(-zeta + 2.*eta - 2.*eta*zeta + xi - 2.*zeta*xi + 2.*eta*xi + zeta2 + xi2)/den;
1712 :
1713 328158 : case 3:
1714 328158 : return 0.25*(zeta - 2.*eta + 2.*eta*zeta + xi - 2.*zeta*xi + 2.*eta*xi - zeta2 - xi2)/den;
1715 :
1716 92012 : case 4:
1717 92012 : return 0.;
1718 :
1719 328158 : case 5:
1720 328158 : return -0.5*(-1. + xi + zeta)*(1. + xi - zeta)/den;
1721 :
1722 328158 : case 6:
1723 328158 : return (1. + xi - zeta)*eta/den;
1724 :
1725 328158 : case 7:
1726 328158 : return 0.5*(-1. + xi + zeta)*(1. + xi - zeta)/den;
1727 :
1728 328158 : case 8:
1729 328158 : return -(-1. + xi + zeta)*eta/den;
1730 :
1731 328158 : case 9:
1732 328158 : return -(-1. + xi + zeta)*zeta/den;
1733 :
1734 328158 : case 10:
1735 328158 : return (1. + xi - zeta)*zeta/den;
1736 :
1737 328158 : case 11:
1738 328158 : return -(1. + xi - zeta)*zeta/den;
1739 :
1740 328158 : case 12:
1741 328158 : return (-1. + xi + zeta)*zeta/den;
1742 :
1743 0 : default:
1744 0 : libmesh_error_msg("Invalid i = " << i);
1745 : }
1746 :
1747 : // d/dzeta
1748 4266054 : case 2:
1749 : {
1750 4266054 : switch(i)
1751 : {
1752 328158 : case 0:
1753 328158 : return -0.25*(xi + eta + 1.)*(-1. + 2.*zeta - zeta2 + eta*xi)/den2;
1754 :
1755 328158 : case 1:
1756 328158 : return 0.25*(eta - xi + 1.)*(1. - 2.*zeta + zeta2 + eta*xi)/den2;
1757 :
1758 328158 : case 2:
1759 328158 : return 0.25*(xi + eta - 1.)*(-1. + 2.*zeta - zeta2 + eta*xi)/den2;
1760 :
1761 328158 : case 3:
1762 328158 : return -0.25*(eta - xi - 1.)*(1. - 2.*zeta + zeta2 + eta*xi)/den2;
1763 :
1764 328158 : case 4:
1765 328158 : return 4.*zeta - 1.;
1766 :
1767 328158 : case 5:
1768 328158 : return 0.5*(-2 + eta + 6.*zeta + eta*xi2 + eta*zeta2 - 6.*zeta2 + 2.*zeta3 - 2.*eta*zeta)/den2;
1769 :
1770 328158 : case 6:
1771 328158 : return -0.5*(2 - 6.*zeta + xi + xi*zeta2 + eta2*xi + 6.*zeta2 - 2.*zeta3 - 2.*zeta*xi)/den2;
1772 :
1773 328158 : case 7:
1774 328158 : return -0.5*(2 + eta - 6.*zeta + eta*xi2 + eta*zeta2 + 6.*zeta2 - 2.*zeta3 - 2.*eta*zeta)/den2;
1775 :
1776 328158 : case 8:
1777 328158 : return 0.5*(-2 + 6.*zeta + xi + xi*zeta2 + eta2*xi - 6.*zeta2 + 2.*zeta3 - 2.*zeta*xi)/den2;
1778 :
1779 328158 : case 9:
1780 328158 : return (1. - eta - 4.*zeta - xi - xi*zeta2 - eta*zeta2 + eta*xi + 5.*zeta2 - 2.*zeta3 + 2.*eta*zeta + 2.*zeta*xi)/den2;
1781 :
1782 328158 : case 10:
1783 328158 : return -(-1. + eta + 4.*zeta - xi - xi*zeta2 + eta*zeta2 + eta*xi - 5.*zeta2 + 2.*zeta3 - 2.*eta*zeta + 2.*zeta*xi)/den2;
1784 :
1785 328158 : case 11:
1786 328158 : return (1. + eta - 4.*zeta + xi + xi*zeta2 + eta*zeta2 + eta*xi + 5.*zeta2 - 2.*zeta3 - 2.*eta*zeta - 2.*zeta*xi)/den2;
1787 :
1788 328158 : case 12:
1789 328158 : return -(-1. - eta + 4.*zeta + xi + xi*zeta2 - eta*zeta2 + eta*xi - 5.*zeta2 + 2.*zeta3 + 2.*eta*zeta - 2.*zeta*xi)/den2;
1790 :
1791 0 : default:
1792 0 : libmesh_error_msg("Invalid i = " << i);
1793 : }
1794 : }
1795 :
1796 0 : default:
1797 0 : libmesh_error_msg("Invalid j = " << j);
1798 : }
1799 : }
1800 :
1801 : // Quadratic shape functions, as defined in R. Graglia, "Higher order
1802 : // bases on pyramidal elements", IEEE Trans Antennas and Propagation,
1803 : // vol 47, no 5, May 1999.
1804 10374252 : case PYRAMID5:
1805 0 : libmesh_assert_msg(T == L2_LAGRANGE,
1806 : "High order on first order elements only supported for L2 families");
1807 : libmesh_fallthrough();
1808 4040568 : case PYRAMID14:
1809 : case PYRAMID18:
1810 : {
1811 4040568 : libmesh_assert_less (i, 14);
1812 :
1813 14414820 : const Real xi = p(0);
1814 14414820 : const Real eta = p(1);
1815 14414820 : const Real zeta = p(2);
1816 4040568 : const Real eps = 1.e-35;
1817 :
1818 : // The "normalized coordinates" defined by Graglia. These are
1819 : // the planes which define the faces of the pyramid.
1820 : Real
1821 14414820 : p1 = 0.5*(1. - eta - zeta), // back
1822 14414820 : p2 = 0.5*(1. + xi - zeta), // left
1823 14414820 : p3 = 0.5*(1. + eta - zeta), // front
1824 14414820 : p4 = 0.5*(1. - xi - zeta); // right
1825 :
1826 : // Denominators are perturbed by epsilon to avoid
1827 : // divide-by-zero issues.
1828 : Real
1829 14414820 : den = (-1. + zeta + eps),
1830 14414820 : den2 = den*den,
1831 14414820 : den3 = den2*den;
1832 :
1833 14414820 : switch (j)
1834 : {
1835 : // d/dxi
1836 4804940 : case 0:
1837 4804940 : switch(i)
1838 : {
1839 343210 : case 0:
1840 343210 : return 0.5*p1*(-xi*eta + zeta - zeta*zeta + 2.*p4*eta)/den2;
1841 :
1842 343210 : case 1:
1843 343210 : return -0.5*p1*(xi*eta + zeta - zeta*zeta + 2.*p2*eta)/den2;
1844 :
1845 343210 : case 2:
1846 343210 : return 0.5*p3*(xi*eta - zeta + zeta*zeta + 2.*p2*eta)/den2;
1847 :
1848 343210 : case 3:
1849 343210 : return -0.5*p3*(-xi*eta - zeta + zeta*zeta + 2.*p4*eta)/den2;
1850 :
1851 96204 : case 4:
1852 96204 : return 0.;
1853 :
1854 343210 : case 5:
1855 343210 : return 2.*p1*eta*xi/den2;
1856 :
1857 343210 : case 6:
1858 343210 : return 2.*p1*p3*(xi + 2.*p2)/den2;
1859 :
1860 343210 : case 7:
1861 343210 : return -2.*p3*eta*xi/den2;
1862 :
1863 343210 : case 8:
1864 343210 : return -2.*p1*p3*(-xi + 2.*p4)/den2;
1865 :
1866 343210 : case 9:
1867 343210 : return 2.*p1*zeta/den;
1868 :
1869 343210 : case 10:
1870 343210 : return -2.*p1*zeta/den;
1871 :
1872 343210 : case 11:
1873 343210 : return -2.*p3*zeta/den;
1874 :
1875 343210 : case 12:
1876 343210 : return 2.*p3*zeta/den;
1877 :
1878 343210 : case 13:
1879 343210 : return -8.*p1*p3*xi/den2;
1880 :
1881 0 : default:
1882 0 : libmesh_error_msg("Invalid i = " << i);
1883 : }
1884 :
1885 : // d/deta
1886 4804940 : case 1:
1887 4804940 : switch(i)
1888 : {
1889 343210 : case 0:
1890 343210 : return -0.5*p4*(xi*eta - zeta + zeta*zeta - 2.*p1*xi)/den2;
1891 :
1892 343210 : case 1:
1893 343210 : return 0.5*p2*(xi*eta + zeta - zeta*zeta - 2.*p1*xi)/den2;
1894 :
1895 343210 : case 2:
1896 343210 : return 0.5*p2*(xi*eta - zeta + zeta*zeta + 2.*p3*xi)/den2;
1897 :
1898 343210 : case 3:
1899 343210 : return -0.5*p4*(xi*eta + zeta - zeta*zeta + 2.*p3*xi)/den2;
1900 :
1901 96204 : case 4:
1902 96204 : return 0.;
1903 :
1904 343210 : case 5:
1905 343210 : return 2.*p2*p4*(eta - 2.*p1)/den2;
1906 :
1907 343210 : case 6:
1908 343210 : return -2.*p2*xi*eta/den2;
1909 :
1910 343210 : case 7:
1911 343210 : return 2.*p2*p4*(eta + 2.*p3)/den2;
1912 :
1913 343210 : case 8:
1914 343210 : return 2.*p4*xi*eta/den2;
1915 :
1916 343210 : case 9:
1917 343210 : return 2.*p4*zeta/den;
1918 :
1919 343210 : case 10:
1920 343210 : return 2.*p2*zeta/den;
1921 :
1922 343210 : case 11:
1923 343210 : return -2.*p2*zeta/den;
1924 :
1925 343210 : case 12:
1926 343210 : return -2.*p4*zeta/den;
1927 :
1928 343210 : case 13:
1929 343210 : return -8.*p2*p4*eta/den2;
1930 :
1931 0 : default:
1932 0 : libmesh_error_msg("Invalid i = " << i);
1933 : }
1934 :
1935 :
1936 : // d/dzeta
1937 4804940 : case 2:
1938 : {
1939 4804940 : switch(i)
1940 : {
1941 343210 : case 0:
1942 343210 : return -0.5*p1*(xi*eta - zeta + zeta*zeta)/den2
1943 343210 : - 0.5*p4*(xi*eta - zeta + zeta*zeta)/den2
1944 343210 : + p4*p1*(2.*zeta - 1)/den2
1945 343210 : - 2.*p4*p1*(xi*eta - zeta + zeta*zeta)/den3;
1946 :
1947 343210 : case 1:
1948 343210 : return 0.5*p2*(xi*eta + zeta - zeta*zeta)/den2
1949 343210 : + 0.5*p1*(xi*eta + zeta - zeta*zeta)/den2
1950 343210 : - p1*p2*(1 - 2.*zeta)/den2
1951 343210 : + 2.*p1*p2*(xi*eta + zeta - zeta*zeta)/den3;
1952 :
1953 343210 : case 2:
1954 343210 : return -0.5*p3*(xi*eta - zeta + zeta*zeta)/den2
1955 343210 : - 0.5*p2*(xi*eta - zeta + zeta*zeta)/den2
1956 343210 : + p2*p3*(2.*zeta - 1)/den2
1957 343210 : - 2.*p2*p3*(xi*eta - zeta + zeta*zeta)/den3;
1958 :
1959 343210 : case 3:
1960 343210 : return 0.5*p4*(xi*eta + zeta - zeta*zeta)/den2
1961 343210 : + 0.5*p3*(xi*eta + zeta - zeta*zeta)/den2
1962 343210 : - p3*p4*(1 - 2.*zeta)/den2
1963 343210 : + 2.*p3*p4*(xi*eta + zeta - zeta*zeta)/den3;
1964 :
1965 343210 : case 4:
1966 343210 : return 4.*zeta - 1.;
1967 :
1968 343210 : case 5:
1969 343210 : return 2.*p4*p1*eta/den2
1970 343210 : + 2.*p2*p4*eta/den2
1971 343210 : + 2.*p1*p2*eta/den2
1972 343210 : + 8.*p2*p1*p4*eta/den3;
1973 :
1974 343210 : case 6:
1975 343210 : return -2.*p2*p3*xi/den2
1976 343210 : - 2.*p1*p3*xi/den2
1977 343210 : - 2.*p1*p2*xi/den2
1978 343210 : - 8.*p1*p2*p3*xi/den3;
1979 :
1980 343210 : case 7:
1981 343210 : return -2.*p3*p4*eta/den2
1982 343210 : - 2.*p2*p4*eta/den2
1983 343210 : - 2.*p2*p3*eta/den2
1984 343210 : - 8.*p2*p3*p4*eta/den3;
1985 :
1986 343210 : case 8:
1987 343210 : return 2.*p4*p1*xi/den2
1988 343210 : + 2.*p1*p3*xi/den2
1989 343210 : + 2.*p3*p4*xi/den2
1990 343210 : + 8.*p3*p4*p1*xi/den3;
1991 :
1992 343210 : case 9:
1993 343210 : return 2.*p4*zeta/den
1994 343210 : + 2.*p1*zeta/den
1995 343210 : - 4.*p1*p4/den
1996 343210 : + 4.*p1*p4*zeta/den2;
1997 :
1998 343210 : case 10:
1999 343210 : return 2.*p1*zeta/den
2000 343210 : + 2.*p2*zeta/den
2001 343210 : - 4.*p2*p1/den
2002 343210 : + 4.*p2*p1*zeta/den2;
2003 :
2004 343210 : case 11:
2005 343210 : return 2.*p2*zeta/den
2006 343210 : + 2.*p3*zeta/den
2007 343210 : - 4.*p3*p2/den
2008 343210 : + 4.*p3*p2*zeta/den2;
2009 :
2010 343210 : case 12:
2011 343210 : return 2.*p3*zeta/den
2012 343210 : + 2.*p4*zeta/den
2013 343210 : - 4.*p4*p3/den
2014 343210 : + 4.*p4*p3*zeta/den2;
2015 :
2016 343210 : case 13:
2017 343210 : return -8.*p2*p3*p4/den2
2018 343210 : - 8.*p3*p4*p1/den2
2019 343210 : - 8.*p2*p1*p4/den2
2020 343210 : - 8.*p1*p2*p3/den2
2021 343210 : - 32.*p1*p2*p3*p4/den3;
2022 :
2023 0 : default:
2024 0 : libmesh_error_msg("Invalid i = " << i);
2025 : }
2026 : }
2027 :
2028 0 : default:
2029 0 : libmesh_error_msg("Invalid j = " << j);
2030 : }
2031 : }
2032 :
2033 :
2034 0 : default:
2035 0 : libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
2036 : }
2037 : }
2038 :
2039 1569135882 : case THIRD:
2040 : {
2041 1569135882 : switch (type)
2042 : {
2043 : // quadratic Lagrange shape functions with a cubic bubble
2044 1216857054 : case TET14:
2045 : {
2046 315331128 : libmesh_assert_less (i, 14);
2047 1216857054 : return libMesh::detail::fe_lagrange_tet14_shape_deriv(i, j, p(0), p(1), p(2));
2048 : }
2049 :
2050 90657000 : case PRISM20:
2051 : {
2052 25206120 : libmesh_assert_less (i, 20);
2053 :
2054 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
2055 : static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2, 0, 1, 2};
2056 :
2057 90657000 : Point p2d(p(0),p(1));
2058 90657000 : Real p1d = p(2);
2059 :
2060 90657000 : const Real mainval = FE<3,LAGRANGE>::shape_deriv(PRISM21, THIRD, i, j, p);
2061 :
2062 90657000 : if (i0[i] != 2)
2063 17644284 : return mainval;
2064 :
2065 7561836 : Real bubbleval = 0;
2066 :
2067 7561836 : switch (j)
2068 : {
2069 : // d()/dxi
2070 9065700 : case 0:
2071 9065700 : bubbleval =
2072 9065700 : FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, 6, 0, p2d)*
2073 2520612 : fe_lagrange_1D_quadratic_shape(2, p1d);
2074 9065700 : break;
2075 :
2076 : // d()/deta
2077 9065700 : case 1:
2078 9065700 : bubbleval =
2079 9065700 : FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, 6, 1, p2d)*
2080 2520612 : fe_lagrange_1D_quadratic_shape(2, p1d);
2081 9065700 : break;
2082 :
2083 : // d()/dzeta
2084 9065700 : case 2:
2085 9065700 : bubbleval =
2086 9065700 : FE<2,LAGRANGE>::shape(TRI7, THIRD, 6, p2d)*
2087 2520612 : fe_lagrange_1D_quadratic_shape_deriv(2, 0, p1d);
2088 9065700 : break;
2089 :
2090 0 : default:
2091 0 : libmesh_error_msg("Invalid shape function derivative j = " << j);
2092 : }
2093 :
2094 27197100 : if (i < 12) // vertices
2095 13598550 : return mainval - bubbleval / 9;
2096 :
2097 13598550 : return mainval + bubbleval * (Real(4) / 9);
2098 : }
2099 :
2100 222184494 : case PRISM21:
2101 : {
2102 61526880 : libmesh_assert_less (i, 21);
2103 :
2104 : // Compute prism shape functions as a tensor-product
2105 : // of a triangle and an edge
2106 :
2107 222184494 : Point p2d(p(0),p(1));
2108 222184494 : Real p1d = p(2);
2109 :
2110 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
2111 : static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2, 0, 1, 2};
2112 : static const unsigned int i1[] = {0, 1, 2, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 3, 4, 5, 6, 6, 6};
2113 :
2114 222184494 : switch (j)
2115 : {
2116 : // d()/dxi
2117 74061498 : case 0:
2118 74061498 : return (FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, i1[i], 0, p2d)*
2119 94565640 : fe_lagrange_1D_quadratic_shape(i0[i], p1d));
2120 :
2121 : // d()/deta
2122 74061498 : case 1:
2123 74061498 : return (FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, i1[i], 1, p2d)*
2124 94565640 : fe_lagrange_1D_quadratic_shape(i0[i], p1d));
2125 :
2126 : // d()/dzeta
2127 74061498 : case 2:
2128 74061498 : return (FE<2,LAGRANGE>::shape(TRI7, THIRD, i1[i], p2d)*
2129 127614036 : fe_lagrange_1D_quadratic_shape_deriv(i0[i], 0, p1d));
2130 :
2131 0 : default:
2132 0 : libmesh_error_msg("Invalid shape function derivative j = " << j);
2133 : }
2134 : }
2135 :
2136 39437334 : case PYRAMID18:
2137 : {
2138 39437334 : return fe_fdm_deriv(type, order, elem, i, j, p, fe_lagrange_3D_shape<T>);
2139 : }
2140 :
2141 0 : default:
2142 0 : libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
2143 : }
2144 : }
2145 :
2146 : // unsupported order
2147 0 : default:
2148 0 : libmesh_error_msg("ERROR: Unsupported 3D FE order!: " << order);
2149 : }
2150 :
2151 : #else // LIBMESH_DIM != 3
2152 : libmesh_ignore(type, order, elem, i, j, p);
2153 : libmesh_not_implemented();
2154 : #endif
2155 : }
2156 :
2157 :
2158 :
2159 : #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
2160 :
2161 : template <FEFamily T>
2162 729576726 : Real fe_lagrange_3D_shape_second_deriv(const ElemType type,
2163 : const Order order,
2164 : const Elem * elem,
2165 : const unsigned int i,
2166 : const unsigned int j,
2167 : const Point & p)
2168 : {
2169 : #if LIBMESH_DIM == 3
2170 :
2171 179627976 : libmesh_assert_less (j, 6);
2172 :
2173 729576726 : switch (order)
2174 : {
2175 : // linear Lagrange shape functions
2176 62646576 : case FIRST:
2177 : {
2178 62646576 : switch (type)
2179 : {
2180 : // Linear tets have all second derivatives = 0
2181 191280 : case TET4:
2182 : case TET10:
2183 : case TET14:
2184 : {
2185 191280 : return 0.;
2186 : }
2187 :
2188 : // The following elements use either tensor product or
2189 : // rational basis functions, and therefore probably have
2190 : // second derivatives, but we have not implemented them
2191 : // yet...
2192 7391556 : case PRISM6:
2193 : case PRISM15:
2194 : case PRISM18:
2195 : case PRISM20:
2196 : case PRISM21:
2197 : {
2198 2054016 : libmesh_assert_less (i, 6);
2199 :
2200 : // Compute prism shape functions as a tensor-product
2201 : // of a triangle and an edge
2202 :
2203 7391556 : Point p2d(p(0),p(1));
2204 2054016 : Real p1d = p(2);
2205 :
2206 : // 0 1 2 3 4 5
2207 : static const unsigned int i0[] = {0, 0, 0, 1, 1, 1};
2208 : static const unsigned int i1[] = {0, 1, 2, 0, 1, 2};
2209 :
2210 7391556 : switch (j)
2211 : {
2212 : // All repeated second derivatives and the xi-eta derivative are zero on PRISMs
2213 1369344 : case 0: // d^2()/dxi^2
2214 : case 1: // d^2()/dxideta
2215 : case 2: // d^2()/deta^2
2216 : case 5: // d^2()/dzeta^2
2217 : {
2218 1369344 : return 0.;
2219 : }
2220 :
2221 1231926 : case 3: // d^2()/dxidzeta
2222 1231926 : return (FE<2,LAGRANGE>::shape_deriv(TRI3, FIRST, i1[i], 0, p2d)*
2223 1676721 : fe_lagrange_1D_linear_shape_deriv(i0[i], 0, p1d));
2224 :
2225 1231926 : case 4: // d^2()/detadzeta
2226 1231926 : return (FE<2,LAGRANGE>::shape_deriv(TRI3, FIRST, i1[i], 1, p2d)*
2227 1676721 : fe_lagrange_1D_linear_shape_deriv(i0[i], 0, p1d));
2228 :
2229 0 : default:
2230 0 : libmesh_error_msg("Invalid j = " << j);
2231 : }
2232 : }
2233 :
2234 269340 : case PYRAMID5:
2235 : case PYRAMID13:
2236 : case PYRAMID14:
2237 : case PYRAMID18:
2238 : {
2239 72240 : libmesh_assert_less (i, 5);
2240 :
2241 269340 : const Real xi = p(0);
2242 269340 : const Real eta = p(1);
2243 269340 : const Real zeta = p(2);
2244 72240 : const Real eps = 1.e-35;
2245 :
2246 269340 : switch (j)
2247 : {
2248 : // xi-xi and eta-eta derivatives are all zero for PYRAMID5.
2249 24080 : case 0: // d^2()/dxi^2
2250 : case 2: // d^2()/deta^2
2251 24080 : return 0.;
2252 :
2253 44890 : case 1: // d^2()/dxideta
2254 : {
2255 44890 : switch (i)
2256 : {
2257 17956 : case 0:
2258 : case 2:
2259 17956 : return 0.25/(1. - zeta + eps);
2260 17956 : case 1:
2261 : case 3:
2262 17956 : return -0.25/(1. - zeta + eps);
2263 2408 : case 4:
2264 2408 : return 0.;
2265 0 : default:
2266 0 : libmesh_error_msg("Invalid i = " << i);
2267 : }
2268 : }
2269 :
2270 44890 : case 3: // d^2()/dxidzeta
2271 : {
2272 44890 : Real den = (1. - zeta + eps)*(1. - zeta + eps);
2273 :
2274 44890 : switch (i)
2275 : {
2276 17956 : case 0:
2277 : case 2:
2278 17956 : return 0.25*eta/den;
2279 17956 : case 1:
2280 : case 3:
2281 17956 : return -0.25*eta/den;
2282 2408 : case 4:
2283 2408 : return 0.;
2284 0 : default:
2285 0 : libmesh_error_msg("Invalid i = " << i);
2286 : }
2287 : }
2288 :
2289 44890 : case 4: // d^2()/detadzeta
2290 : {
2291 44890 : Real den = (1. - zeta + eps)*(1. - zeta + eps);
2292 :
2293 44890 : switch (i)
2294 : {
2295 17956 : case 0:
2296 : case 2:
2297 17956 : return 0.25*xi/den;
2298 17956 : case 1:
2299 : case 3:
2300 17956 : return -0.25*xi/den;
2301 2408 : case 4:
2302 2408 : return 0.;
2303 0 : default:
2304 0 : libmesh_error_msg("Invalid i = " << i);
2305 : }
2306 : }
2307 :
2308 44890 : case 5: // d^2()/dzeta^2
2309 : {
2310 44890 : Real den = (1. - zeta + eps)*(1. - zeta + eps)*(1. - zeta + eps);
2311 :
2312 44890 : switch (i)
2313 : {
2314 17956 : case 0:
2315 : case 2:
2316 17956 : return 0.5*xi*eta/den;
2317 17956 : case 1:
2318 : case 3:
2319 17956 : return -0.5*xi*eta/den;
2320 2408 : case 4:
2321 2408 : return 0.;
2322 0 : default:
2323 0 : libmesh_error_msg("Invalid i = " << i);
2324 : }
2325 : }
2326 :
2327 0 : default:
2328 0 : libmesh_error_msg("Invalid j = " << j);
2329 : }
2330 : }
2331 :
2332 : // Trilinear shape functions on HEX8s have nonzero mixed second derivatives
2333 48775776 : case HEX8:
2334 : case HEX20:
2335 : case HEX27:
2336 : {
2337 12197136 : libmesh_assert_less (i, 8);
2338 48775776 : return libMesh::detail::fe_lagrange_hex8_shape_second_deriv(i, j, p(0), p(1), p(2));
2339 : }
2340 :
2341 : // All second derivatives for piecewise-linear polyhedra are
2342 : // zero or dirac-type distributions, but we can't put the
2343 : // latter in a Real, so beware when integrating...
2344 1385676 : case C0POLYHEDRON:
2345 : {
2346 1385676 : return 0.;
2347 : }
2348 :
2349 0 : default:
2350 0 : libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
2351 : }
2352 :
2353 : }
2354 :
2355 : // quadratic Lagrange shape functions
2356 327471408 : case SECOND:
2357 : {
2358 327471408 : switch (type)
2359 : {
2360 :
2361 : // serendipity hexahedral quadratic shape functions
2362 24134400 : case HEX20:
2363 : {
2364 6033600 : libmesh_assert_less (i, 20);
2365 24134400 : return libMesh::detail::fe_lagrange_hex20_shape_second_deriv(i, j, p(0), p(1), p(2));
2366 : }
2367 :
2368 : // triquadratic hexahedral shape functions
2369 196069896 : case HEX8:
2370 625806 : libmesh_assert_msg(T == L2_LAGRANGE,
2371 : "High order on first order elements only supported for L2 families");
2372 : libmesh_fallthrough();
2373 57787020 : case HEX27:
2374 : {
2375 59017896 : libmesh_assert_less (i, 27);
2376 254461986 : return libMesh::detail::fe_lagrange_hex27_shape_second_deriv(i, j, p(0), p(1), p(2));
2377 : }
2378 :
2379 : // quadratic tetrahedral shape functions
2380 1584060 : case TET4:
2381 41760 : libmesh_assert_msg(T == L2_LAGRANGE,
2382 : "High order on first order elements only supported for L2 families");
2383 : libmesh_fallthrough();
2384 529560 : case TET10:
2385 : case TET14:
2386 : {
2387 617940 : libmesh_assert_less (i, 10);
2388 2160240 : return libMesh::detail::fe_lagrange_tet10_shape_second_deriv(i, j);
2389 : }
2390 :
2391 :
2392 :
2393 : // "serendipity" prism
2394 15507990 : case PRISM15:
2395 : {
2396 4315140 : libmesh_assert_less (i, 15);
2397 :
2398 15507990 : const Real xi = p(0);
2399 15507990 : const Real eta = p(1);
2400 15507990 : const Real zeta = p(2);
2401 :
2402 15507990 : switch (j)
2403 : {
2404 : // d^2()/dxi^2
2405 2584665 : case 0:
2406 : {
2407 2584665 : switch(i)
2408 : {
2409 344622 : case 0:
2410 : case 1:
2411 344622 : return 2.*(1. - zeta);
2412 431514 : case 2:
2413 : case 5:
2414 : case 7:
2415 : case 8:
2416 : case 9:
2417 : case 10:
2418 : case 11:
2419 : case 13:
2420 : case 14:
2421 431514 : return 0.;
2422 344622 : case 3:
2423 : case 4:
2424 344622 : return 2.*(1. + zeta);
2425 172311 : case 6:
2426 172311 : return 4.*(zeta - 1);
2427 172311 : case 12:
2428 172311 : return -4.*(1. + zeta);
2429 0 : default:
2430 0 : libmesh_error_msg("Invalid i = " << i);
2431 : }
2432 : }
2433 :
2434 : // d^2()/dxideta
2435 2584665 : case 1:
2436 : {
2437 2584665 : switch(i)
2438 : {
2439 344622 : case 0:
2440 : case 7:
2441 344622 : return 2.*(1. - zeta);
2442 335622 : case 1:
2443 : case 2:
2444 : case 4:
2445 : case 5:
2446 : case 9:
2447 : case 10:
2448 : case 11:
2449 335622 : return 0.;
2450 344622 : case 3:
2451 : case 13:
2452 344622 : return 2.*(1. + zeta);
2453 344622 : case 6:
2454 : case 8:
2455 344622 : return 2.*(zeta - 1.);
2456 344622 : case 12:
2457 : case 14:
2458 344622 : return -2.*(1. + zeta);
2459 0 : default:
2460 0 : libmesh_error_msg("Invalid i = " << i);
2461 : }
2462 : }
2463 :
2464 : // d^2()/deta^2
2465 2584665 : case 2:
2466 : {
2467 2584665 : switch(i)
2468 : {
2469 344622 : case 0:
2470 : case 2:
2471 344622 : return 2.*(1. - zeta);
2472 431514 : case 1:
2473 : case 4:
2474 : case 6:
2475 : case 7:
2476 : case 9:
2477 : case 10:
2478 : case 11:
2479 : case 12:
2480 : case 13:
2481 431514 : return 0.;
2482 344622 : case 3:
2483 : case 5:
2484 344622 : return 2.*(1. + zeta);
2485 172311 : case 8:
2486 172311 : return 4.*(zeta - 1.);
2487 172311 : case 14:
2488 172311 : return -4.*(1. + zeta);
2489 0 : default:
2490 0 : libmesh_error_msg("Invalid i = " << i);
2491 : }
2492 : }
2493 :
2494 : // d^2()/dxidzeta
2495 2584665 : case 3:
2496 : {
2497 2584665 : switch(i)
2498 : {
2499 172311 : case 0:
2500 172311 : return 1.5 - zeta - 2.*xi - 2.*eta;
2501 172311 : case 1:
2502 172311 : return 0.5 + zeta - 2.*xi;
2503 143838 : case 2:
2504 : case 5:
2505 : case 11:
2506 143838 : return 0.;
2507 172311 : case 3:
2508 172311 : return -1.5 - zeta + 2.*xi + 2.*eta;
2509 172311 : case 4:
2510 172311 : return -0.5 + zeta + 2.*xi;
2511 172311 : case 6:
2512 172311 : return 4.*xi + 2.*eta - 2.;
2513 172311 : case 7:
2514 172311 : return -2.*eta;
2515 172311 : case 8:
2516 172311 : return 2.*eta;
2517 172311 : case 9:
2518 172311 : return 2.*zeta;
2519 172311 : case 10:
2520 172311 : return -2.*zeta;
2521 172311 : case 12:
2522 172311 : return -4.*xi - 2.*eta + 2.;
2523 172311 : case 13:
2524 172311 : return 2.*eta;
2525 172311 : case 14:
2526 172311 : return -2.*eta;
2527 0 : default:
2528 0 : libmesh_error_msg("Invalid i = " << i);
2529 : }
2530 : }
2531 :
2532 : // d^2()/detadzeta
2533 2584665 : case 4:
2534 : {
2535 2584665 : switch(i)
2536 : {
2537 172311 : case 0:
2538 172311 : return 1.5 - zeta - 2.*xi - 2.*eta;
2539 143838 : case 1:
2540 : case 4:
2541 : case 10:
2542 143838 : return 0.;
2543 172311 : case 2:
2544 172311 : return .5 + zeta - 2.*eta;
2545 172311 : case 3:
2546 172311 : return -1.5 - zeta + 2.*xi + 2.*eta;
2547 172311 : case 5:
2548 172311 : return -.5 + zeta + 2.*eta;
2549 172311 : case 6:
2550 172311 : return 2.*xi;
2551 172311 : case 7:
2552 172311 : return -2.*xi;
2553 172311 : case 8:
2554 172311 : return 2.*xi + 4.*eta - 2.;
2555 172311 : case 9:
2556 172311 : return 2.*zeta;
2557 172311 : case 11:
2558 172311 : return -2.*zeta;
2559 172311 : case 12:
2560 172311 : return -2.*xi;
2561 172311 : case 13:
2562 172311 : return 2.*xi;
2563 172311 : case 14:
2564 172311 : return -2.*xi - 4.*eta + 2.;
2565 0 : default:
2566 0 : libmesh_error_msg("Invalid i = " << i);
2567 : }
2568 : }
2569 :
2570 : // d^2()/dzeta^2
2571 2584665 : case 5:
2572 : {
2573 2584665 : switch(i)
2574 : {
2575 344622 : case 0:
2576 : case 3:
2577 344622 : return 1. - xi - eta;
2578 95892 : case 1:
2579 : case 4:
2580 95892 : return xi;
2581 344622 : case 2:
2582 : case 5:
2583 344622 : return eta;
2584 575352 : case 6:
2585 : case 7:
2586 : case 8:
2587 : case 12:
2588 : case 13:
2589 : case 14:
2590 575352 : return 0.;
2591 172311 : case 9:
2592 172311 : return 2.*xi + 2.*eta - 2.;
2593 172311 : case 10:
2594 172311 : return -2.*xi;
2595 172311 : case 11:
2596 172311 : return -2.*eta;
2597 0 : default:
2598 0 : libmesh_error_msg("Invalid i = " << i);
2599 : }
2600 : }
2601 :
2602 0 : default:
2603 0 : libmesh_error_msg("Invalid j = " << j);
2604 : }
2605 : }
2606 :
2607 :
2608 :
2609 : // quadratic prism shape functions
2610 21499344 : case PRISM6:
2611 413424 : libmesh_assert_msg(T == L2_LAGRANGE,
2612 : "High order on first order elements only supported for L2 families");
2613 : libmesh_fallthrough();
2614 6472872 : case PRISM18:
2615 : case PRISM20:
2616 : case PRISM21:
2617 : {
2618 8126568 : libmesh_assert_less (i, 18);
2619 :
2620 : // Compute prism shape functions as a tensor-product
2621 : // of a triangle and an edge
2622 :
2623 29212488 : Point p2d(p(0),p(1));
2624 29212488 : Real p1d = p(2);
2625 :
2626 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
2627 : static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2};
2628 : static const unsigned int i1[] = {0, 1, 2, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 3, 4, 5};
2629 :
2630 29212488 : switch (j)
2631 : {
2632 : // d^2()/dxi^2
2633 4868748 : case 0:
2634 4868748 : return (FE<2,LAGRANGE>::shape_second_deriv(TRI6, SECOND, i1[i], 0, p2d)*
2635 6223176 : fe_lagrange_1D_quadratic_shape(i0[i], p1d));
2636 :
2637 : // d^2()/dxideta
2638 4868748 : case 1:
2639 4868748 : return (FE<2,LAGRANGE>::shape_second_deriv(TRI6, SECOND, i1[i], 1, p2d)*
2640 6223176 : fe_lagrange_1D_quadratic_shape(i0[i], p1d));
2641 :
2642 : // d^2()/deta^2
2643 4868748 : case 2:
2644 4868748 : return (FE<2,LAGRANGE>::shape_second_deriv(TRI6, SECOND, i1[i], 2, p2d)*
2645 6223176 : fe_lagrange_1D_quadratic_shape(i0[i], p1d));
2646 :
2647 : // d^2()/dxidzeta
2648 4868748 : case 3:
2649 4868748 : return (FE<2,LAGRANGE>::shape_deriv(TRI6, SECOND, i1[i], 0, p2d)*
2650 8383068 : fe_lagrange_1D_quadratic_shape_deriv(i0[i], 0, p1d));
2651 :
2652 : // d^2()/detadzeta
2653 4868748 : case 4:
2654 4868748 : return (FE<2,LAGRANGE>::shape_deriv(TRI6, SECOND, i1[i], 1, p2d)*
2655 8383068 : fe_lagrange_1D_quadratic_shape_deriv(i0[i], 0, p1d));
2656 :
2657 : // d^2()/dzeta^2
2658 4868748 : case 5:
2659 4868748 : return (FE<2,LAGRANGE>::shape(TRI6, SECOND, i1[i], p2d)*
2660 6040188 : fe_lagrange_1D_quadratic_shape_second_deriv(i0[i], 0, p1d));
2661 :
2662 0 : default:
2663 0 : libmesh_error_msg("Invalid shape function derivative j = " << j);
2664 : }
2665 : }
2666 :
2667 :
2668 : // Quadratic shape functions, as defined in R. Graglia, "Higher order
2669 : // bases on pyramidal elements", IEEE Trans Antennas and Propagation,
2670 : // vol 47, no 5, May 1999.
2671 899640 : case PYRAMID5:
2672 0 : libmesh_assert_msg(T == L2_LAGRANGE,
2673 : "High order on first order elements only supported for L2 families");
2674 : libmesh_fallthrough();
2675 332136 : case PYRAMID14:
2676 : case PYRAMID18:
2677 : {
2678 332136 : libmesh_assert_less (i, 14);
2679 :
2680 1231776 : const Real xi = p(0);
2681 1231776 : const Real eta = p(1);
2682 1231776 : const Real zeta = p(2);
2683 332136 : const Real eps = 1.e-35;
2684 :
2685 : // The "normalized coordinates" defined by Graglia. These are
2686 : // the planes which define the faces of the pyramid.
2687 : Real
2688 1231776 : p1 = 0.5*(1. - eta - zeta), // back
2689 1231776 : p2 = 0.5*(1. + xi - zeta), // left
2690 1231776 : p3 = 0.5*(1. + eta - zeta), // front
2691 1231776 : p4 = 0.5*(1. - xi - zeta); // right
2692 :
2693 : // Denominators are perturbed by epsilon to avoid
2694 : // divide-by-zero issues.
2695 : Real
2696 1231776 : den = (-1. + zeta + eps),
2697 1231776 : den2 = den*den,
2698 1231776 : den3 = den2*den,
2699 1231776 : den4 = den2*den2;
2700 :
2701 : // These terms are used in several of the derivatives
2702 : Real
2703 1231776 : numer_mp = xi*eta - zeta + zeta*zeta,
2704 1231776 : numer_pm = xi*eta + zeta - zeta*zeta;
2705 :
2706 1231776 : switch (j)
2707 : {
2708 205296 : case 0: // d^2()/dxi^2
2709 : {
2710 205296 : switch(i)
2711 : {
2712 29328 : case 0:
2713 : case 1:
2714 29328 : return -p1*eta/den2;
2715 29328 : case 2:
2716 : case 3:
2717 29328 : return p3*eta/den2;
2718 19770 : case 4:
2719 : case 9:
2720 : case 10:
2721 : case 11:
2722 : case 12:
2723 19770 : return 0.;
2724 14664 : case 5:
2725 14664 : return 2.*p1*eta/den2;
2726 29328 : case 6:
2727 : case 8:
2728 29328 : return 4.*p1*p3/den2;
2729 14664 : case 7:
2730 14664 : return -2.*p3*eta/den2;
2731 14664 : case 13:
2732 14664 : return -8.*p1*p3/den2;
2733 0 : default:
2734 0 : libmesh_error_msg("Invalid i = " << i);
2735 : }
2736 : }
2737 :
2738 205296 : case 1: // d^2()/dxideta
2739 : {
2740 205296 : switch(i)
2741 : {
2742 14664 : case 0:
2743 14664 : return 0.25*numer_mp/den2
2744 14664 : - 0.5*p1*xi/den2
2745 14664 : - 0.5*p4*eta/den2
2746 14664 : + p4*p1/den2;
2747 :
2748 14664 : case 1:
2749 14664 : return 0.25*numer_pm/den2
2750 14664 : - 0.5*p1*xi/den2
2751 14664 : + 0.5*p2*eta/den2
2752 14664 : - p1*p2/den2;
2753 :
2754 14664 : case 2:
2755 14664 : return 0.25*numer_mp/den2
2756 14664 : + 0.5*p3*xi/den2
2757 14664 : + 0.5*p2*eta/den2
2758 14664 : + p2*p3/den2;
2759 :
2760 14664 : case 3:
2761 14664 : return 0.25*numer_pm/den2
2762 14664 : + 0.5*p3*xi/den2
2763 14664 : - 0.5*p4*eta/den2
2764 14664 : - p3*p4/den2;
2765 :
2766 3954 : case 4:
2767 3954 : return 0.;
2768 :
2769 14664 : case 5:
2770 14664 : return p4*eta/den2
2771 14664 : - 2.*p4*p1/den2
2772 14664 : - p2*eta/den2
2773 14664 : + 2.*p1*p2/den2;
2774 :
2775 14664 : case 6:
2776 14664 : return -p3*xi/den2
2777 14664 : + p1*xi/den2
2778 14664 : - 2.*p2*p3/den2
2779 14664 : + 2.*p1*p2/den2;
2780 :
2781 14664 : case 7:
2782 14664 : return p4*eta/den2
2783 14664 : + 2.*p3*p4/den2
2784 14664 : - p2*eta/den2
2785 14664 : - 2.*p2*p3/den2;
2786 :
2787 14664 : case 8:
2788 14664 : return -p3*xi/den2
2789 14664 : + p1*xi/den2
2790 14664 : - 2.*p4*p1/den2
2791 14664 : + 2.*p3*p4/den2;
2792 :
2793 29328 : case 9:
2794 : case 11:
2795 29328 : return -zeta/den;
2796 :
2797 29328 : case 10:
2798 : case 12:
2799 29328 : return zeta/den;
2800 :
2801 14664 : case 13:
2802 14664 : return 4.*p4*p1/den2
2803 14664 : - 4.*p3*p4/den2
2804 14664 : + 4.*p2*p3/den2
2805 14664 : - 4.*p1*p2/den2;
2806 :
2807 0 : default:
2808 0 : libmesh_error_msg("Invalid i = " << i);
2809 : }
2810 : }
2811 :
2812 :
2813 205296 : case 2: // d^2()/deta^2
2814 : {
2815 205296 : switch(i)
2816 : {
2817 29328 : case 0:
2818 : case 3:
2819 29328 : return -p4*xi/den2;
2820 29328 : case 1:
2821 : case 2:
2822 29328 : return p2*xi/den2;
2823 19770 : case 4:
2824 : case 9:
2825 : case 10:
2826 : case 11:
2827 : case 12:
2828 19770 : return 0.;
2829 29328 : case 5:
2830 : case 7:
2831 29328 : return 4.*p2*p4/den2;
2832 14664 : case 6:
2833 14664 : return -2.*p2*xi/den2;
2834 14664 : case 8:
2835 14664 : return 2.*p4*xi/den2;
2836 14664 : case 13:
2837 14664 : return -8.*p2*p4/den2;
2838 0 : default:
2839 0 : libmesh_error_msg("Invalid i = " << i);
2840 : }
2841 : }
2842 :
2843 :
2844 205296 : case 3: // d^2()/dxidzeta
2845 : {
2846 205296 : switch(i)
2847 : {
2848 14664 : case 0:
2849 14664 : return 0.25*numer_mp/den2
2850 14664 : - 0.5*p1*(2.*zeta - 1.)/den2
2851 14664 : + p1*numer_mp/den3
2852 14664 : - 0.5*p1*eta/den2
2853 14664 : - 0.5*p4*eta/den2
2854 14664 : - 2.*p4*p1*eta/den3;
2855 :
2856 14664 : case 1:
2857 14664 : return 0.25*numer_pm/den2
2858 14664 : - 0.5*p1*(1 - 2.*zeta)/den2
2859 14664 : + p1*numer_pm/den3
2860 14664 : + 0.5*p2*eta/den2
2861 14664 : + 0.5*p1*eta/den2
2862 14664 : + 2.*p1*p2*eta/den3;
2863 :
2864 14664 : case 2:
2865 14664 : return -0.25*numer_mp/den2
2866 14664 : + 0.5*p3*(2.*zeta - 1.)/den2
2867 14664 : - p3*numer_mp/den3
2868 14664 : - 0.5*p3*eta/den2
2869 14664 : - 0.5*p2*eta/den2
2870 14664 : - 2.*p2*p3*eta/den3;
2871 :
2872 14664 : case 3:
2873 14664 : return -0.25*numer_pm/den2
2874 14664 : + 0.5*p3*(1 - 2.*zeta)/den2
2875 14664 : - p3*numer_pm/den3
2876 14664 : + 0.5*p4*eta/den2
2877 14664 : + 0.5*p3*eta/den2
2878 14664 : + 2.*p3*p4*eta/den3;
2879 :
2880 3954 : case 4:
2881 3954 : return 0.;
2882 :
2883 14664 : case 5:
2884 14664 : return p4*eta/den2
2885 14664 : + 4.*p4*p1*eta/den3
2886 14664 : - p2*eta/den2
2887 14664 : - 4.*p1*p2*eta/den3;
2888 :
2889 14664 : case 6:
2890 14664 : return -p3*xi/den2
2891 14664 : - p1*xi/den2
2892 14664 : - 4.*p1*p3*xi/den3
2893 14664 : - 2.*p2*p3/den2
2894 14664 : - 2.*p1*p3/den2
2895 14664 : - 2.*p1*p2/den2
2896 14664 : - 8.*p1*p2*p3/den3;
2897 :
2898 14664 : case 7:
2899 14664 : return -p4*eta/den2
2900 14664 : - 4.*p3*p4*eta/den3
2901 14664 : + p2*eta/den2
2902 14664 : + 4.*p2*p3*eta/den3;
2903 :
2904 14664 : case 8:
2905 14664 : return -p3*xi/den2
2906 14664 : - p1*xi/den2
2907 14664 : - 4.*p1*p3*xi/den3
2908 14664 : + 2.*p4*p1/den2
2909 14664 : + 2.*p1*p3/den2
2910 14664 : + 2.*p3*p4/den2
2911 14664 : + 8.*p3*p4*p1/den3;
2912 :
2913 14664 : case 9:
2914 14664 : return -zeta/den
2915 14664 : + 2.*p1/den
2916 14664 : - 2.*p1*zeta/den2;
2917 :
2918 14664 : case 10:
2919 14664 : return zeta/den
2920 14664 : - 2.*p1/den
2921 14664 : + 2.*p1*zeta/den2;
2922 :
2923 14664 : case 11:
2924 14664 : return zeta/den
2925 14664 : - 2.*p3/den
2926 14664 : + 2.*p3*zeta/den2;
2927 :
2928 14664 : case 12:
2929 14664 : return -zeta/den
2930 14664 : + 2.*p3/den
2931 14664 : - 2.*p3*zeta/den2;
2932 :
2933 14664 : case 13:
2934 14664 : return -4.*p4*p1/den2
2935 14664 : - 4.*p3*p4/den2
2936 14664 : - 16.*p3*p4*p1/den3
2937 14664 : + 4.*p2*p3/den2
2938 14664 : + 4.*p1*p2/den2
2939 14664 : + 16.*p1*p2*p3/den3;
2940 :
2941 0 : default:
2942 0 : libmesh_error_msg("Invalid i = " << i);
2943 : }
2944 : }
2945 :
2946 205296 : case 4: // d^2()/detadzeta
2947 : {
2948 205296 : switch(i)
2949 : {
2950 14664 : case 0:
2951 14664 : return 0.25*numer_mp/den2
2952 14664 : - 0.5*p4*(2.*zeta - 1.)/den2
2953 14664 : + p4*numer_mp/den3
2954 14664 : - 0.5*p1*xi/den2
2955 14664 : - 0.5*p4*xi/den2
2956 14664 : - 2.*p4*p1*xi/den3;
2957 :
2958 14664 : case 1:
2959 14664 : return -0.25*numer_pm/den2
2960 14664 : + 0.5*p2*(1. - 2.*zeta)/den2
2961 14664 : - p2*numer_pm/den3
2962 14664 : + 0.5*p2*xi/den2
2963 14664 : + 0.5*p1*xi/den2
2964 14664 : + 2.*p1*p2*xi/den3;
2965 :
2966 14664 : case 2:
2967 14664 : return -0.25*numer_mp/den2
2968 14664 : + 0.5*p2*(2.*zeta - 1.)/den2
2969 14664 : - p2*numer_mp/den3
2970 14664 : - 0.5*p3*xi/den2
2971 14664 : - 0.5*p2*xi/den2
2972 14664 : - 2.*p2*p3*xi/den3;
2973 :
2974 14664 : case 3:
2975 14664 : return 0.25*numer_pm/den2
2976 14664 : - 0.5*p4*(1. - 2.*zeta)/den2
2977 14664 : + p4*numer_pm/den3
2978 14664 : + 0.5*p4*xi/den2
2979 14664 : + 0.5*p3*xi/den2
2980 14664 : + 2.*p3*p4*xi/den3;
2981 :
2982 3954 : case 4:
2983 3954 : return 0.;
2984 :
2985 14664 : case 5:
2986 14664 : return -p4*eta/den2
2987 14664 : - p2*eta/den2
2988 14664 : - 4.*p2*p4*eta/den3
2989 14664 : + 2.*p4*p1/den2
2990 14664 : + 2.*p2*p4/den2
2991 14664 : + 2.*p1*p2/den2
2992 14664 : + 8.*p2*p1*p4/den3;
2993 :
2994 14664 : case 6:
2995 14664 : return p3*xi/den2
2996 14664 : + 4.*p2*p3*xi/den3
2997 14664 : - p1*xi/den2
2998 14664 : - 4.*p1*p2*xi/den3;
2999 :
3000 14664 : case 7:
3001 14664 : return -p4*eta/den2
3002 14664 : - p2*eta/den2
3003 14664 : - 4.*p2*p4*eta/den3
3004 14664 : - 2.*p3*p4/den2
3005 14664 : - 2.*p2*p4/den2
3006 14664 : - 2.*p2*p3/den2
3007 14664 : - 8.*p2*p3*p4/den3;
3008 :
3009 14664 : case 8:
3010 14664 : return p1*xi/den2
3011 14664 : + 4.*p4*p1*xi/den3
3012 14664 : - p3*xi/den2
3013 14664 : - 4.*p3*p4*xi/den3;
3014 :
3015 14664 : case 9:
3016 14664 : return -zeta/den
3017 14664 : + 2.*p4/den
3018 14664 : - 2.*p4*zeta/den2;
3019 :
3020 14664 : case 10:
3021 14664 : return -zeta/den
3022 14664 : + 2.*p2/den
3023 14664 : - 2.*p2*zeta/den2;
3024 :
3025 14664 : case 11:
3026 14664 : return zeta/den
3027 14664 : - 2.*p2/den
3028 14664 : + 2.*p2*zeta/den2;
3029 :
3030 14664 : case 12:
3031 14664 : return zeta/den
3032 14664 : - 2.*p4/den
3033 14664 : + 2.*p4*zeta/den2;
3034 :
3035 14664 : case 13:
3036 14664 : return 4.*p3*p4/den2
3037 14664 : + 4.*p2*p3/den2
3038 14664 : + 16.*p2*p3*p4/den3
3039 14664 : - 4.*p4*p1/den2
3040 14664 : - 4.*p1*p2/den2
3041 14664 : - 16.*p2*p1*p4/den3;
3042 :
3043 0 : default:
3044 0 : libmesh_error_msg("Invalid i = " << i);
3045 : }
3046 : }
3047 :
3048 205296 : case 5: // d^2()/dzeta^2
3049 : {
3050 205296 : switch(i)
3051 : {
3052 14664 : case 0:
3053 14664 : return 0.5*numer_mp/den2
3054 14664 : - p1*(2.*zeta - 1.)/den2
3055 14664 : + 2.*p1*numer_mp/den3
3056 14664 : - p4*(2.*zeta - 1.)/den2
3057 14664 : + 2.*p4*numer_mp/den3
3058 14664 : + 2.*p4*p1/den2
3059 14664 : - 4.*p4*p1*(2.*zeta - 1.)/den3
3060 14664 : + 6.*p4*p1*numer_mp/den4;
3061 :
3062 14664 : case 1:
3063 14664 : return -0.5*numer_pm/den2
3064 14664 : + p2*(1 - 2.*zeta)/den2
3065 14664 : - 2.*p2*numer_pm/den3
3066 14664 : + p1*(1 - 2.*zeta)/den2
3067 14664 : - 2.*p1*numer_pm/den3
3068 14664 : + 2.*p1*p2/den2
3069 14664 : + 4.*p1*p2*(1 - 2.*zeta)/den3
3070 14664 : - 6.*p1*p2*numer_pm/den4;
3071 :
3072 14664 : case 2:
3073 14664 : return 0.5*numer_mp/den2
3074 14664 : - p3*(2.*zeta - 1.)/den2
3075 14664 : + 2.*p3*numer_mp/den3
3076 14664 : - p2*(2.*zeta - 1.)/den2
3077 14664 : + 2.*p2*numer_mp/den3
3078 14664 : + 2.*p2*p3/den2
3079 14664 : - 4.*p2*p3*(2.*zeta - 1.)/den3
3080 14664 : + 6.*p2*p3*numer_mp/den4;
3081 :
3082 14664 : case 3:
3083 14664 : return -0.5*numer_pm/den2
3084 14664 : + p4*(1 - 2.*zeta)/den2
3085 14664 : - 2.*p4*numer_pm/den3
3086 14664 : + p3*(1 - 2.*zeta)/den2
3087 14664 : - 2.*p3*numer_pm/den3
3088 14664 : + 2.*p3*p4/den2
3089 14664 : + 4.*p3*p4*(1 - 2.*zeta)/den3
3090 14664 : - 6.*p3*p4*numer_pm/den4;
3091 :
3092 3954 : case 4:
3093 3954 : return 4.;
3094 :
3095 14664 : case 5:
3096 14664 : return -2.*p1*eta/den2
3097 14664 : - 2.*p4*eta/den2
3098 14664 : - 8.*p4*p1*eta/den3
3099 14664 : - 2.*p2*eta/den2
3100 14664 : - 8.*p2*p4*eta/den3
3101 14664 : - 8.*p1*p2*eta/den3
3102 14664 : - 24.*p2*p1*p4*eta/den4;
3103 :
3104 14664 : case 6:
3105 14664 : return 2.*p3*xi/den2
3106 14664 : + 2.*p2*xi/den2
3107 14664 : + 8.*p2*p3*xi/den3
3108 14664 : + 2.*p1*xi/den2
3109 14664 : + 8.*p1*p3*xi/den3
3110 14664 : + 8.*p1*p2*xi/den3
3111 14664 : + 24.*p1*p2*p3*xi/den4;
3112 :
3113 14664 : case 7:
3114 14664 : return 2.*p4*eta/den2
3115 14664 : + 2.*p3*eta/den2
3116 14664 : + 8.*p3*p4*eta/den3
3117 14664 : + 2.*p2*eta/den2
3118 14664 : + 8.*p2*p4*eta/den3
3119 14664 : + 8.*p2*p3*eta/den3
3120 14664 : + 24.*p2*p3*p4*eta/den4;
3121 :
3122 14664 : case 8:
3123 14664 : return -2.*p1*xi/den2
3124 14664 : - 2.*p4*xi/den2
3125 14664 : - 8.*p4*p1*xi/den3
3126 14664 : - 2.*p3*xi/den2
3127 14664 : - 8.*p1*p3*xi/den3
3128 14664 : - 8.*p3*p4*xi/den3
3129 14664 : - 24.*p3*p4*p1*xi/den4;
3130 :
3131 14664 : case 9:
3132 14664 : return -2.*zeta/den
3133 14664 : + 4.*p4/den
3134 14664 : - 4.*p4*zeta/den2
3135 14664 : + 4.*p1/den
3136 14664 : - 4.*p1*zeta/den2
3137 14664 : + 8.*p4*p1/den2
3138 14664 : - 8.*p1*p4*zeta/den3;
3139 :
3140 14664 : case 10:
3141 14664 : return -2.*zeta/den
3142 14664 : + 4.*p1/den
3143 14664 : - 4.*p1*zeta/den2
3144 14664 : + 4.*p2/den
3145 14664 : - 4.*p2*zeta/den2
3146 14664 : + 8.*p1*p2/den2
3147 14664 : - 8.*p2*p1*zeta/den3;
3148 :
3149 14664 : case 11:
3150 14664 : return -2.*zeta/den
3151 14664 : + 4.*p2/den
3152 14664 : - 4.*p2*zeta/den2
3153 14664 : + 4.*p3/den
3154 14664 : - 4.*p3*zeta/den2
3155 14664 : + 8.*p2*p3/den2
3156 14664 : - 8.*p3*p2*zeta/den3;
3157 :
3158 14664 : case 12:
3159 14664 : return -2.*zeta/den
3160 14664 : + 4.*p3/den
3161 14664 : - 4.*p3*zeta/den2
3162 14664 : + 4.*p4/den
3163 14664 : - 4.*p4*zeta/den2
3164 14664 : + 8.*p3*p4/den2
3165 14664 : - 8.*p4*p3*zeta/den3;
3166 :
3167 14664 : case 13:
3168 14664 : return 8.*p3*p4/den2
3169 14664 : + 8.*p2*p4/den2
3170 14664 : + 8.*p2*p3/den2
3171 14664 : + 32.*p2*p3*p4/den3
3172 14664 : + 8.*p4*p1/den2
3173 14664 : + 8.*p1*p3/den2
3174 14664 : + 32.*p3*p4*p1/den3
3175 14664 : + 8.*p1*p2/den2
3176 14664 : + 32.*p2*p1*p4/den3
3177 14664 : + 32.*p1*p2*p3/den3
3178 14664 : + 96.*p1*p2*p3*p4/den4;
3179 :
3180 0 : default:
3181 0 : libmesh_error_msg("Invalid i = " << i);
3182 : }
3183 : }
3184 :
3185 0 : default:
3186 0 : libmesh_error_msg("Invalid j = " << j);
3187 : }
3188 : }
3189 :
3190 : // G. Bedrosian, "Shape functions and integration formulas for
3191 : // three-dimensional finite element analysis", Int. J. Numerical
3192 : // Methods Engineering, vol 35, p. 95-108, 1992.
3193 762528 : case PYRAMID13:
3194 : {
3195 205608 : libmesh_assert_less (i, 13);
3196 :
3197 762528 : const Real xi = p(0);
3198 762528 : const Real eta = p(1);
3199 762528 : const Real zeta = p(2);
3200 205608 : const Real eps = 1.e-35;
3201 :
3202 : // Denominators are perturbed by epsilon to avoid
3203 : // divide-by-zero issues.
3204 : Real
3205 762528 : den = (-1. + zeta + eps),
3206 762528 : den2 = den*den,
3207 762528 : den3 = den2*den,
3208 762528 : xi2 = xi*xi,
3209 762528 : eta2 = eta*eta,
3210 762528 : zeta2 = zeta*zeta,
3211 762528 : zeta3 = zeta2*zeta;
3212 :
3213 762528 : switch (j)
3214 : {
3215 127088 : case 0: // d^2()/dxi^2
3216 : {
3217 127088 : switch(i)
3218 : {
3219 19552 : case 0:
3220 : case 1:
3221 19552 : return 0.5*(-1. + zeta + eta)/den;
3222 :
3223 19552 : case 2:
3224 : case 3:
3225 19552 : return 0.5*(-1. + zeta - eta)/den;
3226 :
3227 18452 : case 4:
3228 : case 6:
3229 : case 8:
3230 : case 9:
3231 : case 10:
3232 : case 11:
3233 : case 12:
3234 18452 : return 0.;
3235 :
3236 9776 : case 5:
3237 9776 : return (1. - eta - zeta)/den;
3238 :
3239 9776 : case 7:
3240 9776 : return (1. + eta - zeta)/den;
3241 :
3242 0 : default:
3243 0 : libmesh_error_msg("Invalid i = " << i);
3244 : }
3245 : }
3246 :
3247 127088 : case 1: // d^2()/dxideta
3248 : {
3249 127088 : switch(i)
3250 : {
3251 9776 : case 0:
3252 9776 : return 0.25*(-1. + 2.*zeta + 2.*xi + 2.*eta)/den;
3253 :
3254 9776 : case 1:
3255 9776 : return -0.25*(-1. + 2.*zeta - 2.*xi + 2.*eta)/den;
3256 :
3257 9776 : case 2:
3258 9776 : return -0.25*(1. - 2.*zeta + 2.*xi + 2.*eta)/den;
3259 :
3260 9776 : case 3:
3261 9776 : return 0.25*(1. - 2.*zeta - 2.*xi + 2.*eta)/den;
3262 :
3263 2636 : case 4:
3264 2636 : return 0.;
3265 :
3266 9776 : case 5:
3267 9776 : return -xi/den;
3268 :
3269 9776 : case 6:
3270 9776 : return eta/den;
3271 :
3272 9776 : case 7:
3273 9776 : return xi/den;
3274 :
3275 9776 : case 8:
3276 9776 : return -eta/den;
3277 :
3278 9776 : case 9:
3279 9776 : return -zeta/den;
3280 :
3281 9776 : case 10:
3282 9776 : return zeta/den;
3283 :
3284 9776 : case 11:
3285 9776 : return -zeta/den;
3286 :
3287 9776 : case 12:
3288 9776 : return zeta/den;
3289 :
3290 0 : default:
3291 0 : libmesh_error_msg("Invalid i = " << i);
3292 : }
3293 : }
3294 :
3295 :
3296 127088 : case 2: // d^2()/deta^2
3297 : {
3298 127088 : switch(i)
3299 : {
3300 19552 : case 0:
3301 : case 3:
3302 19552 : return 0.5*(-1. + zeta + xi)/den;
3303 :
3304 19552 : case 1:
3305 : case 2:
3306 19552 : return 0.5*(-1. + zeta - xi)/den;
3307 :
3308 18452 : case 4:
3309 : case 5:
3310 : case 7:
3311 : case 9:
3312 : case 10:
3313 : case 11:
3314 : case 12:
3315 18452 : return 0.;
3316 :
3317 9776 : case 6:
3318 9776 : return (1. + xi - zeta)/den;
3319 :
3320 9776 : case 8:
3321 9776 : return (1. - xi - zeta)/den;
3322 :
3323 0 : default:
3324 0 : libmesh_error_msg("Invalid i = " << i);
3325 : }
3326 : }
3327 :
3328 :
3329 127088 : case 3: // d^2()/dxidzeta
3330 : {
3331 127088 : switch(i)
3332 : {
3333 9776 : case 0:
3334 9776 : return -0.25*(-1. + 2.*zeta - zeta2 + eta + 2.*eta*xi + eta2)/den2;
3335 :
3336 9776 : case 1:
3337 9776 : return 0.25*(-1. + 2.*zeta - zeta2 + eta - 2.*eta*xi + eta2)/den2;
3338 :
3339 9776 : case 2:
3340 9776 : return 0.25*(-1. + 2.*zeta - zeta2 - eta + 2.*eta*xi + eta2)/den2;
3341 :
3342 9776 : case 3:
3343 9776 : return -0.25*(-1. + 2.*zeta - zeta2 - eta - 2.*eta*xi + eta2)/den2;
3344 :
3345 2636 : case 4:
3346 2636 : return 0.;
3347 :
3348 9776 : case 5:
3349 9776 : return eta*xi/den2;
3350 :
3351 9776 : case 6:
3352 9776 : return -0.5*(1. + zeta2 + eta2 - 2.*zeta)/den2;
3353 :
3354 9776 : case 7:
3355 9776 : return -eta*xi/den2;
3356 :
3357 9776 : case 8:
3358 9776 : return 0.5*(1. + zeta2 + eta2 - 2.*zeta)/den2;
3359 :
3360 9776 : case 9:
3361 9776 : return (-1. - zeta2 + eta + 2.*zeta)/den2;
3362 :
3363 9776 : case 10:
3364 9776 : return -(-1. - zeta2 + eta + 2.*zeta)/den2;
3365 :
3366 9776 : case 11:
3367 9776 : return (1. + zeta2 + eta - 2.*zeta)/den2;
3368 :
3369 9776 : case 12:
3370 9776 : return -(1. + zeta2 + eta - 2.*zeta)/den2;
3371 :
3372 0 : default:
3373 0 : libmesh_error_msg("Invalid i = " << i);
3374 : }
3375 : }
3376 :
3377 127088 : case 4: // d^2()/detadzeta
3378 : {
3379 127088 : switch(i)
3380 : {
3381 9776 : case 0:
3382 9776 : return -0.25*(-1. + 2.*zeta - zeta2 + xi + 2.*eta*xi + xi2)/den2;
3383 :
3384 9776 : case 1:
3385 9776 : return 0.25*(1. - 2.*zeta + zeta2 + xi + 2.*eta*xi - xi2)/den2;
3386 :
3387 9776 : case 2:
3388 9776 : return 0.25*(-1. + 2.*zeta - zeta2 - xi + 2.*eta*xi + xi2)/den2;
3389 :
3390 9776 : case 3:
3391 9776 : return -0.25*(1. - 2.*zeta + zeta2 - xi + 2.*eta*xi - xi2)/den2;
3392 :
3393 2636 : case 4:
3394 2636 : return 0.;
3395 :
3396 9776 : case 5:
3397 9776 : return 0.5*(1. + xi2 + zeta2 - 2.*zeta)/den2;
3398 :
3399 9776 : case 6:
3400 9776 : return -eta*xi/den2;
3401 :
3402 9776 : case 7:
3403 9776 : return -0.5*(1. + xi2 + zeta2 - 2.*zeta)/den2;
3404 :
3405 9776 : case 8:
3406 9776 : return eta*xi/den2;
3407 :
3408 9776 : case 9:
3409 9776 : return (-1. - zeta2 + xi + 2.*zeta)/den2;
3410 :
3411 9776 : case 10:
3412 9776 : return -(1. + zeta2 + xi - 2.*zeta)/den2;
3413 :
3414 9776 : case 11:
3415 9776 : return (1. + zeta2 + xi - 2.*zeta)/den2;
3416 :
3417 9776 : case 12:
3418 9776 : return -(-1. - zeta2 + xi + 2.*zeta)/den2;
3419 :
3420 0 : default:
3421 0 : libmesh_error_msg("Invalid i = " << i);
3422 : }
3423 : }
3424 :
3425 127088 : case 5: // d^2()/dzeta^2
3426 : {
3427 127088 : switch(i)
3428 : {
3429 9776 : case 0:
3430 9776 : return 0.5*(xi + eta + 1.)*eta*xi/den3;
3431 :
3432 9776 : case 1:
3433 9776 : return -0.5*(eta - xi + 1.)*eta*xi/den3;
3434 :
3435 9776 : case 2:
3436 9776 : return -0.5*(xi + eta - 1.)*eta*xi/den3;
3437 :
3438 9776 : case 3:
3439 9776 : return 0.5*(eta - xi - 1.)*eta*xi/den3;
3440 :
3441 2636 : case 4:
3442 2636 : return 4.;
3443 :
3444 9776 : case 5:
3445 9776 : return -(1. - 3.*zeta + 3.*zeta2 - zeta3 + eta*xi2)/den3;
3446 :
3447 9776 : case 6:
3448 9776 : return (-1. + 3.*zeta - 3.*zeta2 + zeta3 + eta2*xi)/den3;
3449 :
3450 9776 : case 7:
3451 9776 : return (-1. + 3.*zeta - 3.*zeta2 + zeta3 + eta*xi2)/den3;
3452 :
3453 9776 : case 8:
3454 9776 : return -(1. - 3.*zeta + 3.*zeta2 - zeta3 + eta2*xi)/den3;
3455 :
3456 9776 : case 9:
3457 9776 : return -2.*(-1. + 3.*zeta - 3.*zeta2 + zeta3 + eta*xi)/den3;
3458 :
3459 9776 : case 10:
3460 9776 : return 2.*(1. - 3.*zeta + 3.*zeta2 - zeta3 + eta*xi)/den3;
3461 :
3462 9776 : case 11:
3463 9776 : return -2.*(-1. + 3.*zeta - 3.*zeta2 + zeta3 + eta*xi)/den3;
3464 :
3465 9776 : case 12:
3466 9776 : return 2.*(1. - 3.*zeta + 3.*zeta2 - zeta3 + eta*xi)/den3;
3467 :
3468 0 : default:
3469 0 : libmesh_error_msg("Invalid i = " << i);
3470 : }
3471 : }
3472 :
3473 0 : default:
3474 0 : libmesh_error_msg("Invalid j = " << j);
3475 : }
3476 : }
3477 :
3478 0 : default:
3479 0 : libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
3480 : }
3481 : }
3482 :
3483 339458742 : case THIRD:
3484 : {
3485 339458742 : switch (type)
3486 : {
3487 : // quadratic Lagrange shape functions with a cubic bubble
3488 233856588 : case TET14:
3489 : {
3490 56532336 : libmesh_assert_less (i, 14);
3491 233856588 : return libMesh::detail::fe_lagrange_tet14_shape_second_deriv(i, j, p(0), p(1), p(2));
3492 : }
3493 :
3494 31940760 : case PRISM20:
3495 : {
3496 8614560 : libmesh_assert_less (i, 20);
3497 :
3498 : // Compute prism shape functions as a tensor-product
3499 : // of a triangle and an edge
3500 :
3501 31940760 : Point p2d(p(0),p(1));
3502 31940760 : Real p1d = p(2);
3503 :
3504 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
3505 : static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2, 0, 1};
3506 :
3507 31940760 : const Real mainval = FE<3,LAGRANGE>::shape_second_deriv(PRISM21, THIRD, i, j, p);
3508 :
3509 31940760 : if (i0[i] != 2)
3510 6030192 : return mainval;
3511 :
3512 2584368 : Real bubbleval = 0;
3513 :
3514 2584368 : switch (j)
3515 : {
3516 : // d^2()/dxi^2
3517 1597038 : case 0:
3518 1597038 : bubbleval =
3519 1597038 : FE<2,LAGRANGE>::shape_second_deriv(TRI7, THIRD, 6, 0, p2d)*
3520 430728 : fe_lagrange_1D_quadratic_shape(2, p1d);
3521 1597038 : break;
3522 :
3523 : // d^2()/dxideta
3524 1597038 : case 1:
3525 1597038 : bubbleval =
3526 1597038 : FE<2,LAGRANGE>::shape_second_deriv(TRI7, THIRD, 6, 1, p2d)*
3527 430728 : fe_lagrange_1D_quadratic_shape(2, p1d);
3528 1597038 : break;
3529 :
3530 : // d^2()/deta^2
3531 1597038 : case 2:
3532 1597038 : bubbleval =
3533 1597038 : FE<2,LAGRANGE>::shape_second_deriv(TRI7, THIRD, 6, 2, p2d)*
3534 430728 : fe_lagrange_1D_quadratic_shape(2, p1d);
3535 1597038 : break;
3536 :
3537 : // d^2()/dxidzeta
3538 1597038 : case 3:
3539 1597038 : bubbleval =
3540 1597038 : FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, 6, 0, p2d)*
3541 430728 : fe_lagrange_1D_quadratic_shape_deriv(2, 0, p1d);
3542 1597038 : break;
3543 :
3544 : // d^2()/detadzeta
3545 1597038 : case 4:
3546 1597038 : bubbleval =
3547 1597038 : FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, 6, 1, p2d)*
3548 430728 : fe_lagrange_1D_quadratic_shape_deriv(2, 0, p1d);
3549 1597038 : break;
3550 :
3551 : // d^2()/dzeta^2
3552 1597038 : case 5:
3553 1597038 : bubbleval =
3554 1597038 : FE<2,LAGRANGE>::shape(TRI7, THIRD, 6, p2d)*
3555 430728 : fe_lagrange_1D_quadratic_shape_second_deriv(2, 0, p1d);
3556 1597038 : break;
3557 :
3558 0 : default:
3559 0 : libmesh_error_msg("Invalid shape function derivative j = " << j);
3560 : }
3561 :
3562 9582228 : if (i < 12) // vertices
3563 4791114 : return mainval - bubbleval / 9;
3564 :
3565 4791114 : return mainval + bubbleval * (Real(4) / 9);
3566 : }
3567 :
3568 71909850 : case PRISM21:
3569 : {
3570 19456860 : libmesh_assert_less (i, 21);
3571 :
3572 : // Compute prism shape functions as a tensor-product
3573 : // of a triangle and an edge
3574 :
3575 71909850 : Point p2d(p(0),p(1));
3576 71909850 : Real p1d = p(2);
3577 :
3578 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
3579 : static const unsigned int i0[] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 2, 2, 2, 1, 1, 1, 2, 2, 2, 0, 1, 2};
3580 : static const unsigned int i1[] = {0, 1, 2, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 3, 4, 5, 6, 6, 6};
3581 :
3582 71909850 : switch (j)
3583 : {
3584 : // d^2()/dxi^2
3585 11984975 : case 0:
3586 11984975 : return (FE<2,LAGRANGE>::shape_second_deriv(TRI7, THIRD, i1[i], 0, p2d)*
3587 15227785 : fe_lagrange_1D_quadratic_shape(i0[i], p1d));
3588 :
3589 : // d^2()/dxideta
3590 11984975 : case 1:
3591 11984975 : return (FE<2,LAGRANGE>::shape_second_deriv(TRI7, THIRD, i1[i], 1, p2d)*
3592 15227785 : fe_lagrange_1D_quadratic_shape(i0[i], p1d));
3593 :
3594 : // d^2()/deta^2
3595 11984975 : case 2:
3596 11984975 : return (FE<2,LAGRANGE>::shape_second_deriv(TRI7, THIRD, i1[i], 2, p2d)*
3597 15227785 : fe_lagrange_1D_quadratic_shape(i0[i], p1d));
3598 :
3599 : // d^2()/dxidzeta
3600 11984975 : case 3:
3601 11984975 : return (FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, i1[i], 0, p2d)*
3602 20727140 : fe_lagrange_1D_quadratic_shape_deriv(i0[i], 0, p1d));
3603 :
3604 : // d^2()/detadzeta
3605 11984975 : case 4:
3606 11984975 : return (FE<2,LAGRANGE>::shape_deriv(TRI7, THIRD, i1[i], 1, p2d)*
3607 20727140 : fe_lagrange_1D_quadratic_shape_deriv(i0[i], 0, p1d));
3608 :
3609 : // d^2()/dzeta^2
3610 11984975 : case 5:
3611 11984975 : return (FE<2,LAGRANGE>::shape(TRI7, THIRD, i1[i], p2d)*
3612 14769440 : fe_lagrange_1D_quadratic_shape_second_deriv(i0[i], 0, p1d));
3613 :
3614 0 : default:
3615 0 : libmesh_error_msg("Invalid shape function derivative j = " << j);
3616 : }
3617 : }
3618 :
3619 1751544 : case PYRAMID18:
3620 : {
3621 1751544 : return fe_fdm_second_deriv(type, order, elem, i, j, p,
3622 1751544 : fe_lagrange_3D_shape_deriv<T>);
3623 : }
3624 :
3625 0 : default:
3626 0 : libmesh_error_msg("ERROR: Unsupported 3D element type!: " << Utility::enum_to_string(type));
3627 : }
3628 : }
3629 :
3630 : // unsupported order
3631 0 : default:
3632 0 : libmesh_error_msg("ERROR: Unsupported 3D FE order!: " << order);
3633 : }
3634 :
3635 : #else // LIBMESH_DIM != 3
3636 : libmesh_ignore(type, order, elem, i, j, p);
3637 : libmesh_not_implemented();
3638 : #endif
3639 : }
3640 :
3641 : #endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
3642 :
3643 :
3644 : } // anonymous namespace
|