BELFEM 0.9.0
Berkeley Lab Finite Element Framework
Loading...
Searching...
No Matches
cl_Element_PYRA14.hpp
Go to the documentation of this file.
1/*
2 * BELFEM -- The Berkeley Lab Finite Element Framework
3 * Copyright (c) 2026, The Regents of the University of California,
4 * through Lawrence Berkeley National Laboratory (subject to receipt of any required
5 * approvals from the U.S. Dept. of Energy). All rights reserved.
6 *
7 * Developers: Christian Messe, Gregory Giard
8 *
9 * See the top-level LICENSE file for the complete license and disclaimer.
10 */
11
12#ifndef BELFEM_CL_ELEMENT_PYRA14_HPP
13#define BELFEM_CL_ELEMENT_PYRA14_HPP
14#include "typedefs.hpp"
15#include "Mesh_Enums.hpp"
16#include "cl_ElementTemplate.hpp"
17
18namespace belfem
19{
20 namespace mesh
21 {
22//------------------------------------------------------------------------------
23
24 template <>
25 ElementType
30
31//------------------------------------------------------------------------------
32
33 template <>
34 uint
35 ElementTemplate< 14, 5, 8, 5, 5 >::dimension() const
36 {
37 return 3 ;
38 }
39
40//------------------------------------------------------------------------------
41
42 template <>
43 void
44 ElementTemplate< 14, 5, 8, 5, 5 >::get_nodes_of_facet( const uint aFacetIndex, Cell< Node * > & aNodes )
45 {
46 switch( aFacetIndex )
47 {
48 case( 0 ):
49 {
50 aNodes.set_size( 6, nullptr );
51 aNodes( 0 ) = mNodes[ 0 ];
52 aNodes( 1 ) = mNodes[ 1 ];
53 aNodes( 2 ) = mNodes[ 4 ];
54 aNodes( 3 ) = mNodes[ 5 ];
55 aNodes( 4 ) = mNodes[ 10 ];
56 aNodes( 5 ) = mNodes[ 9 ];
57 break;
58 }
59 case( 1 ):
60 {
61 aNodes.set_size( 6, nullptr );
62 aNodes( 0 ) = mNodes[ 1 ];
63 aNodes( 1 ) = mNodes[ 2 ];
64 aNodes( 2 ) = mNodes[ 4 ];
65 aNodes( 3 ) = mNodes[ 6 ];
66 aNodes( 4 ) = mNodes[ 11 ];
67 aNodes( 5 ) = mNodes[ 10 ];
68 break;
69 }
70 case( 2 ):
71 {
72 aNodes.set_size( 6, nullptr );
73 aNodes( 0 ) = mNodes[ 2 ];
74 aNodes( 1 ) = mNodes[ 3 ];
75 aNodes( 2 ) = mNodes[ 4 ];
76 aNodes( 3 ) = mNodes[ 7 ];
77 aNodes( 4 ) = mNodes[ 12 ];
78 aNodes( 5 ) = mNodes[ 11 ];
79 break;
80 }
81 case( 3 ):
82 {
83 aNodes.set_size( 6, nullptr );
84 aNodes( 0 ) = mNodes[ 3 ];
85 aNodes( 1 ) = mNodes[ 0 ];
86 aNodes( 2 ) = mNodes[ 4 ];
87 aNodes( 3 ) = mNodes[ 8 ];
88 aNodes( 4 ) = mNodes[ 9 ];
89 aNodes( 5 ) = mNodes[ 12 ];
90 break;
91 }
92 case( 4 ):
93 {
94 aNodes.set_size( 9, nullptr );
95 aNodes( 0 ) = mNodes[ 0 ];
96 aNodes( 1 ) = mNodes[ 3 ];
97 aNodes( 2 ) = mNodes[ 2 ];
98 aNodes( 3 ) = mNodes[ 1 ];
99 aNodes( 4 ) = mNodes[ 8 ];
100 aNodes( 5 ) = mNodes[ 7 ];
101 aNodes( 6 ) = mNodes[ 6 ];
102 aNodes( 7 ) = mNodes[ 5 ];
103 aNodes( 8 ) = mNodes[ 13 ];
104 break;
105 }
106 default:
107 {
108 this->throw_facet_error( aFacetIndex );
109 }
110 }
111 }
112
113//------------------------------------------------------------------------------
114
115 template <>
116 void
117 ElementTemplate< 14, 5, 8, 5, 5 >::get_corner_nodes_of_facet( const uint aFacetIndex, Cell< Node * > & aNodes )
118 {
119 switch( aFacetIndex )
120 {
121 case( 0 ):
122 {
123 aNodes.set_size( 3, nullptr );
124 aNodes( 0 ) = mNodes[ 0 ];
125 aNodes( 1 ) = mNodes[ 1 ];
126 aNodes( 2 ) = mNodes[ 4 ];
127 break;
128 }
129 case( 1 ):
130 {
131 aNodes.set_size( 3, nullptr );
132 aNodes( 0 ) = mNodes[ 1 ];
133 aNodes( 1 ) = mNodes[ 2 ];
134 aNodes( 2 ) = mNodes[ 4 ];
135 break;
136 }
137 case( 2 ):
138 {
139 aNodes.set_size( 3, nullptr );
140 aNodes( 0 ) = mNodes[ 2 ];
141 aNodes( 1 ) = mNodes[ 3 ];
142 aNodes( 2 ) = mNodes[ 4 ];
143 break;
144 }
145 case( 3 ):
146 {
147 aNodes.set_size( 3, nullptr );
148 aNodes( 0 ) = mNodes[ 3 ];
149 aNodes( 1 ) = mNodes[ 0 ];
150 aNodes( 2 ) = mNodes[ 4 ];
151 break;
152 }
153 case( 4 ):
154 {
155 aNodes.set_size( 4, nullptr );
156 aNodes( 0 ) = mNodes[ 0 ];
157 aNodes( 1 ) = mNodes[ 3 ];
158 aNodes( 2 ) = mNodes[ 2 ];
159 aNodes( 3 ) = mNodes[ 1 ];
160 break;
161 }
162 default:
163 {
164 this->throw_facet_error( aFacetIndex );
165 }
166 }
167 }
168
169//------------------------------------------------------------------------------
170
171 template <>
172 void
173 ElementTemplate< 14, 5, 8, 5, 5 >::get_nodes_of_edge( const uint aEdgeIndex, Cell< Node * > & aNodes )
174 {
175 // allocate the node container
176 aNodes.set_size( 3, nullptr );
177
178 switch ( aEdgeIndex )
179 {
180 case ( 0 ):
181 {
182 aNodes( 0 ) = mNodes[ 0 ];
183 aNodes( 1 ) = mNodes[ 1 ];
184 aNodes( 2 ) = mNodes[ 5 ];
185 break;
186 }
187 case ( 1 ):
188 {
189 aNodes( 0 ) = mNodes[ 1 ];
190 aNodes( 1 ) = mNodes[ 2 ];
191 aNodes( 2 ) = mNodes[ 6 ];
192 break;
193 }
194 case ( 2 ):
195 {
196 aNodes( 0 ) = mNodes[ 2 ];
197 aNodes( 1 ) = mNodes[ 3 ];
198 aNodes( 2 ) = mNodes[ 7 ];
199 break;
200 }
201 case ( 3 ):
202 {
203 aNodes( 0 ) = mNodes[ 3 ];
204 aNodes( 1 ) = mNodes[ 0 ];
205 aNodes( 2 ) = mNodes[ 8 ];
206 break;
207 }
208 case ( 4 ):
209 {
210 aNodes( 0 ) = mNodes[ 0 ];
211 aNodes( 1 ) = mNodes[ 4 ];
212 aNodes( 2 ) = mNodes[ 9 ];
213 break;
214 }
215 case ( 5 ):
216 {
217 aNodes( 0 ) = mNodes[ 1 ];
218 aNodes( 1 ) = mNodes[ 4 ];
219 aNodes( 2 ) = mNodes[ 10 ];
220 break;
221 }
222 case ( 6 ):
223 {
224 aNodes( 0 ) = mNodes[ 2 ];
225 aNodes( 1 ) = mNodes[ 4 ];
226 aNodes( 2 ) = mNodes[ 11 ];
227 break;
228 }
229 case ( 7 ):
230 {
231 aNodes( 0 ) = mNodes[ 3 ];
232 aNodes( 1 ) = mNodes[ 4 ];
233 aNodes( 2 ) = mNodes[ 12 ];
234 break;
235 }
236 default:
237 {
238 this->throw_edge_error( aEdgeIndex );
239 }
240 }
241 }
242
243//------------------------------------------------------------------------------
244
245 template <>
246 void
247 ElementTemplate< 14, 5, 8, 5, 5 >::get_edges_of_facet(
248 const uint aFacetIndex, Cell< Edge * > & aEdges )
249 {
250 switch( aFacetIndex )
251 {
252 case( 0 ):
253 {
254 aEdges.set_size( 3, nullptr );
255 aEdges( 0 ) = mEdges[ 0 ];
256 aEdges( 1 ) = mEdges[ 5 ];
257 aEdges( 2 ) = mEdges[ 4 ];
258 break;
259 }
260 case( 1 ):
261 {
262 aEdges.set_size( 3, nullptr );
263 aEdges( 0 ) = mEdges[ 1 ];
264 aEdges( 1 ) = mEdges[ 6 ];
265 aEdges( 2 ) = mEdges[ 5 ];
266 break;
267 }
268 case( 2 ):
269 {
270 aEdges.set_size( 3, nullptr );
271 aEdges( 0 ) = mEdges[ 3 ];
272 aEdges( 1 ) = mEdges[ 7 ];
273 aEdges( 2 ) = mEdges[ 6 ];
274 break;
275 }
276 case( 3 ):
277 {
278 aEdges.set_size( 3, nullptr );
279 aEdges( 0 ) = mEdges[ 3 ];
280 aEdges( 1 ) = mEdges[ 4 ];
281 aEdges( 2 ) = mEdges[ 7 ];
282 break;
283 }
284 case( 4 ):
285 {
286 aEdges.set_size( 4, nullptr );
287 aEdges( 0 ) = mEdges[ 3 ];
288 aEdges( 1 ) = mEdges[ 2 ];
289 aEdges( 2 ) = mEdges[ 1 ];
290 aEdges( 3 ) = mEdges[ 0 ];
291 break;
292 }
293 default:
294 {
295 this->throw_facet_error( aFacetIndex );
296 }
297 }
298 }
299
300//------------------------------------------------------------------------------
301 } /* namespace mesh */
302} /* namespace belfem */
303#endif //BELFEM_CL_ELEMENT_PYRA14_HPP
304
Mesh_Enums.hpp
cl_ElementTemplate.hpp
belfem::Cell
Cell is a wrapper around the standard vector.
Definition cl_Cell.hpp:42
belfem::Cell::set_size
void set_size(const size_t aSize)
Definition cl_Cell.hpp:189
belfem::mesh::ElementTemplate::get_nodes_of_edge
void get_nodes_of_edge(const uint aEdgeIndex, Cell< Node * > &aNodes) override
Definition cl_ElementTemplate.hpp:930
belfem::mesh::ElementTemplate::get_nodes_of_facet
void get_nodes_of_facet(const uint aFacetIndex, Cell< Node * > &aNodes) override
Definition cl_ElementTemplate.hpp:896
belfem::mesh::ElementTemplate::get_corner_nodes_of_facet
void get_corner_nodes_of_facet(const uint aFacetIndex, Cell< Node * > &aNodes) override
Definition cl_ElementTemplate.hpp:907
belfem::mesh::ElementTemplate::dimension
uint dimension() const override
Definition cl_ElementTemplate.hpp:978
belfem::mesh::ElementTemplate::type
ElementType type() const override
return the type of the element
Definition cl_ElementTemplate.hpp:470
belfem::mesh::ElementTemplate::get_edges_of_facet
void get_edges_of_facet(const uint aFacetIndex, Cell< Edge * > &aEdges) override
Definition cl_ElementTemplate.hpp:918
belfem::mesh
Definition cl_EF_EdgeFunction.hpp:17
belfem
USER GUIDES:
Definition cl_Capacitor.cpp:16
belfem::uint
unsigned int uint
Definition typedefs.hpp:30
belfem::ElementType
ElementType
Element types.
Definition Mesh_Enums.hpp:27
belfem::ElementType::PYRA14
@ PYRA14
Definition Mesh_Enums.hpp:42