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