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