BELFEM 0.9.0
Berkeley Lab Finite Element Framework
Loading...
Searching...
No Matches
cl_Element_HEX20.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_HEX20_HPP
13#define BELFEM_CL_ELEMENT_HEX20_HPP
14
15#include "typedefs.hpp"
16#include "Mesh_Enums.hpp"
17#include "cl_ElementTemplate.hpp"
18
19namespace belfem
20{
21 namespace mesh
22 {
23//------------------------------------------------------------------------------
24
25 template <>
26 ElementType
31
32//------------------------------------------------------------------------------
33
34 template <>
35 uint
36 ElementTemplate< 20, 8, 12, 6, 6 >::dimension() const
37 {
38 return 3 ;
39 }
40
41//------------------------------------------------------------------------------
42
43 template <>
44 void
45 ElementTemplate< 20, 8, 12, 6, 6 >::get_nodes_of_facet( const uint aFacetIndex, Cell< Node * > & aNodes )
46 {
47 // allocate the node container
48 aNodes.set_size( 8, nullptr );
49
50 switch( aFacetIndex )
51 {
52 case( 0 ):
53 {
54 aNodes( 0 ) = mNodes[ 0 ];
55 aNodes( 1 ) = mNodes[ 1 ];
56 aNodes( 2 ) = mNodes[ 5 ];
57 aNodes( 3 ) = mNodes[ 4 ];
58 aNodes( 4 ) = mNodes[ 8 ];
59 aNodes( 5 ) = mNodes[ 13 ];
60 aNodes( 6 ) = mNodes[ 16 ];
61 aNodes( 7 ) = mNodes[ 12 ];
62 break;
63 }
64 case( 1 ):
65 {
66 aNodes( 0 ) = mNodes[ 1 ];
67 aNodes( 1 ) = mNodes[ 2 ];
68 aNodes( 2 ) = mNodes[ 6 ];
69 aNodes( 3 ) = mNodes[ 5 ];
70 aNodes( 4 ) = mNodes[ 9 ];
71 aNodes( 5 ) = mNodes[ 14 ];
72 aNodes( 6 ) = mNodes[ 17 ];
73 aNodes( 7 ) = mNodes[ 13 ];
74 break;
75 }
76 case( 2 ):
77 {
78 aNodes( 0 ) = mNodes[ 2 ];
79 aNodes( 1 ) = mNodes[ 3 ];
80 aNodes( 2 ) = mNodes[ 7 ];
81 aNodes( 3 ) = mNodes[ 6 ];
82 aNodes( 4 ) = mNodes[ 10 ];
83 aNodes( 5 ) = mNodes[ 15 ];
84 aNodes( 6 ) = mNodes[ 18 ];
85 aNodes( 7 ) = mNodes[ 14 ];
86 break;
87 }
88 case( 3 ):
89 {
90 aNodes( 0 ) = mNodes[ 0 ];
91 aNodes( 1 ) = mNodes[ 4 ];
92 aNodes( 2 ) = mNodes[ 7 ];
93 aNodes( 3 ) = mNodes[ 3 ];
94 aNodes( 4 ) = mNodes[ 12 ];
95 aNodes( 5 ) = mNodes[ 19 ];
96 aNodes( 6 ) = mNodes[ 15 ];
97 aNodes( 7 ) = mNodes[ 11 ];
98 break;
99 }
100 case( 4 ):
101 {
102 aNodes( 0 ) = mNodes[ 0 ];
103 aNodes( 1 ) = mNodes[ 3 ];
104 aNodes( 2 ) = mNodes[ 2 ];
105 aNodes( 3 ) = mNodes[ 1 ];
106 aNodes( 4 ) = mNodes[ 11 ];
107 aNodes( 5 ) = mNodes[ 10 ];
108 aNodes( 6 ) = mNodes[ 9 ];
109 aNodes( 7 ) = mNodes[ 8 ];
110 break;
111 }
112 case( 5 ):
113 {
114 aNodes( 0 ) = mNodes[ 4 ];
115 aNodes( 1 ) = mNodes[ 5 ];
116 aNodes( 2 ) = mNodes[ 6 ];
117 aNodes( 3 ) = mNodes[ 7 ];
118 aNodes( 4 ) = mNodes[ 16 ];
119 aNodes( 5 ) = mNodes[ 17 ];
120 aNodes( 6 ) = mNodes[ 18 ];
121 aNodes( 7 ) = mNodes[ 19 ];
122 break;
123 }
124 default:
125 {
126 this->throw_facet_error( aFacetIndex );
127 }
128 }
129
130 }
131
132//------------------------------------------------------------------------------
133
134 template <>
135 void
136 ElementTemplate< 20, 8, 12, 6, 6 >::get_corner_nodes_of_facet( const uint aFacetIndex, Cell< Node * > & aNodes )
137 {
138 // allocate the node container
139 aNodes.set_size( 4, nullptr );
140
141 switch( aFacetIndex )
142 {
143 case( 0 ):
144 {
145 aNodes( 0 ) = mNodes[ 0 ];
146 aNodes( 1 ) = mNodes[ 1 ];
147 aNodes( 2 ) = mNodes[ 5 ];
148 aNodes( 3 ) = mNodes[ 4 ];
149 break;
150 }
151 case( 1 ):
152 {
153 aNodes( 0 ) = mNodes[ 1 ];
154 aNodes( 1 ) = mNodes[ 2 ];
155 aNodes( 2 ) = mNodes[ 6 ];
156 aNodes( 3 ) = mNodes[ 5 ];
157 break;
158 }
159 case( 2 ):
160 {
161 aNodes( 0 ) = mNodes[ 2 ];
162 aNodes( 1 ) = mNodes[ 3 ];
163 aNodes( 2 ) = mNodes[ 7 ];
164 aNodes( 3 ) = mNodes[ 6 ];
165 break;
166 }
167 case( 3 ):
168 {
169 aNodes( 0 ) = mNodes[ 0 ];
170 aNodes( 1 ) = mNodes[ 4 ];
171 aNodes( 2 ) = mNodes[ 7 ];
172 aNodes( 3 ) = mNodes[ 3 ];
173 break;
174 }
175 case( 4 ):
176 {
177 aNodes( 0 ) = mNodes[ 0 ];
178 aNodes( 1 ) = mNodes[ 3 ];
179 aNodes( 2 ) = mNodes[ 2 ];
180 aNodes( 3 ) = mNodes[ 1 ];
181 break;
182 }
183 case( 5 ):
184 {
185 aNodes( 0 ) = mNodes[ 4 ];
186 aNodes( 1 ) = mNodes[ 5 ];
187 aNodes( 2 ) = mNodes[ 6 ];
188 aNodes( 3 ) = mNodes[ 7 ];
189 break;
190 }
191 default:
192 {
193 this->throw_facet_error( aFacetIndex );
194 }
195 }
196 }
197
198//------------------------------------------------------------------------------
199
200 template <>
201 void
202 ElementTemplate< 20, 8, 12, 6, 6 >::get_nodes_of_edge( const uint aEdgeIndex, Cell< Node * > & aNodes )
203 {
204 // allocate the node container
205 aNodes.set_size( 3, nullptr );
206
207 switch ( aEdgeIndex )
208 {
209 case 0 :
210 {
211 aNodes( 0 ) = mNodes[ 0 ];
212 aNodes( 1 ) = mNodes[ 1 ];
213 aNodes( 2 ) = mNodes[ 8 ];
214 break;
215 }
216 case 1 :
217 {
218 aNodes( 0 ) = mNodes[ 1 ];
219 aNodes( 1 ) = mNodes[ 2 ];
220 aNodes( 2 ) = mNodes[ 9 ];
221 break;
222 }
223 case 2 :
224 {
225 aNodes( 0 ) = mNodes[ 2 ];
226 aNodes( 1 ) = mNodes[ 3 ];
227 aNodes( 2 ) = mNodes[ 10 ];
228 break;
229 }
230 case 3 :
231 {
232 aNodes( 0 ) = mNodes[ 3 ];
233 aNodes( 1 ) = mNodes[ 0 ];
234 aNodes( 2 ) = mNodes[ 11 ];
235 break;
236 }
237 case 4 :
238 {
239 aNodes( 0 ) = mNodes[ 4 ];
240 aNodes( 1 ) = mNodes[ 5 ];
241 aNodes( 2 ) = mNodes[ 16 ];
242 break;
243 }
244 case 5 :
245 {
246 aNodes( 0 ) = mNodes[ 5 ];
247 aNodes( 1 ) = mNodes[ 6 ];
248 aNodes( 2 ) = mNodes[ 17 ];
249 break;
250 }
251 case 6 :
252 {
253 aNodes( 0 ) = mNodes[ 6 ];
254 aNodes( 1 ) = mNodes[ 7 ];
255 aNodes( 2 ) = mNodes[ 18 ];
256 break;
257 }
258 case 7 :
259 {
260 aNodes( 0 ) = mNodes[ 7 ];
261 aNodes( 1 ) = mNodes[ 4 ];
262 aNodes( 2 ) = mNodes[ 19 ];
263 break;
264 }
265 case 8 :
266 {
267 aNodes( 0 ) = mNodes[ 0 ];
268 aNodes( 1 ) = mNodes[ 4 ];
269 aNodes( 2 ) = mNodes[ 12 ];
270 break;
271 }
272 case 9 :
273 {
274 aNodes( 0 ) = mNodes[ 1 ];
275 aNodes( 1 ) = mNodes[ 5 ];
276 aNodes( 2 ) = mNodes[ 13 ];
277 break;
278 }
279 case 10 :
280 {
281 aNodes( 0 ) = mNodes[ 2 ];
282 aNodes( 1 ) = mNodes[ 6 ];
283 aNodes( 2 ) = mNodes[ 14 ];
284 break;
285 }
286 case 11 :
287 {
288 aNodes( 0 ) = mNodes[ 3 ];
289 aNodes( 1 ) = mNodes[ 7 ];
290 aNodes( 2 ) = mNodes[ 15 ];
291 break;
292 }
293 default:
294 {
295 this->throw_edge_error( aEdgeIndex );
296 }
297 }
298 }
299//------------------------------------------------------------------------------
300
301 template <>
302 void
303 ElementTemplate< 20, 8, 12, 6, 6 >::get_edges_of_facet(
304 const uint aFacetIndex, Cell< Edge * > & aEdges )
305 {
306 // allocate the node container
307 aEdges.set_size( 4, nullptr );
308
309 switch( aFacetIndex )
310 {
311 case 0 :
312 {
313 aEdges( 0 ) = mEdges[ 0 ];
314 aEdges( 1 ) = mEdges[ 9 ];
315 aEdges( 2 ) = mEdges[ 4 ];
316 aEdges( 3 ) = mEdges[ 8 ];
317 break;
318 }
319 case 1 :
320 {
321 aEdges( 0 ) = mEdges[ 1 ];
322 aEdges( 1 ) = mEdges[ 10 ];
323 aEdges( 2 ) = mEdges[ 5 ];
324 aEdges( 3 ) = mEdges[ 9 ];
325 break;
326 }
327 case 2 :
328 {
329 aEdges( 0 ) = mEdges[ 2 ];
330 aEdges( 1 ) = mEdges[ 11 ];
331 aEdges( 2 ) = mEdges[ 6 ];
332 aEdges( 3 ) = mEdges[ 10 ];
333 break;
334 }
335 case 3 :
336 {
337 aEdges( 0 ) = mEdges[ 8 ];
338 aEdges( 1 ) = mEdges[ 7 ];
339 aEdges( 2 ) = mEdges[ 11 ];
340 aEdges( 3 ) = mEdges[ 3 ];
341 break;
342 }
343 case 4 :
344 {
345 aEdges( 0 ) = mEdges[ 3 ];
346 aEdges( 1 ) = mEdges[ 2 ];
347 aEdges( 2 ) = mEdges[ 1 ];
348 aEdges( 3 ) = mEdges[ 0 ];
349 break;
350 }
351 case 5 :
352 {
353 aEdges( 0 ) = mEdges[ 4 ];
354 aEdges( 1 ) = mEdges[ 5 ];
355 aEdges( 2 ) = mEdges[ 6 ];
356 aEdges( 3 ) = mEdges[ 7 ];
357 break;
358 }
359 default:
360 {
361 this->throw_facet_error( aFacetIndex );
362 }
363 }
364 }
365
366//------------------------------------------------------------------------------
367 } /* namespace mesh */
368} /* namespace belfem */
369
370#endif //BELFEM_CL_ELEMENT_HEX20_HPP
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::HEX20
@ HEX20
Definition Mesh_Enums.hpp:45