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