BELFEM 0.9.0
Berkeley Lab Finite Element Framework
Loading...
Searching...
No Matches
cl_Element_HEX8.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_HEX8_HPP
13#define BELFEM_CL_ELEMENT_HEX8_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< 8, 8, 12, 6, 6 >::dimension() const
37 {
38 return 3 ;
39 }
40
41//------------------------------------------------------------------------------
42
43 template <>
44 void
45 ElementTemplate< 8, 8, 12, 6, 6 >::get_nodes_of_facet( const uint aFacetIndex, Cell< Node * > & aNodes )
46 {
47 // allocate the node container
48 aNodes.set_size( 4, 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 break;
59 }
60 case 1 :
61 {
62 aNodes( 0 ) = mNodes[ 1 ];
63 aNodes( 1 ) = mNodes[ 2 ];
64 aNodes( 2 ) = mNodes[ 6 ];
65 aNodes( 3 ) = mNodes[ 5 ];
66 break;
67 }
68 case 2 :
69 {
70 aNodes( 0 ) = mNodes[ 2 ];
71 aNodes( 1 ) = mNodes[ 3 ];
72 aNodes( 2 ) = mNodes[ 7 ];
73 aNodes( 3 ) = mNodes[ 6 ];
74 break;
75 }
76 case 3 :
77 {
78 aNodes( 0 ) = mNodes[ 0 ];
79 aNodes( 1 ) = mNodes[ 4 ];
80 aNodes( 2 ) = mNodes[ 7 ];
81 aNodes( 3 ) = mNodes[ 3 ];
82 break;
83 }
84 case 4 :
85 {
86 aNodes( 0 ) = mNodes[ 0 ];
87 aNodes( 1 ) = mNodes[ 3 ];
88 aNodes( 2 ) = mNodes[ 2 ];
89 aNodes( 3 ) = mNodes[ 1 ];
90 break;
91 }
92 case 5 :
93 {
94 aNodes( 0 ) = mNodes[ 4 ];
95 aNodes( 1 ) = mNodes[ 5 ];
96 aNodes( 2 ) = mNodes[ 6 ];
97 aNodes( 3 ) = mNodes[ 7 ];
98 break;
99 }
100 default:
101 {
102 this->throw_facet_error( aFacetIndex );
103 }
104 }
105
106 }
107
108//------------------------------------------------------------------------------
109
110 template <>
111 void
112 ElementTemplate< 8, 8, 12, 6, 6 >::get_corner_nodes_of_facet( const uint aFacetIndex, Cell< Node * > & aNodes )
113 {
114 this->get_nodes_of_facet( aFacetIndex, aNodes );
115 }
116
117//------------------------------------------------------------------------------
118
119 template <>
120 void
121 ElementTemplate< 8, 8, 12, 6, 6 >::get_nodes_of_edge( const uint aEdgeIndex, Cell< Node * > & aNodes )
122 {
123 // allocate the node container
124 aNodes.set_size( 2, nullptr );
125
126 switch ( aEdgeIndex )
127 {
128 case 0 :
129 {
130 aNodes( 0 ) = mNodes[ 0 ];
131 aNodes( 1 ) = mNodes[ 1 ];
132 break;
133 }
134 case 1 :
135 {
136 aNodes( 0 ) = mNodes[ 1 ];
137 aNodes( 1 ) = mNodes[ 2 ];
138 break;
139 }
140 case 2 :
141 {
142 aNodes( 0 ) = mNodes[ 2 ];
143 aNodes( 1 ) = mNodes[ 3 ];
144 break;
145 }
146 case 3 :
147 {
148 aNodes( 0 ) = mNodes[ 3 ];
149 aNodes( 1 ) = mNodes[ 0 ];
150 break;
151 }
152 case 4 :
153 {
154 aNodes( 0 ) = mNodes[ 4 ];
155 aNodes( 1 ) = mNodes[ 5 ];
156 break;
157 }
158 case 5 :
159 {
160 aNodes( 0 ) = mNodes[ 5 ];
161 aNodes( 1 ) = mNodes[ 6 ];
162 break;
163 }
164 case 6 :
165 {
166 aNodes( 0 ) = mNodes[ 6 ];
167 aNodes( 1 ) = mNodes[ 7 ];
168 break;
169 }
170 case 7 :
171 {
172 aNodes( 0 ) = mNodes[ 7 ];
173 aNodes( 1 ) = mNodes[ 4 ];
174 break;
175 }
176 case 8 :
177 {
178 aNodes( 0 ) = mNodes[ 0 ];
179 aNodes( 1 ) = mNodes[ 4 ];
180 break;
181 }
182 case 9 :
183 {
184 aNodes( 0 ) = mNodes[ 1 ];
185 aNodes( 1 ) = mNodes[ 5 ];
186 break;
187 }
188 case 10 :
189 {
190 aNodes( 0 ) = mNodes[ 2 ];
191 aNodes( 1 ) = mNodes[ 6 ];
192 break;
193 }
194 case 11 :
195 {
196 aNodes( 0 ) = mNodes[ 3 ];
197 aNodes( 1 ) = mNodes[ 7 ];
198 break;
199 }
200 default:
201 {
202 this->throw_edge_error( aEdgeIndex );
203 }
204 }
205 }
206
207//------------------------------------------------------------------------------
208
209 template <>
210 void
211 ElementTemplate< 8, 8, 12, 6, 6 >::get_edges_of_facet(
212 const uint aFacetIndex, Cell< Edge * > & aEdges )
213 {
214 // allocate the node container
215 aEdges.set_size( 4, nullptr );
216
217 switch( aFacetIndex )
218 {
219 case 0 :
220 {
221 aEdges( 0 ) = mEdges[ 0 ];
222 aEdges( 1 ) = mEdges[ 9 ];
223 aEdges( 2 ) = mEdges[ 4 ];
224 aEdges( 3 ) = mEdges[ 8 ];
225 break;
226 }
227 case 1 :
228 {
229 aEdges( 0 ) = mEdges[ 1 ];
230 aEdges( 1 ) = mEdges[ 10 ];
231 aEdges( 2 ) = mEdges[ 5 ];
232 aEdges( 3 ) = mEdges[ 9 ];
233 break;
234 }
235 case 2 :
236 {
237 aEdges( 0 ) = mEdges[ 2 ];
238 aEdges( 1 ) = mEdges[ 11 ];
239 aEdges( 2 ) = mEdges[ 6 ];
240 aEdges( 3 ) = mEdges[ 10 ];
241 break;
242 }
243 case 3 :
244 {
245 aEdges( 0 ) = mEdges[ 8 ];
246 aEdges( 1 ) = mEdges[ 7 ];
247 aEdges( 2 ) = mEdges[ 11 ];
248 aEdges( 3 ) = mEdges[ 3 ];
249 break;
250 }
251 case 4 :
252 {
253 aEdges( 0 ) = mEdges[ 3 ];
254 aEdges( 1 ) = mEdges[ 2 ];
255 aEdges( 2 ) = mEdges[ 1 ];
256 aEdges( 3 ) = mEdges[ 0 ];
257 break;
258 }
259 case 5 :
260 {
261 aEdges( 0 ) = mEdges[ 4 ];
262 aEdges( 1 ) = mEdges[ 5 ];
263 aEdges( 2 ) = mEdges[ 6 ];
264 aEdges( 3 ) = mEdges[ 7 ];
265 break;
266 }
267 default:
268 {
269 this->throw_facet_error( aFacetIndex );
270 }
271 }
272 }
273
274//------------------------------------------------------------------------------
275 } /* namespace mesh */
276} /* namespace belfem */
277
278#endif //BELFEM_CL_ELEMENT_HEX8_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::HEX8
@ HEX8
Definition Mesh_Enums.hpp:33