libMesh
Loading...
Searching...
No Matches
cell_inf_prism12.C
Go to the documentation of this file.
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#include "libmesh/libmesh_config.h"
19
20#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
21
22// Local includes
23#include "libmesh/cell_inf_prism12.h"
24#include "libmesh/edge_edge3.h"
25#include "libmesh/edge_inf_edge2.h"
26#include "libmesh/face_tri6.h"
27#include "libmesh/face_inf_quad6.h"
28#include "libmesh/enum_io_package.h"
29#include "libmesh/enum_order.h"
30
31namespace libMesh
32{
33
34
35// ------------------------------------------------------------
36// InfPrism12 class static member initializations
37const int InfPrism12::num_nodes;
38const int InfPrism12::nodes_per_side;
39const int InfPrism12::nodes_per_edge;
40
41const unsigned int InfPrism12::side_nodes_map[InfPrism12::num_sides][InfPrism12::nodes_per_side] =
42 {
43 { 0, 1, 2, 6, 7, 8}, // Side 0
44 { 0, 1, 3, 4, 6, 9}, // Side 1
45 { 1, 2, 4, 5, 7, 10}, // Side 2
46 { 2, 0, 5, 3, 8, 11} // Side 3
47 };
48
49const unsigned int InfPrism12::edge_nodes_map[InfPrism12::num_edges][InfPrism12::nodes_per_edge] =
50 {
51 {0, 1, 6}, // Side 0
52 {1, 2, 7}, // Side 1
53 {0, 2, 8}, // Side 2
54 {0, 3, 99}, // Side 3
55 {1, 4, 99}, // Side 4
56 {2, 5, 99} // Side 5
57 };
58
59// ------------------------------------------------------------
60// InfPrism12 class member functions
61
62bool InfPrism12::is_node_on_side(const unsigned int n,
63 const unsigned int s) const
64{
65 libmesh_assert_less (s, n_sides());
66 return std::find(std::begin(side_nodes_map[s]),
67 std::end(side_nodes_map[s]),
68 n) != std::end(side_nodes_map[s]);
69}
70
71std::vector<unsigned>
72InfPrism12::nodes_on_side(const unsigned int s) const
73{
74 libmesh_assert_less(s, n_sides());
75 return {std::begin(side_nodes_map[s]), std::end(side_nodes_map[s])};
76}
77
78std::vector<unsigned>
79InfPrism12::nodes_on_edge(const unsigned int e) const
80{
81 libmesh_assert_less(e, n_edges());
82 auto trim = (e < 3) ? 0 : 1;
83 return {std::begin(edge_nodes_map[e]), std::end(edge_nodes_map[e]) - trim};
84}
85
86bool InfPrism12::is_node_on_edge(const unsigned int n,
87 const unsigned int e) const
88{
89 libmesh_assert_less (e, n_edges());
90 return std::find(std::begin(edge_nodes_map[e]),
91 std::end(edge_nodes_map[e]),
92 n) != std::end(edge_nodes_map[e]);
93}
94
95Order InfPrism12::default_order() const
96{
97 return SECOND;
98}
99
100unsigned int InfPrism12::local_side_node(unsigned int side,
101 unsigned int side_node) const
102{
103 libmesh_assert_less (side, this->n_sides());
104
105 // Never more than 6 nodes per side.
106 libmesh_assert_less(side_node, InfPrism12::nodes_per_side);
107
108 return InfPrism12::side_nodes_map[side][side_node];
109}
110
111
112
113unsigned int InfPrism12::local_edge_node(unsigned int edge,
114 unsigned int edge_node) const
115{
116 libmesh_assert_less (edge, this->n_edges());
117
118 // Never more than 3 nodes per edge.
119 libmesh_assert_less(edge_node, InfPrism12::nodes_per_edge);
120
121 // Some edges only have 2 nodes.
122 libmesh_assert(edge < 3 || edge_node < 2);
123
124 return InfPrism12::edge_nodes_map[edge][edge_node];
125}
126
127
128
129std::unique_ptr<Elem> InfPrism12::build_side_ptr (const unsigned int i)
130{
131 libmesh_assert_less (i, this->n_sides());
132
133 std::unique_ptr<Elem> face;
134
135 switch (i)
136 {
137 case 0: // the triangular face at z=-1, base face
138 {
139 face = std::make_unique<Tri6>();
140 break;
141 }
142
143 case 1: // the quad face at y=0
144 case 2: // the other quad face
145 case 3: // the quad face at x=0
146 {
147 face = std::make_unique<InfQuad6>();
148 break;
149 }
150
151 default:
152 libmesh_error_msg("Invalid side i = " << i);
153 }
154
155 // Set the nodes
156 for (auto n : face->node_index_range())
157 face->set_node(n, this->node_ptr(InfPrism12::side_nodes_map[i][n]));
158
159 face->set_interior_parent(this);
160 face->inherit_data_from(*this);
161
162 return face;
163}
164
165
166void InfPrism12::build_side_ptr (std::unique_ptr<Elem> & side,
167 const unsigned int i)
168{
169 libmesh_assert_less (i, this->n_sides());
170
171 switch (i)
172 {
173 case 0: // the triangular face at z=-1, base face
174 {
175 if (!side.get() || side->type() != TRI6)
176 {
177 side = this->build_side_ptr(i);
178 return;
179 }
180 break;
181 }
182
183 case 1: // the quad face at y=0
184 case 2: // the other quad face
185 case 3: // the quad face at x=0
186 {
187 if (!side.get() || side->type() != INFQUAD6)
188 {
189 side = this->build_side_ptr(i);
190 return;
191 }
192 break;
193 }
194
195 default:
196 libmesh_error_msg("Invalid side i = " << i);
197 }
198
199 side->inherit_data_from(*this);
200
201 // Set the nodes
202 for (auto n : side->node_index_range())
203 side->set_node(n, this->node_ptr(InfPrism12::side_nodes_map[i][n]));
204}
205
206
207
208std::unique_ptr<Elem> InfPrism12::build_edge_ptr (const unsigned int i)
209{
210 if (i < 3) // base edges
211 return this->simple_build_edge_ptr<Edge3,InfPrism12>(i);
212
213 // infinite edges
214 return this->simple_build_edge_ptr<InfEdge2,InfPrism12>(i);
215}
216
217
218
219void InfPrism12::build_edge_ptr (std::unique_ptr<Elem> & edge,
220 const unsigned int i)
221{
222 libmesh_assert_less (i, this->n_edges());
223
224 switch (i)
225 {
226 // the base edges
227 case 0:
228 case 1:
229 case 2:
230 {
231 if (!edge.get() || edge->type() != EDGE3)
232 {
233 edge = this->build_edge_ptr(i);
234 return;
235 }
236 break;
237 }
238
239 // the infinite edges
240 case 3:
241 case 4:
242 case 5:
243 {
244 if (!edge.get() || edge->type() != INFEDGE2)
245 {
246 edge = this->build_edge_ptr(i);
247 return;
248 }
249 break;
250 }
251
252 default:
253 libmesh_error_msg("Invalid edge i = " << i);
254 }
255
256 edge->inherit_data_from(*this);
257
258 // Set the nodes
259 for (auto n : edge->node_index_range())
260 edge->set_node(n, this->node_ptr(InfPrism12::edge_nodes_map[i][n]));
261}
262
263
264
265void InfPrism12::connectivity(const unsigned int sc,
266 const IOPackage iop,
267 std::vector<dof_id_type> & conn) const
268{
269 libmesh_assert(_nodes);
270 libmesh_assert_less (sc, this->n_sub_elem());
271 libmesh_assert_not_equal_to (iop, INVALID_IO_PACKAGE);
272
273 switch (iop)
274 {
275 case TECPLOT:
276 {
277 conn.resize(8);
278 switch (sc)
279 {
280 case 0:
281
282 // guess this is a collapsed hex8
283 conn[0] = this->node_id(0)+1;
284 conn[1] = this->node_id(6)+1;
285 conn[2] = this->node_id(8)+1;
286 conn[3] = this->node_id(8)+1;
287 conn[4] = this->node_id(3)+1;
288 conn[5] = this->node_id(9)+1;
289 conn[6] = this->node_id(11)+1;
290 conn[7] = this->node_id(11)+1;
291
292 return;
293
294 case 1:
295
296 conn[0] = this->node_id(6)+1;
297 conn[1] = this->node_id(7)+1;
298 conn[2] = this->node_id(8)+1;
299 conn[3] = this->node_id(8)+1;
300 conn[4] = this->node_id(9)+1;
301 conn[5] = this->node_id(10)+1;
302 conn[6] = this->node_id(11)+1;
303 conn[7] = this->node_id(11)+1;
304
305 return;
306
307 case 2:
308
309 conn[0] = this->node_id(6)+1;
310 conn[1] = this->node_id(1)+1;
311 conn[2] = this->node_id(7)+1;
312 conn[3] = this->node_id(7)+1;
313 conn[4] = this->node_id(9)+1;
314 conn[5] = this->node_id(4)+1;
315 conn[6] = this->node_id(10)+1;
316 conn[7] = this->node_id(10)+1;
317
318 return;
319
320 case 3:
321
322 conn[0] = this->node_id(8)+1;
323 conn[1] = this->node_id(7)+1;
324 conn[2] = this->node_id(2)+1;
325 conn[3] = this->node_id(2)+1;
326 conn[4] = this->node_id(11)+1;
327 conn[5] = this->node_id(10)+1;
328 conn[6] = this->node_id(5)+1;
329 conn[7] = this->node_id(5)+1;
330
331 return;
332
333 default:
334 libmesh_error_msg("Invalid sc = " << sc);
335 }
336 }
337
338 default:
339 libmesh_error_msg("Unsupported IO package " << iop);
340 }
341}
342
343
344
345
346
347unsigned short int InfPrism12::second_order_adjacent_vertex (const unsigned int n,
348 const unsigned int v) const
349{
350 libmesh_assert_greater_equal (n, this->n_vertices());
351 libmesh_assert_less (n, this->n_nodes());
352 libmesh_assert_less (v, 2);
353 return _second_order_adjacent_vertices[n-this->n_vertices()][v];
354}
355
356
357
358const unsigned short int InfPrism12::_second_order_adjacent_vertices[InfPrism12::num_edges][2] =
359 {
360 { 0, 1}, // vertices adjacent to node 6
361 { 1, 2}, // vertices adjacent to node 7
362 { 0, 2}, // vertices adjacent to node 8
363
364 { 3, 4}, // vertices adjacent to node 9
365 { 4, 5}, // vertices adjacent to node 10
366 { 3, 5} // vertices adjacent to node 11
367 };
368
369
370
371std::pair<unsigned short int, unsigned short int>
372InfPrism12::second_order_child_vertex (const unsigned int n) const
373{
374 libmesh_assert_greater_equal (n, this->n_vertices());
375 libmesh_assert_less (n, this->n_nodes());
376
377 return std::pair<unsigned short int, unsigned short int>
378 (_second_order_vertex_child_number[n],
379 _second_order_vertex_child_index[n]);
380}
381
382
383
384const unsigned short int InfPrism12::_second_order_vertex_child_number[InfPrism12::num_nodes] =
385 {
386 99,99,99,99,99,99, // Vertices
387 0,1,0, // Edges
388 0,1,0 // Faces
389 };
390
391
392
393const unsigned short int InfPrism12::_second_order_vertex_child_index[InfPrism12::num_nodes] =
394 {
395 99,99,99,99,99,99, // Vertices
396 1,2,2, // Edges
397 4,5,5 // Faces
398 };
399
400
401
402#ifdef LIBMESH_ENABLE_AMR
403
404const Real InfPrism12::_embedding_matrix[InfPrism12::num_children][InfPrism12::num_nodes][InfPrism12::num_nodes] =
405 {
406 // embedding matrix for child 0
407 {
408 // 0 1 2 3 4 5 6 7 8 9 10 11 th parent Node
409 { 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, // 0th child N.
410 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0}, // 1
411 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0}, // 2
412 { 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, // 3
413 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0}, // 4
414 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0}, // 5
415 { 0.375, -0.125, 0.0, 0.0, 0.0, 0.0, 0.75, 0.0, 0.0, 0.0, 0.0, 0.0}, // 6
416 { 0.0, -0.125, -0.125, 0.0, 0.0, 0.0, 0.5, 0.25, 0.5, 0.0, 0.0, 0.0}, // 7
417 { 0.375, 0.0, -0.125, 0.0, 0.0, 0.0, 0.0, 0.0, 0.75, 0.0, 0.0, 0.0}, // 8
418 { 0.0, 0.0, 0.0, 0.375, -0.125, 0.0, 0.0, 0.0, 0.0, 0.75, 0.0, 0.0}, // 9
419 { 0.0, 0.0, 0.0, 0.0, -0.125, -0.125, 0.0, 0.0, 0.0, 0.5, 0.25, 0.5}, // 10
420 { 0.0, 0.0, 0.0, 0.375, 0.0, -0.125, 0.0, 0.0, 0.0, 0.0, 0.0, 0.75} // 11
421 },
422
423 // embedding matrix for child 1
424 {
425 // 0 1 2 3 4 5 6 7 8 9 10 11 th parent Node
426 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0}, // 0th child N.
427 { 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, // 1
428 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0}, // 2
429 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0}, // 3
430 { 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, // 4
431 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0}, // 5
432 { -0.125, 0.375, 0.0, 0.0, 0.0, 0.0, 0.75, 0.0, 0.0, 0.0, 0.0, 0.0}, // 6
433 { 0.0, 0.375, -0.125, 0.0, 0.0, 0.0, 0.0, 0.75, 0.0, 0.0, 0.0, 0.0}, // 7
434 { -0.125, 0.0, -0.125, 0.0, 0.0, 0.0, 0.5, 0.5, 0.25, 0.0, 0.0, 0.0}, // 8
435 { 0.0, 0.0, 0.0, -0.125, 0.375, 0.0, 0.0, 0.0, 0.0, 0.75, 0.0, 0.0}, // 9
436 { 0.0, 0.0, 0.0, 0.0, 0.375, -0.125, 0.0, 0.0, 0.0, 0.0, 0.75, 0.0}, // 10
437 { 0.0, 0.0, 0.0, -0.125, 0.0, -0.125, 0.0, 0.0, 0.0, 0.5, 0.5, 0.25} // 11
438 },
439
440 // embedding matrix for child 2
441 {
442 // 0 1 2 3 4 5 6 7 8 9 10 11 th parent Node
443 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0}, // 0th child N.
444 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0}, // 1
445 { 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, // 2
446 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0}, // 3
447 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0}, // 4
448 { 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, // 5
449 { -0.125, -0.125, 0.0, 0.0, 0.0, 0.0, 0.25, 0.5, 0.5, 0.0, 0.0, 0.0}, // 6
450 { 0.0, -0.125, 0.375, 0.0, 0.0, 0.0, 0.0, 0.75, 0.0, 0.0, 0.0, 0.0}, // 7
451 { -0.125, 0.0, 0.375, 0.0, 0.0, 0.0, 0.0, 0.0, 0.75, 0.0, 0.0, 0.0}, // 8
452 { 0.0, 0.0, 0.0, -0.125, -0.125, 0.0, 0.0, 0.0, 0.0, 0.25, 0.5, 0.5}, // 9
453 { 0.0, 0.0, 0.0, 0.0, -0.125, 0.375, 0.0, 0.0, 0.0, 0.0, 0.75, 0.0}, // 10
454 { 0.0, 0.0, 0.0, -0.125, 0.0, 0.375, 0.0, 0.0, 0.0, 0.0, 0.0, 0.75} // 11
455 },
456
457 // embedding matrix for child 3
458 {
459 // 0 1 2 3 4 5 6 7 8 9 10 11 th parent Node
460 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0}, // 0th child N.
461 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0}, // 1
462 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0}, // 2
463 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0}, // 3
464 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0}, // 4
465 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0}, // 5
466 { -0.125, 0.0, -0.125, 0.0, 0.0, 0.0, 0.5, 0.5, 0.25, 0.0, 0.0, 0.0}, // 6
467 { -0.125, -0.125, 0.0, 0.0, 0.0, 0.0, 0.25, 0.5, 0.5, 0.0, 0.0, 0.0}, // 7
468 { 0.0, -0.125, -0.125, 0.0, 0.0, 0.0, 0.5, 0.25, 0.5, 0.0, 0.0, 0.0}, // 8
469 { 0.0, 0.0, 0.0, -0.125, 0.0, -0.125, 0.0, 0.0, 0.0, 0.5, 0.5, 0.25}, // 9
470 { 0.0, 0.0, 0.0, -0.125, -0.125, 0.0, 0.0, 0.0, 0.0, 0.25, 0.5, 0.5}, // 10
471 { 0.0, 0.0, 0.0, 0.0, -0.125, -0.125, 0.0, 0.0, 0.0, 0.5, 0.25, 0.5} // 11
472 }
473
474 };
475
476
477#endif
478
479
480void
481InfPrism12::permute(unsigned int perm_num)
482{
483 libmesh_assert_less (perm_num, 3);
484
485 for (unsigned int i = 0; i != perm_num; ++i)
486 {
487 swap3nodes(0,1,2);
488 swap3nodes(3,4,5);
489 swap3nodes(6,7,8);
490 swap3nodes(9,10,11);
491 swap3neighbors(1,2,3);
492 }
493}
494
495
496void
497InfPrism12::flip(BoundaryInfo * boundary_info)
498{
499 libmesh_assert(boundary_info);
500
501 swap2nodes(0,1);
502 swap2nodes(3,4);
503 swap2nodes(7,8);
504 swap2nodes(10,11);
505 swap2neighbors(2,3);
506 swap2boundarysides(2,3,boundary_info);
507 swap2boundaryedges(3,4,boundary_info);
508}
509
510
511ElemType
512InfPrism12::side_type (const unsigned int s) const
513{
514 libmesh_assert_less (s, 4);
515 if (s == 0)
516 return TRI6;
517 return INFQUAD6;
518}
519
520
521} // namespace libMesh
522
523#endif // ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
libMesh::BoundaryInfo
The BoundaryInfo class contains information relevant to boundary conditions including storing faces,...
Definition boundary_info.h:58
libMesh::Elem::swap2nodes
void swap2nodes(unsigned int n1, unsigned int n2)
Swaps two node_ptrs.
Definition elem.h:2101
libMesh::Elem::swap3neighbors
void swap3neighbors(unsigned int n1, unsigned int n2, unsigned int n3)
Swaps three neighbor_ptrs, "rotating" them.
Definition elem.h:2142
libMesh::Elem::_nodes
Node ** _nodes
Pointers to the nodes we are connected to.
Definition elem.h:2254
libMesh::Elem::swap2neighbors
void swap2neighbors(unsigned int n1, unsigned int n2)
Swaps two neighbor_ptrs.
Definition elem.h:2111
libMesh::Elem::swap2boundarysides
void swap2boundarysides(unsigned short s1, unsigned short s2, BoundaryInfo *boundary_info) const
Swaps two sides in boundary_info, if it is non-null.
Definition elem.C:3579
libMesh::Elem::swap3nodes
void swap3nodes(unsigned int n1, unsigned int n2, unsigned int n3)
Swaps three node_ptrs, "rotating" them.
Definition elem.h:2133
libMesh::Elem::swap2boundaryedges
void swap2boundaryedges(unsigned short e1, unsigned short e2, BoundaryInfo *boundary_info) const
Swaps two edges in boundary_info, if it is non-null.
Definition elem.C:3595
libMesh::Elem::node_id
dof_id_type node_id(const unsigned int i) const
Definition elem.h:2484
libMesh::InfPrism12::local_edge_node
virtual unsigned int local_edge_node(unsigned int edge, unsigned int edge_node) const override
Definition cell_inf_prism12.C:113
libMesh::InfPrism12::connectivity
virtual void connectivity(const unsigned int sc, const IOPackage iop, std::vector< dof_id_type > &conn) const override
Definition cell_inf_prism12.C:265
libMesh::InfPrism12::_embedding_matrix
static const Real _embedding_matrix[num_children][num_nodes][num_nodes]
Matrix that computes new nodal locations/solution values from current nodes/solution.
Definition cell_inf_prism12.h:235
libMesh::InfPrism12::side_type
ElemType side_type(const unsigned int s) const override final
Definition cell_inf_prism12.C:512
libMesh::InfPrism12::permute
virtual void permute(unsigned int perm_num) override final
Permutes the element (by swapping node and neighbor pointers) according to the specified index.
Definition cell_inf_prism12.C:481
libMesh::InfPrism12::nodes_on_edge
virtual std::vector< unsigned int > nodes_on_edge(const unsigned int e) const override
Definition cell_inf_prism12.C:79
libMesh::InfPrism12::flip
virtual void flip(BoundaryInfo *) override final
Flips the element (by swapping node and neighbor pointers) to have a mapping Jacobian of opposite sig...
Definition cell_inf_prism12.C:497
libMesh::InfPrism12::build_edge_ptr
virtual std::unique_ptr< Elem > build_edge_ptr(const unsigned int i) override
Definition cell_inf_prism12.C:208
libMesh::InfPrism12::is_node_on_edge
virtual bool is_node_on_edge(const unsigned int n, const unsigned int e) const override
Definition cell_inf_prism12.C:86
libMesh::InfPrism12::nodes_per_edge
static const int nodes_per_edge
Definition cell_inf_prism12.h:193
libMesh::InfPrism12::second_order_adjacent_vertex
virtual unsigned short int second_order_adjacent_vertex(const unsigned int n, const unsigned int v) const override
Definition cell_inf_prism12.C:347
libMesh::InfPrism12::nodes_per_side
static const int nodes_per_side
Definition cell_inf_prism12.h:192
libMesh::InfPrism12::nodes_on_side
virtual std::vector< unsigned int > nodes_on_side(const unsigned int s) const override
Definition cell_inf_prism12.C:72
libMesh::InfPrism12::_second_order_vertex_child_number
static const unsigned short int _second_order_vertex_child_number[num_nodes]
Vector that names a child sharing each second order node.
Definition cell_inf_prism12.h:253
libMesh::InfPrism12::local_side_node
virtual unsigned int local_side_node(unsigned int side, unsigned int side_node) const override
Definition cell_inf_prism12.C:100
libMesh::InfPrism12::second_order_child_vertex
virtual std::pair< unsigned short int, unsigned short int > second_order_child_vertex(const unsigned int n) const override
Definition cell_inf_prism12.C:372
libMesh::InfPrism12::num_nodes
static const int num_nodes
Geometric constants for InfPrism12.
Definition cell_inf_prism12.h:191
libMesh::InfPrism12::edge_nodes_map
static const unsigned int edge_nodes_map[num_edges][nodes_per_edge]
This maps the node of the edge to element node numbers.
Definition cell_inf_prism12.h:205
libMesh::InfPrism12::n_sub_elem
virtual unsigned int n_sub_elem() const override
Definition cell_inf_prism12.h:92
libMesh::InfPrism12::n_nodes
virtual unsigned int n_nodes() const override
Definition cell_inf_prism12.h:82
libMesh::InfPrism12::default_order
virtual Order default_order() const override
Definition cell_inf_prism12.C:95
libMesh::InfPrism12::is_node_on_side
virtual bool is_node_on_side(const unsigned int n, const unsigned int s) const override
Definition cell_inf_prism12.C:62
libMesh::InfPrism12::side_nodes_map
static const unsigned int side_nodes_map[num_sides][nodes_per_side]
This maps the node of the side to element node numbers.
Definition cell_inf_prism12.h:199
libMesh::InfPrism12::_second_order_adjacent_vertices
static const unsigned short int _second_order_adjacent_vertices[num_edges][2]
Matrix that tells which vertices define the location of mid-side (or second-order) nodes.
Definition cell_inf_prism12.h:248
libMesh::InfPrism12::build_side_ptr
virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i) override
Definition cell_inf_prism12.C:129
libMesh::InfPrism12::_second_order_vertex_child_index
static const unsigned short int _second_order_vertex_child_index[num_nodes]
Vector that names the child vertex index for each second order node.
Definition cell_inf_prism12.h:258
libMesh::InfPrism::n_vertices
virtual unsigned int n_vertices() const override final
Definition cell_inf_prism.h:94
libMesh::InfPrism::num_edges
static const int num_edges
Definition cell_inf_prism.h:80
libMesh::InfPrism::n_edges
virtual unsigned int n_edges() const override final
Definition cell_inf_prism.h:100
libMesh::InfPrism::num_sides
static const int num_sides
Geometric constants for all InfPrisms.
Definition cell_inf_prism.h:79
libMesh::InfPrism::n_sides
virtual unsigned int n_sides() const override final
Definition cell_inf_prism.h:88
libMesh::InfPrism::num_children
static const int num_children
Definition cell_inf_prism.h:81
libMesh
The libMesh namespace provides an interface to certain functionality in the library.
libMesh::IOPackage
IOPackage
libMesh interfaces with several different software packages for the purposes of creating,...
Definition enum_io_package.h:38
libMesh::ElemType
ElemType
Defines an enum for geometric element types.
Definition enum_elem_type.h:33
libMesh::libmesh_assert
libmesh_assert(ctx)
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition libmesh_common.h:144
Generated on Mon Aug 24 2026 19:00:36 for libMesh by doxygen 1.9.8