FEAT 3
Finite Element Analysis Toolbox
Loading...
Searching...
No Matches
node_functional.hpp
1// FEAT3: Finite Element Analysis Toolbox, Version 3
2// Copyright (C) 2010 by Stefan Turek & the FEAT group
3// FEAT3 is released under the GNU General Public License version 3,
4// see the file 'copyright.txt' in the top level directory for details.
5
6#pragma once
7
8// includes, FEAT
9#include <kernel/space/node_functional_base.hpp>
10
11namespace FEAT
12{
13 namespace Space
14 {
15 namespace Lagrange3
16 {
17 template<
18 typename Space_,
19 typename ShapeType_,
20 typename DataType_>
21 class NodeFunctional :
22 public NodeFunctionalNull<Space_, DataType_>
23 {
24 public:
25 explicit NodeFunctional(const Space_& space) :
26 NodeFunctionalNull<Space_, DataType_>(space)
27 {
28 }
29 };
30
31 template<
32 typename Space_,
33 typename DataType_>
34 class NodeFunctional<Space_, Shape::Vertex, DataType_> :
35 public NodeFunctionalBase<Space_, DataType_>
36 {
37 public:
38 typedef NodeFunctionalBase<Space_, DataType_> BaseClass;
39 static constexpr int max_assigned_dofs = 1;
40
41 template<typename Function_>
42 struct Value
43 {
44 typedef typename Analytic::EvalTraits<DataType_, Function_>::ValueType Type;
45 };
46
47 protected:
48 typedef typename Space_::TrafoType TrafoType;
49 typedef typename TrafoType::template Evaluator<Shape::Vertex, DataType_>::Type TrafoEvalType;
50 typedef typename TrafoEvalType::EvalTraits TrafoEvalTraits;
51 typedef typename TrafoEvalTraits::DataType DataType;
52 typedef typename TrafoEvalTraits::DomainPointType DomainPointType;
53
54 // declare trafo evaluation data
55 typedef typename TrafoEvalType::template ConfigTraits<TrafoTags::img_point>::EvalDataType TrafoEvalData;
56
57 TrafoEvalType _trafo_eval;
58
59 public:
60 explicit NodeFunctional(const Space_& space) :
61 BaseClass(space),
62 _trafo_eval(space.get_trafo())
63 {
64 }
65
66 void prepare(Index cell_index)
67 {
68 BaseClass::prepare(cell_index);
69 _trafo_eval.prepare(cell_index);
70 }
71
72 void finish()
73 {
74 _trafo_eval.finish();
75 BaseClass::finish();
76 }
77
78 int get_num_assigned_dofs() const
79 {
80 return max_assigned_dofs;
81 }
82
83 template<typename NodeData_, typename Function_>
84 void operator()(NodeData_& node_data, const Function_& function) const
85 {
86 static_assert(std::is_base_of<Analytic::Function, Function_>::value, "invalid function object");
87 static_assert(Function_::can_value, "function cannot compute values");
88
89 // declare our evaluation traits
90 typedef Analytic::EvalTraits<DataType_, Function_> FuncEvalTraits;
91
92 // declare function evaluator
93 typename Function_::template Evaluator<FuncEvalTraits> func_eval(function);
94
95 // compute trafo data
96 DomainPointType dom_point(DataType(0));
97 TrafoEvalData trafo_data;
98 _trafo_eval(trafo_data, dom_point);
99
100 // evaluate function
101 node_data[0] = func_eval.value(trafo_data.img_point);
102 }
103 };
104
105 template<
106 typename Space_,
107 int shape_dim_,
108 typename DataType_>
109 class NodeFunctional<Space_, Shape::Hypercube<shape_dim_>, DataType_> :
110 public NodeFunctionalBase<Space_, DataType_>
111 {
112 public:
113 typedef NodeFunctionalBase<Space_, DataType_> BaseClass;
114 static constexpr int max_assigned_dofs = (1 << shape_dim_);
115
116 template<typename Function_>
117 struct Value
118 {
119 typedef typename Analytic::EvalTraits<DataType_, Function_>::ValueType Type;
120 };
121
122 protected:
123 typedef typename Space_::TrafoType TrafoType;
124 typedef typename TrafoType::template Evaluator<Shape::Hypercube<shape_dim_>, DataType_>::Type TrafoEvalType;
125 typedef typename TrafoEvalType::EvalTraits TrafoEvalTraits;
126 typedef typename TrafoEvalTraits::DataType DataType;
127 typedef typename TrafoEvalTraits::DomainPointType DomainPointType;
128
129 // declare trafo evaluation data
130 typedef typename TrafoEvalType::template ConfigTraits<TrafoTags::img_point>::EvalDataType TrafoEvalData;
131
132 TrafoEvalType _trafo_eval;
133
134 public:
135 explicit NodeFunctional(const Space_& space) :
136 BaseClass(space),
137 _trafo_eval(space.get_trafo())
138 {
139 }
140
141 void prepare(Index cell_index)
142 {
143 BaseClass::prepare(cell_index);
144 _trafo_eval.prepare(cell_index);
145 }
146
147 void finish()
148 {
149 _trafo_eval.finish();
150 BaseClass::finish();
151 }
152
153 int get_num_assigned_dofs() const
154 {
155 return max_assigned_dofs;
156 }
157
158 template<typename NodeData_, typename Function_>
159 void operator()(NodeData_& node_data, const Function_& function) const
160 {
161 static_assert(std::is_base_of<Analytic::Function, Function_>::value, "invalid function object");
162 static_assert(Function_::can_value, "function cannot compute values");
163
164 // declare our evaluation traits
165 typedef Analytic::EvalTraits<DataType_, Function_> FuncEvalTraits;
166
167 // declare function evaluator
168 typename Function_::template Evaluator<FuncEvalTraits> func_eval(function);
169
170 // compute trafo data
171 DomainPointType dom_point(DataType_(0));
172 TrafoEvalData trafo_data;
173
174 // loop over all nodal points
175 for(int i(0); i < max_assigned_dofs; ++i)
176 {
177 // set up domain point coords
178 for(int k(0); k < shape_dim_; ++k)
179 dom_point[k] = DataType_(2*((i >> k) & 1) - 1) / DataType_(3); // = +- 1/3
180
181 // transform
182 _trafo_eval(trafo_data, dom_point);
183
184 // evaluate function
185 node_data[i] = func_eval.value(trafo_data.img_point);
186 }
187 }
188 };
189
190 template<
191 typename Space_,
192 typename DataType_>
193 class NodeFunctional<Space_, Shape::Simplex<1>, DataType_> :
194 public NodeFunctionalBase<Space_, DataType_>
195 {
196 public:
197 typedef NodeFunctionalBase<Space_, DataType_> BaseClass;
198 static constexpr int max_assigned_dofs = 2;
199
200 template<typename Function_>
201 struct Value
202 {
203 typedef typename Analytic::EvalTraits<DataType_, Function_>::ValueType Type;
204 };
205
206 protected:
207 typedef typename Space_::TrafoType TrafoType;
208 typedef typename TrafoType::template Evaluator<Shape::Simplex<1>, DataType_>::Type TrafoEvalType;
209 typedef typename TrafoEvalType::EvalTraits TrafoEvalTraits;
210 typedef typename TrafoEvalTraits::DataType DataType;
211 typedef typename TrafoEvalTraits::DomainPointType DomainPointType;
212
213 // declare trafo evaluation data
214 typedef typename TrafoEvalType::template ConfigTraits<TrafoTags::img_point>::EvalDataType TrafoEvalData;
215
216 TrafoEvalType _trafo_eval;
217
218 public:
219 explicit NodeFunctional(const Space_& space) :
220 BaseClass(space),
221 _trafo_eval(space.get_trafo())
222 {
223 }
224
225 void prepare(Index cell_index)
226 {
227 BaseClass::prepare(cell_index);
228 _trafo_eval.prepare(cell_index);
229 }
230
231 void finish()
232 {
233 _trafo_eval.finish();
234 BaseClass::finish();
235 }
236
237 int get_num_assigned_dofs() const
238 {
239 return max_assigned_dofs;
240 }
241
242 template<typename NodeData_, typename Function_>
243 void operator()(NodeData_& node_data, const Function_& function) const
244 {
245 static_assert(std::is_base_of<Analytic::Function, Function_>::value, "invalid function object");
246 static_assert(Function_::can_value, "function cannot compute values");
247
248 // declare our evaluation traits
249 typedef Analytic::EvalTraits<DataType_, Function_> FuncEvalTraits;
250
251 // declare function evaluator
252 typename Function_::template Evaluator<FuncEvalTraits> func_eval(function);
253
254 // compute trafo data
255 DomainPointType dom_point(DataType_(0));
256 TrafoEvalData trafo_data;
257
258 // first nodal point 1/3
259 dom_point[0] = DataType(1) / DataType(3);
260 _trafo_eval(trafo_data, dom_point);
261 node_data[0] = func_eval.value(trafo_data.img_point);
262
263 // second nodal point 2/3
264 dom_point[0] = DataType(2) / DataType(3);
265 _trafo_eval(trafo_data, dom_point);
266 node_data[1] = func_eval.value(trafo_data.img_point);
267 }
268 };
269
270 template<
271 typename Space_,
272 typename DataType_>
273 class NodeFunctional<Space_, Shape::Simplex<2>, DataType_> :
274 public NodeFunctionalBase<Space_, DataType_>
275 {
276 public:
277 typedef NodeFunctionalBase<Space_, DataType_> BaseClass;
278 static constexpr int max_assigned_dofs = 1;
279
280 template<typename Function_>
281 struct Value
282 {
283 typedef typename Analytic::EvalTraits<DataType_, Function_>::ValueType Type;
284 };
285
286 protected:
287 typedef typename Space_::TrafoType TrafoType;
288 typedef typename TrafoType::template Evaluator<Shape::Simplex<2>, DataType_>::Type TrafoEvalType;
289 typedef typename TrafoEvalType::EvalTraits TrafoEvalTraits;
290 typedef typename TrafoEvalTraits::DataType DataType;
291 typedef typename TrafoEvalTraits::DomainPointType DomainPointType;
292
293 // declare trafo evaluation data
294 typedef typename TrafoEvalType::template ConfigTraits<TrafoTags::img_point>::EvalDataType TrafoEvalData;
295
296 TrafoEvalType _trafo_eval;
297
298 public:
299 explicit NodeFunctional(const Space_& space) :
300 BaseClass(space),
301 _trafo_eval(space.get_trafo())
302 {
303 }
304
305 void prepare(Index cell_index)
306 {
307 BaseClass::prepare(cell_index);
308 _trafo_eval.prepare(cell_index);
309 }
310
311 void finish()
312 {
313 _trafo_eval.finish();
314 BaseClass::finish();
315 }
316
317 int get_num_assigned_dofs() const
318 {
319 return max_assigned_dofs;
320 }
321
322 template<typename NodeData_, typename Function_>
323 void operator()(NodeData_& node_data, const Function_& function) const
324 {
325 static_assert(std::is_base_of<Analytic::Function, Function_>::value, "invalid function object");
326 static_assert(Function_::can_value, "function cannot compute values");
327
328 // declare our evaluation traits
329 typedef Analytic::EvalTraits<DataType_, Function_> FuncEvalTraits;
330
331 // declare function evaluator
332 typename Function_::template Evaluator<FuncEvalTraits> func_eval(function);
333
334 // compute trafo data
335 DomainPointType dom_point(DataType_(1) / DataType(3));
336 TrafoEvalData trafo_data;
337 _trafo_eval(trafo_data, dom_point);
338 node_data[0] = func_eval.value(trafo_data.img_point);
339 }
340 };
341 } // namespace Lagrange3
342 } // namespace Space
343} // namespace FEAT
FEAT::Space::Lagrange3::Evaluator
Lagrange-3 Element Evaluator class template declaration.
Definition: evaluator.hpp:125
FEAT::Space::NodeFunctionalBase
Node-functional base class template.
Definition: node_functional_base.hpp:30
FEAT::Space::NodeFunctionalBase::finish
void finish()
Releases the node-functional from the current cell.
Definition: node_functional_base.hpp:70
FEAT::Space::NodeFunctionalBase::prepare
void prepare(Index cell_index)
Prepares the node-functional for a given cell.
Definition: node_functional_base.hpp:62
FEAT::Space::NodeFunctionalNull
Null-Node-Functional class template.
Definition: node_functional_base.hpp:122
FEAT::Space::NodeFunctionalNull::get_num_assigned_dofs
int get_num_assigned_dofs() const
Returns the number of assigned dofs on the current cell.
Definition: node_functional_base.hpp:138
FEAT::Space::NodeFunctionalNull::BaseClass
NodeFunctionalBase< Space_, DataType_ > BaseClass
base-class typedef
Definition: node_functional_base.hpp:128
FEAT::Space::NodeFunctionalNull::operator()
void operator()(NodeData_ &node_data, const Function_ &function) const
Evaluation operator.
Definition: node_functional_base.hpp:147
FEAT
FEAT namespace.
Definition: adjactor.hpp:12
FEAT::Index
std::uint64_t Index
Index data type.
Definition: base_header.hpp:122
FEAT::TrafoTags::dom_point
@ dom_point
specifies whether the trafo should supply domain point coordinates