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