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