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/cell_tet14.h"
21 : #include "libmesh/fe_reference_element_traits.h"
22 : #include "libmesh/edge_edge3.h"
23 : #include "libmesh/face_tri7.h"
24 : #include "libmesh/enum_io_package.h"
25 : #include "libmesh/enum_order.h"
26 :
27 : #ifdef LIBMESH_ENABLE_AMR
28 : namespace {
29 : constexpr libMesh::Real r18 = 18;
30 : constexpr libMesh::Real r64 = 64;
31 : constexpr libMesh::Real r72 = 72;
32 : }
33 : #endif
34 :
35 : namespace libMesh
36 : {
37 :
38 :
39 :
40 : // ------------------------------------------------------------
41 : // Tet14 class static member initializations
42 : const int Tet14::num_nodes;
43 : const int Tet14::nodes_per_side;
44 : const int Tet14::nodes_per_edge;
45 :
46 : const ReferenceElementTable<Tet14::num_sides, Tet14::nodes_per_side>
47 : Tet14::side_nodes_map = build_side_nodes<Tet14::num_sides, Tet14::nodes_per_side>(TET14);
48 :
49 : const ReferenceElementTable<Tet14::num_edges, Tet14::nodes_per_edge>
50 : Tet14::edge_nodes_map = tet_edge_nodes();
51 :
52 : // ------------------------------------------------------------
53 : // Tet14 class member functions
54 :
55 17179937 : bool Tet14::is_vertex(const unsigned int i) const
56 : {
57 17179937 : if (i < 4)
58 4868763 : return true;
59 3239568 : return false;
60 : }
61 :
62 46080 : bool Tet14::is_edge(const unsigned int i) const
63 : {
64 46080 : if (i < 4 || i > 9)
65 18432 : return false;
66 6912 : return true;
67 : }
68 :
69 2785038 : bool Tet14::is_face(const unsigned int i) const
70 : {
71 2785038 : if (i > 9)
72 543948 : return true;
73 561910 : return false;
74 : }
75 :
76 1292612 : bool Tet14::is_node_on_side(const unsigned int n,
77 : const unsigned int s) const
78 : {
79 325453 : libmesh_assert_less (s, n_sides());
80 325453 : return std::find(std::begin(side_nodes_map[s]),
81 325453 : std::end(side_nodes_map[s]),
82 1292612 : n) != std::end(side_nodes_map[s]);
83 : }
84 :
85 : std::vector<unsigned>
86 28282914 : Tet14::nodes_on_side(const unsigned int s) const
87 : {
88 6501714 : libmesh_assert_less(s, n_sides());
89 28282914 : return {std::begin(side_nodes_map[s]), std::end(side_nodes_map[s])};
90 : }
91 :
92 : std::vector<unsigned>
93 32298 : Tet14::nodes_on_edge(const unsigned int e) const
94 : {
95 8076 : libmesh_assert_less(e, n_edges());
96 32298 : return {std::begin(edge_nodes_map[e]), std::end(edge_nodes_map[e])};
97 : }
98 :
99 257916 : bool Tet14::is_node_on_edge(const unsigned int n,
100 : const unsigned int e) const
101 : {
102 68640 : libmesh_assert_less (e, n_edges());
103 68640 : return std::find(std::begin(edge_nodes_map[e]),
104 68640 : std::end(edge_nodes_map[e]),
105 257916 : n) != std::end(edge_nodes_map[e]);
106 : }
107 :
108 :
109 : #ifdef LIBMESH_ENABLE_AMR
110 :
111 : // This function only works if LIBMESH_ENABLE_AMR...
112 756672 : bool Tet14::is_child_on_side(const unsigned int c,
113 : const unsigned int s) const
114 : {
115 : // Table of local IDs for the midege nodes on the side opposite a given node.
116 : // See the ASCII art in the header file for this class to confirm this.
117 756672 : const unsigned int midedge_nodes_opposite[4][3] =
118 : {
119 : {5,8,9}, // midedge nodes opposite node 0
120 : {6,7,9}, // midedge nodes opposite node 1
121 : {4,7,8}, // midedge nodes opposite node 2
122 : {4,5,6} // midedge nodes opposite node 3
123 : };
124 :
125 : // Call the base class helper function
126 1209216 : return Tet::is_child_on_side_helper(c, s, midedge_nodes_opposite);
127 : }
128 :
129 : #else
130 :
131 : bool Tet14::is_child_on_side(const unsigned int /*c*/,
132 : const unsigned int /*s*/) const
133 : {
134 : libmesh_not_implemented();
135 : return false;
136 : }
137 :
138 : #endif //LIBMESH_ENABLE_AMR
139 :
140 :
141 :
142 5469915 : bool Tet14::has_affine_map() const
143 : {
144 : // Make sure edges are straight
145 2735906 : Point v10 = this->point(1) - this->point(0);
146 6837870 : if (!v10.relative_fuzzy_equals
147 5469915 : ((this->point(4) - this->point(0))*2))
148 1166 : return false;
149 2733574 : Point v21 = this->point(2) - this->point(1);
150 6832071 : if (!v21.relative_fuzzy_equals
151 5465282 : ((this->point(5) - this->point(1))*2))
152 0 : return false;
153 2733574 : Point v20 = this->point(2) - this->point(0);
154 6832071 : if (!v20.relative_fuzzy_equals
155 5465282 : ((this->point(6) - this->point(0))*2))
156 0 : return false;
157 2733574 : Point v30 = this->point(3) - this->point(0);
158 6832071 : if (!v30.relative_fuzzy_equals
159 5465282 : ((this->point(7) - this->point(0))*2))
160 0 : return false;
161 2733574 : Point v31 = this->point(3) - this->point(1);
162 6832071 : if (!v31.relative_fuzzy_equals
163 5465282 : ((this->point(8) - this->point(1))*2))
164 0 : return false;
165 2733574 : Point v32 = this->point(3) - this->point(2);
166 6832071 : if (!v32.relative_fuzzy_equals
167 5465282 : ((this->point(9) - this->point(2))*2))
168 0 : return false;
169 :
170 : // Make sure midface nodes are midface
171 5465282 : if (!(v20+v10).relative_fuzzy_equals
172 5465282 : ((this->point(10) - this->point(0))*3))
173 0 : return false;
174 5465282 : if (!(v30+v10).relative_fuzzy_equals
175 5465282 : ((this->point(11) - this->point(0))*3))
176 0 : return false;
177 5465282 : if (!(v31+v21).relative_fuzzy_equals
178 5465282 : ((this->point(12) - this->point(1))*3))
179 0 : return false;
180 5465282 : if (!(v30+v20).relative_fuzzy_equals
181 5465282 : ((this->point(13) - this->point(0))*3))
182 0 : return false;
183 :
184 1366789 : return true;
185 : }
186 :
187 :
188 :
189 24432855 : Order Tet14::default_order() const
190 : {
191 24432855 : return THIRD;
192 : }
193 :
194 :
195 :
196 27622156 : unsigned int Tet14::local_side_node(unsigned int side,
197 : unsigned int side_node) const
198 : {
199 6843984 : libmesh_assert_less (side, this->n_sides());
200 6843984 : libmesh_assert_less (side_node, Tet14::nodes_per_side);
201 :
202 27622156 : return Tet14::side_nodes_map[side][side_node];
203 : }
204 :
205 :
206 :
207 13016464 : unsigned int Tet14::local_edge_node(unsigned int edge,
208 : unsigned int edge_node) const
209 : {
210 2244276 : libmesh_assert_less (edge, this->n_edges());
211 2244276 : libmesh_assert_less (edge_node, Tet14::nodes_per_edge);
212 :
213 13016464 : return Tet14::edge_nodes_map[edge][edge_node];
214 : }
215 :
216 :
217 :
218 5264454 : std::unique_ptr<Elem> Tet14::build_side_ptr (const unsigned int i)
219 : {
220 5264454 : return this->simple_build_side_ptr<Tri7, Tet14>(i);
221 : }
222 :
223 :
224 :
225 1390996 : void Tet14::build_side_ptr (std::unique_ptr<Elem> & side,
226 : const unsigned int i)
227 : {
228 1390996 : this->simple_build_side_ptr<Tet14>(side, i, TRI7);
229 1390996 : }
230 :
231 :
232 :
233 2280102 : std::unique_ptr<Elem> Tet14::build_edge_ptr (const unsigned int i)
234 : {
235 2280102 : return this->simple_build_edge_ptr<Edge3,Tet14>(i);
236 : }
237 :
238 :
239 :
240 0 : void Tet14::build_edge_ptr (std::unique_ptr<Elem> & edge, const unsigned int i)
241 : {
242 0 : this->simple_build_edge_ptr<Tet14>(edge, i, EDGE3);
243 0 : }
244 :
245 :
246 :
247 0 : void Tet14::connectivity(const unsigned int sc,
248 : const IOPackage iop,
249 : std::vector<dof_id_type> & conn) const
250 : {
251 0 : libmesh_assert(_nodes);
252 0 : libmesh_assert_less (sc, this->n_sub_elem());
253 0 : libmesh_assert_not_equal_to (iop, INVALID_IO_PACKAGE);
254 :
255 0 : switch (iop)
256 : {
257 0 : case TECPLOT:
258 : {
259 0 : conn.resize(8);
260 0 : switch (sc)
261 : {
262 :
263 :
264 : // Linear sub-tet 0
265 0 : case 0:
266 :
267 0 : conn[0] = this->node_id(0)+1;
268 0 : conn[1] = this->node_id(4)+1;
269 0 : conn[2] = this->node_id(6)+1;
270 0 : conn[3] = this->node_id(6)+1;
271 0 : conn[4] = this->node_id(7)+1;
272 0 : conn[5] = this->node_id(7)+1;
273 0 : conn[6] = this->node_id(7)+1;
274 0 : conn[7] = this->node_id(7)+1;
275 :
276 0 : return;
277 :
278 : // Linear sub-tet 1
279 0 : case 1:
280 :
281 0 : conn[0] = this->node_id(4)+1;
282 0 : conn[1] = this->node_id(1)+1;
283 0 : conn[2] = this->node_id(5)+1;
284 0 : conn[3] = this->node_id(5)+1;
285 0 : conn[4] = this->node_id(8)+1;
286 0 : conn[5] = this->node_id(8)+1;
287 0 : conn[6] = this->node_id(8)+1;
288 0 : conn[7] = this->node_id(8)+1;
289 :
290 0 : return;
291 :
292 : // Linear sub-tet 2
293 0 : case 2:
294 :
295 0 : conn[0] = this->node_id(5)+1;
296 0 : conn[1] = this->node_id(2)+1;
297 0 : conn[2] = this->node_id(6)+1;
298 0 : conn[3] = this->node_id(6)+1;
299 0 : conn[4] = this->node_id(9)+1;
300 0 : conn[5] = this->node_id(9)+1;
301 0 : conn[6] = this->node_id(9)+1;
302 0 : conn[7] = this->node_id(9)+1;
303 :
304 0 : return;
305 :
306 : // Linear sub-tet 3
307 0 : case 3:
308 :
309 0 : conn[0] = this->node_id(7)+1;
310 0 : conn[1] = this->node_id(8)+1;
311 0 : conn[2] = this->node_id(9)+1;
312 0 : conn[3] = this->node_id(9)+1;
313 0 : conn[4] = this->node_id(3)+1;
314 0 : conn[5] = this->node_id(3)+1;
315 0 : conn[6] = this->node_id(3)+1;
316 0 : conn[7] = this->node_id(3)+1;
317 :
318 0 : return;
319 :
320 : // Linear sub-tet 4
321 0 : case 4:
322 :
323 0 : conn[0] = this->node_id(4)+1;
324 0 : conn[1] = this->node_id(8)+1;
325 0 : conn[2] = this->node_id(6)+1;
326 0 : conn[3] = this->node_id(6)+1;
327 0 : conn[4] = this->node_id(7)+1;
328 0 : conn[5] = this->node_id(7)+1;
329 0 : conn[6] = this->node_id(7)+1;
330 0 : conn[7] = this->node_id(7)+1;
331 :
332 0 : return;
333 :
334 : // Linear sub-tet 5
335 0 : case 5:
336 :
337 0 : conn[0] = this->node_id(4)+1;
338 0 : conn[1] = this->node_id(5)+1;
339 0 : conn[2] = this->node_id(6)+1;
340 0 : conn[3] = this->node_id(6)+1;
341 0 : conn[4] = this->node_id(8)+1;
342 0 : conn[5] = this->node_id(8)+1;
343 0 : conn[6] = this->node_id(8)+1;
344 0 : conn[7] = this->node_id(8)+1;
345 :
346 0 : return;
347 :
348 : // Linear sub-tet 6
349 0 : case 6:
350 :
351 0 : conn[0] = this->node_id(5)+1;
352 0 : conn[1] = this->node_id(9)+1;
353 0 : conn[2] = this->node_id(6)+1;
354 0 : conn[3] = this->node_id(6)+1;
355 0 : conn[4] = this->node_id(8)+1;
356 0 : conn[5] = this->node_id(8)+1;
357 0 : conn[6] = this->node_id(8)+1;
358 0 : conn[7] = this->node_id(8)+1;
359 :
360 0 : return;
361 :
362 : // Linear sub-tet 7
363 0 : case 7:
364 :
365 0 : conn[0] = this->node_id(7)+1;
366 0 : conn[1] = this->node_id(6)+1;
367 0 : conn[2] = this->node_id(9)+1;
368 0 : conn[3] = this->node_id(9)+1;
369 0 : conn[4] = this->node_id(8)+1;
370 0 : conn[5] = this->node_id(8)+1;
371 0 : conn[6] = this->node_id(8)+1;
372 0 : conn[7] = this->node_id(8)+1;
373 :
374 0 : return;
375 :
376 :
377 0 : default:
378 0 : libmesh_error_msg("Invalid sc = " << sc);
379 : }
380 : }
381 :
382 0 : case VTK:
383 : {
384 : // VTK has vtkHigherOrderTetra which might have the same
385 : // connectivity as our Tet14, but this has not been tested
386 : // yet.
387 : libmesh_experimental();
388 0 : conn.resize(Tet14::num_nodes);
389 0 : for (auto i : index_range(conn))
390 0 : conn[i] = this->node_id(i);
391 0 : return;
392 : }
393 :
394 0 : default:
395 0 : libmesh_error_msg("Unsupported IO package " << iop);
396 : }
397 : }
398 :
399 :
400 :
401 2228240 : unsigned int Tet14::n_second_order_adjacent_vertices (const unsigned int n) const
402 : {
403 2228240 : switch (n)
404 : {
405 358944 : case 4:
406 : case 5:
407 : case 6:
408 : case 7:
409 : case 8:
410 : case 9:
411 358944 : return 2;
412 :
413 891296 : case 10:
414 : case 11:
415 : case 12:
416 : case 13:
417 891296 : return 3;
418 :
419 0 : default:
420 0 : libmesh_error_msg("Invalid n = " << n);
421 : }
422 : }
423 :
424 :
425 :
426 :
427 : const unsigned short int Tet14::_second_order_vertex_child_number[14] =
428 : {
429 : 99,99,99,99, // Vertices
430 : 0,1,0,0,1,2, // Edges
431 : 5,4,6,7 // Faces
432 : };
433 :
434 :
435 :
436 : const unsigned short int Tet14::_second_order_vertex_child_index[14] =
437 : {
438 : 99,99,99,99, // Vertices
439 : 1,2,2,3,3,3, // Edges
440 : 10,13,12,13 // Faces
441 : };
442 :
443 :
444 :
445 : std::pair<unsigned short int, unsigned short int>
446 0 : Tet14::second_order_child_vertex (const unsigned int n) const
447 : {
448 0 : libmesh_assert_greater_equal (n, this->n_vertices());
449 0 : libmesh_assert_less (n, this->n_nodes());
450 0 : return std::pair<unsigned short int, unsigned short int>
451 0 : (_second_order_vertex_child_number[n],
452 0 : _second_order_vertex_child_index[n]);
453 : }
454 :
455 :
456 :
457 5347776 : unsigned short int Tet14::second_order_adjacent_vertex (const unsigned int n,
458 : const unsigned int v) const
459 : {
460 1435776 : libmesh_assert_greater_equal (n, this->n_vertices());
461 1435776 : libmesh_assert_less (n, this->n_nodes());
462 1435776 : libmesh_assert_less (v, 3);
463 1435776 : libmesh_assert (n > 9 || v < 2); // Only face nodes have multiple adjacencies
464 5347776 : return _second_order_adjacent_vertices[n-this->n_vertices()][v];
465 : }
466 :
467 :
468 :
469 : const unsigned short int Tet14::_second_order_adjacent_vertices[10][3] =
470 : {
471 : {0, 1, 99}, // vertices adjacent to node 4
472 : {1, 2, 99}, // vertices adjacent to node 5
473 : {0, 2, 99}, // vertices adjacent to node 6
474 : {0, 3, 99}, // vertices adjacent to node 7
475 : {1, 3, 99}, // vertices adjacent to node 8
476 : {2, 3, 99}, // vertices adjacent to node 9
477 : {0, 1, 2}, // vertices adjacent to node 10
478 : {0, 1, 3}, // vertices adjacent to node 11
479 : {1, 2, 3}, // vertices adjacent to node 12
480 : {0, 2, 3}, // vertices adjacent to node 13
481 : };
482 :
483 :
484 :
485 :
486 :
487 : #ifdef LIBMESH_ENABLE_AMR
488 :
489 : const Real Tet14::_embedding_matrix[Tet14::num_children][Tet14::num_nodes][Tet14::num_nodes] =
490 : {
491 : // embedding matrix for child 0
492 : {
493 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13
494 : { 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, // 0
495 : { 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, // 1
496 : { 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.}, // 2
497 : { 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.}, // 3
498 : { 0.375,-0.125, 0., 0., 0.75, 0., 0., 0., 0., 0., 0., 0., 0., 0.}, // 4
499 : {.09375,-.03125,-.03125, 0., 0.125,-0.125, 0.125, 0., 0., 0.,.84375, 0., 0., 0.}, // 5
500 : { 0.375, 0.,-0.125, 0., 0., 0., 0.75, 0., 0., 0., 0., 0., 0., 0.}, // 6
501 : { 0.375, 0., 0.,-0.125, 0., 0., 0., 0.75, 0., 0., 0., 0., 0., 0.}, // 7
502 : {.09375,-.03125, 0.,-.03125,0.125, 0., 0., 0.125,-0.125, 0., 0.,.84375, 0., 0.}, // 8
503 : {.09375, 0.,-.03125,-.03125, 0., 0., 0.125, 0.125, 0.,-0.125, 0., 0., 0.,.84375}, // 9
504 : { 5/r18,-1/r18,-1/r18, 0., 4/r18,-2/r18, 4/r18, 0., 0., 0., 0.5, 0., 0., 0.}, // 10
505 : { 5/r18,-1/r18, 0.,-1/r18, 4/r18, 0., 0., 4/r18,-2/r18, 0., 0., 0.5, 0., 0.}, // 11
506 : { 0.125,-1/r72,-1/r72,-1/r72, 0.,-2/r18, 0., 0.,-2/r18,-2/r18, 0.375, 0.375, 0.125, 0.375}, // 12
507 : { 5/r18, 0.,-1/r18,-1/r18, 0., 0., 4/r18, 4/r18, 0.,-2/r18, 0., 0., 0., 0.5} // 13
508 : },
509 :
510 : // embedding matrix for child 1?
511 : {
512 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13
513 : { 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, // 0
514 : { 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, // 1
515 : { 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.}, // 2
516 : { 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.}, // 3
517 : {-0.125, 0.375, 0., 0., 0.75, 0., 0., 0., 0., 0., 0., 0., 0., 0.}, // 4
518 : { 0., 0.375,-0.125, 0., 0., 0.75, 0., 0., 0., 0., 0., 0., 0., 0.}, // 5
519 : {-.03125,.09375,-.03125, 0., 0.125, 0.125,-0.125, 0., 0., 0.,.84375, 0., 0., 0.}, // 6
520 : {-.03125,.09375, 0.,-.03125,0.125, 0., 0.,-0.125, 0.125, 0., 0.,.84375, 0., 0.}, // 7
521 : { 0., 0.375, 0.,-0.125, 0., 0., 0., 0., 0.75, 0., 0., 0., 0., 0.}, // 8
522 : { 0.,.09375,-0.03125,-0.03125,0., 0.125, 0., 0., 0.125,-0.125, 0., 0.,.84375, 0.}, // 9
523 : {-1/r18, 5/r18,-1/r18, 0., 4/r18, 4/r18,-2/r18, 0., 0., 0., 0.5, 0., 0., 0.}, // 10
524 : {-1/r18, 5/r18, 0.,-1/r18, 4/r18, 0., 0.,-2/r18, 4/r18, 0., 0., 0.5, 0., 0.}, // 11
525 : { 0., 5/r18,-1/r18,-1/r18, 0., 4/r18, 0., 0., 4/r18,-2/r18, 0., 0., 0.5, 0.}, // 12
526 : {-1/r72, 0.125,-1/r72,-1/r72, 0., 0.,-2/r18,-2/r18, 0.,-2/r18, 0.375, 0.375, 0.375, 0.125} // 13
527 : },
528 :
529 : // embedding matrix for child 2
530 : {
531 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13
532 : { 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.}, // 0
533 : { 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.}, // 1
534 : { 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, // 2
535 : { 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.}, // 3
536 : {-.03125,-.03125,.09375, 0.,-0.125, 0.125, 0.125, 0., 0., 0.,.84375, 0., 0., 0.}, // 4
537 : { 0.,-0.125, 0.375, 0., 0., 0.75, 0., 0., 0., 0., 0., 0., 0., 0.}, // 5
538 : {-0.125, 0., 0.375, 0., 0., 0., 0.75, 0., 0., 0., 0., 0., 0., 0.}, // 6
539 : {-.03125, 0.,.09375,-.03125, 0., 0., 0.125,-0.125, 0., 0.125, 0., 0., 0.,.84375}, // 7
540 : { 0.,-.03125,.09375,-.03125, 0., 0.125, 0., 0.,-0.125, 0.125, 0., 0.,.84375, 0.}, // 8
541 : { 0., 0., 0.375,-0.125, 0., 0., 0., 0., 0., 0.75, 0., 0., 0., 0.}, // 9
542 : {-1/r18,-1/r18, 5/r18, 0.,-2/r18, 4/r18, 4/r18, 0., 0., 0., 0.5, 0., 0., 0.}, // 10
543 : {-1/r72,-1/r72, 0.125,-1/r72,-2/r18, 0., 0.,-2/r18,-2/r18, 0., 0.375, 0.125, 0.375, 0.375}, // 11
544 : { 0.,-1/r18, 5/r18,-1/r18, 0., 4/r18, 0., 0.,-2/r18, 4/r18, 0., 0., 0.5, 0.}, // 12
545 : {-1/r18, 0., 5/r18,-1/r18, 0., 0., 4/r18,-2/r18, 0., 4/r18, 0., 0., 0., 0.5} // 13
546 : },
547 :
548 : // embedding matrix for child 3
549 : {
550 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13
551 : { 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.}, // 0
552 : { 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.}, // 1
553 : { 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.}, // 2
554 : { 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, // 3
555 : {-.03125,-.03125, 0.,.09375,-0.125, 0., 0., 0.125, 0.125, 0., 0.,.84375, 0., 0.}, // 4
556 : { 0.,-.03125,-.03125,.09375, 0.,-0.125, 0., 0., 0.125, 0.125, 0., 0.,.84375, 0.}, // 5
557 : {-.03125, 0.,-.03125,.09375, 0., 0.,-0.125, 0.125, 0., 0.125, 0., 0., 0.,.84375}, // 6
558 : {-0.125, 0., 0., 0.375, 0., 0., 0., 0.75, 0., 0., 0., 0., 0., 0.}, // 7
559 : { 0.,-0.125, 0., 0.375, 0., 0., 0., 0., 0.75, 0., 0., 0., 0., 0.}, // 8
560 : { 0., 0.,-0.125, 0.375, 0., 0., 0., 0., 0., 0.75, 0., 0., 0., 0.}, // 9
561 : {-1/r72,-1/r72,-1/r72, 0.125,-2/r18,-2/r18,-2/r18, 0., 0., 0., 0.125, 0.375, 0.375, 0.375}, // 10
562 : {-1/r18,-1/r18, 0., 5/r18,-2/r18, 0., 0., 4/r18, 4/r18, 0., 0., 0.5, 0., 0.}, // 11
563 : { 0.,-1/r18,-1/r18, 5/r18, 0.,-2/r18, 0., 0., 4/r18, 4/r18, 0., 0., 0.5, 0.}, // 12
564 : {-1/r18, 0.,-1/r18, 5/r18, 0., 0.,-2/r18, 4/r18, 0., 4/r18, 0., 0., 0., 0.5} // 13
565 : },
566 :
567 : // embedding matrix for child 4
568 : {
569 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13
570 : { 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, // 0
571 : { 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.}, // 1
572 : { 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.}, // 2
573 : { 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.}, // 3
574 : {-.03125,.09375, 0.,-.03125,0.125, 0., 0.,-0.125, 0.125, 0., 0.,.84375, 0., 0.}, // 4
575 : { 1/r64, 1/r64, 1/r64, 1/r64,-0.125,-0.125,-0.125,-0.125,-0.125,-0.125,27/r64,27/r64,27/r64,27/r64}, // 5
576 : {.09375,-.03125,-.03125, 0., 0.125,-0.125, 0.125, 0., 0., 0.,.84375, 0., 0., 0.}, // 6
577 : {.09375,-.03125, 0.,-.03125,0.125, 0., 0., 0.125,-0.125, 0., 0.,.84375, 0., 0.}, // 7
578 : {-.03125,-.03125, 0.,.09375,-0.125, 0., 0., 0.125, 0.125, 0., 0.,.84375, 0., 0.}, // 8
579 : {.09375, 0.,-.03125,-.03125, 0., 0., 0.125, 0.125, 0.,-0.125, 0., 0., 0.,.84375}, // 9
580 : { 2/r72, 2/r72, 0., 0., 0.,-2/r18,-2/r18,-2/r18,-2/r18,-2/r18, 0.5, 0.5, 0.25, 0.25}, // 10
581 : { 0., 0, 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0.}, // 11
582 : { 2/r72, 0., 0., 2/r72,-2/r18,-2/r18,-2/r18, 0.,-2/r18,-2/r18, 0.25, 0.5, 0.25, 0.5}, // 12
583 : { 0.125,-1/r72,-1/r72,-1/r72, 0.,-2/r18, 0., 0.,-2/r18,-2/r18, 0.375, 0.375, 0.125, 0.375} // 13
584 : },
585 :
586 : // embedding matrix for child 5?
587 : {
588 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13
589 : { 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, // 0
590 : { 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.}, // 1
591 : { 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.}, // 2
592 : { 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.}, // 3
593 : {-.03125,.09375,-.03125, 0., 0.125, 0.125,-0.125, 0., 0., 0.,.84375, 0., 0., 0.}, // 4
594 : {-.03125,-.03125,.09375, 0.,-0.125, 0.125, 0.125, 0., 0., 0.,.84375, 0., 0., 0.}, // 5
595 : {.09375,-.03125,-.03125, 0., 0.125,-0.125, 0.125, 0., 0., 0.,.84375, 0., 0., 0.}, // 6
596 : {-.03125,.09375, 0.,-.03125,0.125, 0., 0.,-0.125, 0.125, 0., 0.,.84375, 0., 0.}, // 7
597 : { 0.,.09375,-.03125,-.03125, 0., 0.125, 0., 0., 0.125,-0.125, 0., 0.,.84375, 0.}, // 8
598 : { 1/r64, 1/r64, 1/r64, 1/r64,-0.125,-0.125,-0.125,-0.125,-0.125,-0.125,27/r64,27/r64,27/r64,27/r64}, // 9
599 : { 0., 0, 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.}, // 10
600 : {-1/r72, 0.125,-1/r72,-1/r72, 0., 0.,-2/r18,-2/r18, 0.,-2/r18, 0.375, 0.375, 0.375, 0.125}, // 11
601 : { 0., 2/r72, 2/r72, 0.,-2/r18, 0.,-2/r18,-2/r18,-2/r18,-2/r18, 0.5, 0.25, 0.5, 0.25}, // 12
602 : { 2/r72, 2/r72, 0., 0., 0.,-2/r18,-2/r18,-2/r18,-2/r18,-2/r18, 0.5, 0.5, 0.25, 0.25} // 13
603 : },
604 :
605 : // embedding matrix for child 6?
606 : {
607 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13
608 : { 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.}, // 0
609 : { 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.}, // 1
610 : { 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.}, // 2
611 : { 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.}, // 3
612 : {-.03125,-.03125,.09375, 0.,-0.125, 0.125, 0.125, 0., 0., 0.,.84375, 0., 0., 0.}, // 4
613 : { 0.,-.03125,.09375,-.03125, 0., 0.125, 0., 0.,-0.125, 0.125, 0., 0.,.84375, 0.}, // 5
614 : {-.03125, 0.,.09375,-.03125, 0., 0., 0.125,-0.125, 0., 0.125, 0., 0., 0.,.84375}, // 6
615 : { 1/r64, 1/r64, 1/r64, 1/r64,-0.125,-0.125,-0.125,-0.125,-0.125,-0.125,27/r64,27/r64,27/r64,27/r64}, // 7
616 : { 0.,.09375,-.03125,-.03125, 0., 0.125, 0., 0., 0.125,-0.125, 0., 0.,.84375, 0.}, // 8
617 : { 0.,-.03125,-.03125,.09375, 0.,-0.125, 0., 0., 0.125, 0.125, 0., 0.,.84375, 0.}, // 9
618 : {-1/r72,-1/r72, 0.125,-1/r72,-2/r18, 0., 0.,-2/r18,-2/r18, 0., 0.375, 0.125, 0.375, 0.375}, // 10
619 : { 0., 2/r72, 2/r72, 0.,-2/r18, 0.,-2/r18,-2/r18,-2/r18,-2/r18, 0.5, 0.25, 0.5, 0.25}, // 11
620 : { 0., 0, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.}, // 12
621 : { 0., 0., 2/r72, 2/r72,-2/r18,-2/r18,-2/r18,-2/r18,-2/r18, 0., 0.25, 0.25, 0.5, 0.5} // 13
622 : },
623 :
624 : // embedding matrix for child 7?
625 : {
626 : // 0 1 2 3 4 5 6 7 8 9 10 11 12 13
627 : { 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.}, // 0
628 : { 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.}, // 1
629 : { 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.}, // 2
630 : { 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.}, // 3
631 : { 1/r64, 1/r64, 1/r64, 1/r64,-0.125,-0.125,-0.125,-0.125,-0.125,-0.125,27/r64,27/r64,27/r64,27/r64}, // 4
632 : { 0.,-.03125,-.03125,.09375, 0.,-0.125, 0., 0., 0.125, 0.125, 0., 0.,.84375, 0.}, // 5
633 : {-.03125, 0.,.09375,-.03125, 0., 0., 0.125,-0.125, 0., 0.125, 0., 0., 0.,.84375}, // 6
634 : {.09375, 0.,-.03125,-.03125, 0., 0., 0.125, 0.125, 0.,-0.125, 0., 0., 0.,.84375}, // 7
635 : {-.03125,-.03125, 0.,.09375,-0.125, 0., 0., 0.125, 0.125, 0., 0.,.84375, 0., 0.}, // 8
636 : {-.03125, 0.,-.03125,.09375, 0., 0.,-0.125, 0.125, 0., 0.125, 0., 0., 0.,.84375}, // 9
637 : { 0., 0., 2/r72, 2/r72,-2/r18,-2/r18,-2/r18,-2/r18,-2/r18, 0., 0.25, 0.25, 0.5, 0.5}, // 10
638 : { 2/r72, 0., 0., 2/r72,-2/r18,-2/r18,-2/r18, 0.,-2/r18,-2/r18, 0.25, 0.5, 0.25, 0.5}, // 11
639 : {-1/r72,-1/r72,-1/r72, 0.125,-2/r18,-2/r18,-2/r18, 0., 0., 0., 0.125, 0.375, 0.375, 0.375}, // 12
640 : { 0., 0, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.}, // 13
641 : }
642 : };
643 :
644 :
645 :
646 5867161 : Real Tet14::embedding_matrix (const unsigned int i,
647 : const unsigned int j,
648 : const unsigned int k) const
649 : {
650 : // Choose an optimal diagonal, if one has not already been selected
651 5867161 : this->choose_diagonal();
652 :
653 : // Permuted j and k indices
654 : unsigned int
655 2039726 : jp=j,
656 2039726 : kp=k;
657 :
658 5867161 : if ((i>3) && (this->_diagonal_selection!=DIAG_02_13))
659 : {
660 : // Just the enum value cast to an unsigned int...
661 246236 : const unsigned ds = static_cast<unsigned int>(this->_diagonal_selection); // == 1 or 2
662 :
663 : // Instead of doing a lot of arithmetic, use these
664 : // straightforward arrays for the permutations. Note that 3 ->
665 : // 3 and 10 -> 10, and the first array consists of "forward"
666 : // permutations of the sets {0,1,2}, {4,5,6}, {7,8,9}, and
667 : // {11,12,13} while the second array consists of "reverse"
668 : // permutations of the same sets.
669 :
670 588226 : const unsigned int perms[2][14] =
671 : {
672 : {1, 2, 0, 3, 5, 6, 4, 8, 9, 7, 10, 12, 13, 11},
673 : {2, 0, 1, 3, 6, 4, 5, 9, 7, 8, 10, 13, 11, 12}
674 : };
675 :
676 : // Permute j
677 588226 : jp = perms[ds-1][j];
678 : // if (jp<3)
679 : // jp = (jp+ds)%3;
680 : // else if (jp>3)
681 : // jp = (jp-1+ds)%3 + 1 + 3*((jp-1)/3);
682 :
683 : // Permute k
684 588226 : kp = perms[ds-1][k];
685 : // if (kp<3)
686 : // kp = (kp+ds)%3;
687 : // else if (kp>3)
688 : // kp = (kp-1+ds)%3 + 1 + 3*((kp-1)/3);
689 : }
690 :
691 : // Debugging:
692 : // libMesh::err << "Selected diagonal " << _diagonal_selection << std::endl;
693 : // libMesh::err << "j=" << j << std::endl;
694 : // libMesh::err << "k=" << k << std::endl;
695 : // libMesh::err << "jp=" << jp << std::endl;
696 : // libMesh::err << "kp=" << kp << std::endl;
697 :
698 : // Call embedding matrix with permuted indices
699 5867161 : return this->_embedding_matrix[i][jp][kp];
700 : }
701 :
702 :
703 : const std::vector<std::pair<unsigned char, unsigned char>> &
704 1184736 : Tet14::parent_bracketing_nodes(unsigned int c,
705 : unsigned int n) const
706 : {
707 : // Choose an optimal diagonal, if one has not already been selected
708 1184736 : this->choose_diagonal();
709 :
710 : // Just the enum value cast to an unsigned int...
711 1184736 : const unsigned ds = static_cast<unsigned int>(this->_diagonal_selection);
712 :
713 1184736 : return Tet14::_parent_bracketing_nodes[ds][c][n];
714 : }
715 :
716 :
717 : const std::vector<std::pair<unsigned char, unsigned char>>
718 : Tet14::_parent_bracketing_nodes[3][Tet14::num_children][Tet14::num_nodes] =
719 : {
720 : // DIAG_02_13
721 : {
722 : // Node 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
723 : // 10, 11, 12, 13
724 : // Child 0
725 : { {},{{0,1}},{{0,2}},{{0,3}},{{0,4}},{{4,6}},{{0,6}},{{0,7}},{{4,7}},{{6,7}},{{0,10}},{{0,11}},{{0,12}},{{0,13}} },
726 : // Child 1
727 : { {{0,1}}, {},{{1,2}},{{1,3}},{{1,4}},{{1,5}},{{4,5}},{{4,8}},{{1,8}},{{5,8}},{{1,10}},{{1,11}},{{1,12}},{{1,13}} },
728 : // Child 2
729 : { {{0,2}},{{1,2}}, {},{{2,3}},{{5,6}},{{2,5}},{{2,6}},{{6,9}},{{5,9}},{{2,9}},{{2,10}},{{2,11}},{{2,12}},{{2,13}} },
730 : // Child 3
731 : { {{0,3}},{{1,3}},{{2,3}}, {},{{7,8}},{{8,9}},{{7,9}},{{3,7}},{{3,8}},{{3,9}},{{3,10}},{{3,11}},{{3,12}},{{3,13}} },
732 : // Child 4
733 : { {{0,1}},{{1,3}},{{0,2}},{{0,3}},{{4,8}},{{6,8}},{{4,6}},{{4,7}},{{7,8}},{{6,7}},
734 : {{10,11}},{{0,8},{1,7},{3,4}}, {{11,13}}, {{0,12}} },
735 : // Child 5
736 : { {{0,1}},{{1,2}},{{0,2}},{{1,3}},{{4,5}},{{5,6}},{{4,6}},{{4,8}},{{5,8}},{{6,8}},
737 : {{0,5},{1,6},{2,4}}, {{1,13}}, {{10,12}}, {{10,11}} },
738 : // Child 6
739 : { {{0,2}},{{1,2}},{{2,3}},{{1,3}},{{5,6}},{{5,9}},{{6,9}},{{6,8}},{{5,8}},{{8,9}},
740 : {{2,11}}, {{10,12}},{{1,9},{2,8},{3,5}}, {{12,13}} },
741 : // Child 7
742 : { {{0,2}},{{1,3}},{{2,3}},{{0,3}},{{6,8}},{{8,9}},{{6,9}},{{6,7}},{{7,8}},{{7,9}},
743 : {{12,13}}, {{11,13}}, {{3,10}},{{0,9},{2,7},{3,6}} }
744 : },
745 : // DIAG_03_12
746 : {
747 : // Node 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
748 : // 10, 11, 12, 13
749 : // Child 0
750 : { {},{{0,1}},{{0,2}},{{0,3}},{{0,4}},{{4,6}},{{0,6}},{{0,7}},{{4,7}},{{6,7}},{{0,10}},{{0,11}},{{0,12}},{{0,13}} },
751 : // Child 1
752 : { {{0,1}}, {},{{1,2}},{{1,3}},{{1,4}},{{1,5}},{{4,5}},{{4,8}},{{1,8}},{{5,8}},{{1,10}},{{1,11}},{{1,12}},{{1,13}} },
753 : // Child 2
754 : { {{0,2}},{{1,2}}, {},{{2,3}},{{5,6}},{{2,5}},{{2,6}},{{6,9}},{{5,9}},{{2,9}},{{2,10}},{{2,11}},{{2,12}},{{2,13}} },
755 : // Child 3
756 : { {{0,3}},{{1,3}},{{2,3}}, {},{{7,8}},{{8,9}},{{7,9}},{{3,7}},{{3,8}},{{3,9}},{{3,10}},{{3,11}},{{3,12}},{{3,13}} },
757 : // Child 4
758 : { {{0,3}},{{1,2}},{{0,2}},{{2,3}},{{5,7}},{{5,6}},{{6,7}},{{7,9}},{{5,9}},{{6,9}},
759 : {{10,13}}, {{12,13}}, {{2,11}},{{0,9},{2,7},{3,6}} },
760 : // Child 5
761 : { {{0,1}},{{1,2}},{{0,2}},{{0,3}},{{4,5}},{{5,6}},{{4,6}},{{4,7}},{{5,7}},{{6,7}},
762 : {{0,5},{1,6},{2,4}}, {{10,11}}, {{10,13}}, {{0,12}} },
763 : // Child 6
764 : { {{0,1}},{{1,3}},{{1,2}},{{0,3}},{{4,8}},{{5,8}},{{4,5}},{{4,7}},{{7,8}},{{5,7}},
765 : {{1,13}},{{0,8},{1,7},{3,4}}, {{11,12}}, {{10,11}} },
766 : // Child 7
767 : { {{0,3}},{{1,3}},{{1,2}},{{2,3}},{{7,8}},{{5,8}},{{5,7}},{{7,9}},{{8,9}},{{5,9}},
768 : {{11,12}}, {{3,10}},{{1,9},{2,8},{3,5}}, {{12,13}} }
769 : },
770 : // DIAG_01_23
771 : {
772 : // Node 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
773 : // 10, 11, 12, 13
774 : // Child 0
775 : { {},{{0,1}},{{0,2}},{{0,3}},{{0,4}},{{4,6}},{{0,6}},{{0,7}},{{4,7}},{{6,7}},{{0,10}},{{0,11}},{{0,12}},{{0,13}} },
776 : // Child 1
777 : { {{0,1}}, {},{{1,2}},{{1,3}},{{1,4}},{{1,5}},{{4,5}},{{4,8}},{{1,8}},{{5,8}},{{1,10}},{{1,11}},{{1,12}},{{1,13}} },
778 : // Child 2
779 : { {{0,2}},{{1,2}}, {},{{2,3}},{{5,6}},{{2,5}},{{2,6}},{{6,9}},{{5,9}},{{2,9}},{{2,10}},{{2,11}},{{2,12}},{{2,13}} },
780 : // Child 3
781 : { {{0,3}},{{1,3}},{{2,3}}, {},{{7,8}},{{8,9}},{{7,9}},{{3,7}},{{3,8}},{{3,9}},{{3,10}},{{3,11}},{{3,12}},{{3,13}} },
782 : // Child 4
783 : { {{0,1}},{{1,2}},{{2,3}},{{1,3}},{{4,5}},{{5,9}},{{4,9}},{{4,8}},{{5,8}},{{8,9}},
784 : {{10,12}}, {{1,13}},{{1,9},{2,8},{3,5}}, {{11,12}} },
785 : // Child 5
786 : { {{0,1}},{{1,2}},{{0,2}},{{2,3}},{{4,5}},{{5,6}},{{4,6}},{{4,9}},{{5,9}},{{6,9}},
787 : {{0,5},{1,6},{2,4}}, {{10,12}}, {{2,11}}, {{10,13}} },
788 : // Child 6
789 : { {{0,3}},{{0,1}},{{0,2}},{{2,3}},{{4,7}},{{4,6}},{{6,7}},{{7,9}},{{4,9}},{{6,9}},
790 : {{0,12}}, {{11,13}}, {{10,13}},{{0,9},{2,7},{3,6}} },
791 : // Child 7
792 : { {{0,3}},{{0,1}},{{2,3}},{{1,3}},{{4,7}},{{4,9}},{{7,9}},{{7,8}},{{4,8}},{{8,9}},
793 : {{11,13}},{{0,8},{1,7},{3,4}}, {{11,12}}, {{3,10}} }
794 : }
795 : };
796 :
797 : #endif // #ifdef LIBMESH_ENABLE_AMR
798 :
799 :
800 :
801 188928 : void Tet14::permute(unsigned int perm_num)
802 : {
803 50688 : libmesh_assert_less (perm_num, 12);
804 :
805 188928 : const unsigned int side = perm_num % 4;
806 188928 : const unsigned int rotate = perm_num / 4;
807 :
808 378745 : for (unsigned int i = 0; i != rotate; ++i)
809 : {
810 189817 : swap3nodes(0,1,2);
811 138871 : swap3nodes(4,5,6);
812 138871 : swap3nodes(7,8,9);
813 138871 : swap3nodes(11,12,13);
814 138871 : swap3neighbors(1,2,3);
815 : }
816 :
817 188928 : switch (side) {
818 13426 : case 0:
819 13426 : break;
820 44703 : case 1:
821 44703 : swap3nodes(0,2,3);
822 32729 : swap3nodes(4,5,8);
823 32729 : swap3nodes(6,9,7);
824 32729 : swap3nodes(10,12,11);
825 32729 : swap3neighbors(0,2,1);
826 32729 : break;
827 46850 : case 2:
828 46850 : swap3nodes(2,0,3);
829 34286 : swap3nodes(5,4,8);
830 34286 : swap3nodes(6,7,9);
831 34286 : swap3nodes(10,11,12);
832 34286 : swap3neighbors(0,1,2);
833 34286 : break;
834 47432 : case 3:
835 47432 : swap3nodes(2,1,3);
836 34708 : swap3nodes(5,8,9);
837 34708 : swap3nodes(6,4,7);
838 34708 : swap3nodes(10,11,13);
839 34708 : swap3neighbors(0,1,3);
840 34708 : break;
841 0 : default:
842 0 : libmesh_error();
843 : }
844 188928 : }
845 :
846 :
847 2304 : void Tet14::flip(BoundaryInfo * boundary_info)
848 : {
849 576 : libmesh_assert(boundary_info);
850 :
851 2304 : swap2nodes(0,2);
852 2304 : swap2nodes(4,5);
853 2304 : swap2nodes(7,9);
854 2304 : swap2nodes(11,12);
855 576 : swap2neighbors(1,2);
856 2304 : swap2boundarysides(1,2,boundary_info);
857 2304 : swap2boundaryedges(0,1,boundary_info);
858 2304 : swap2boundaryedges(3,5,boundary_info);
859 2304 : }
860 :
861 :
862 28131120 : ElemType Tet14::side_type (const unsigned int libmesh_dbg_var(s)) const
863 : {
864 6442976 : libmesh_assert_less (s, 4);
865 28131120 : return TRI7;
866 : }
867 :
868 :
869 : } // namespace libMesh
|
