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