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