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 Hermite3
16 {
17 template<
18 typename Space_,
19 typename Shape_,
20 int dim_,
21 typename DataType_>
22 class NodeFunctional :
23 public NodeFunctionalNull<Space_, DataType_>
24 {
25 public:
26 explicit NodeFunctional(const Space_& space) :
27 NodeFunctionalNull<Space_, DataType_>(space)
28 {
29 }
30 };
31
32 template<
33 typename Space_,
34 typename DataType_>
35 class NodeFunctional<Space_, Shape::Simplex<2>, 0, DataType_> :
36 public NodeFunctionalBase<Space_, DataType_>
37 {
38 public:
39 typedef NodeFunctionalBase<Space_, DataType_> BaseClass;
40 static constexpr int max_assigned_dofs = 3;
41
42 template<typename Function_>
43 struct Value
44 {
45 typedef typename Analytic::EvalTraits<DataType_, Function_>::ValueType Type;
46 };
47
48 protected:
49 typedef typename Space_::TrafoType TrafoType;
50 typedef typename Space_::ShapeType ShapeType;
51 typedef typename TrafoType::template Evaluator<Shape::Vertex, DataType_>::Type TrafoEvalType;
52 typedef typename TrafoEvalType::EvalTraits TrafoEvalTraits;
53 typedef typename TrafoEvalTraits::DomainPointType DomainPointType;
54
55 // declare trafo evaluation data
56 typedef typename TrafoEvalType::template ConfigTraits<TrafoTags::img_point>::EvalDataType TrafoEvalData;
57
58 TrafoEvalType _trafo_eval;
59
60 public:
61 explicit NodeFunctional(const Space_& space) :
62 BaseClass(space),
63 _trafo_eval(space.get_trafo())
64 {
65 }
66
67 void prepare(Index cell_index)
68 {
69 BaseClass::prepare(cell_index);
70 _trafo_eval.prepare(cell_index);
71 }
72
73 void finish()
74 {
75 _trafo_eval.finish();
76 BaseClass::finish();
77 }
78
79 int get_num_assigned_dofs() const
80 {
81 return max_assigned_dofs;
82 }
83
84 template<typename NodeData_, typename Function_>
85 void operator()(NodeData_& node_data, const Function_& function) const
86 {
87 static_assert(std::is_base_of<Analytic::Function, Function_>::value, "invalid function object");
88 static_assert(Function_::can_value, "function cannot compute values");
89 static_assert(Function_::can_grad, "function cannot compute gradients");
90
91 // declare our evaluation traits
92 typedef Analytic::EvalTraits<DataType_, Function_> FuncEvalTraits;
93
94 // declare function evaluator
95 typename Function_::template Evaluator<FuncEvalTraits> func_eval(function);
96
97 // compute trafo data
98 DomainPointType dom_point(DataType_(0));
99 TrafoEvalData trafo_data;
100 _trafo_eval(trafo_data, dom_point);
101
102 // evaluate function
103 const auto func_value = func_eval.value(trafo_data.img_point);
104 const auto func_grad = func_eval.gradient(trafo_data.img_point);
105
106 // set node functional values
107 node_data[0] = func_value;
108 node_data[1] = func_grad[0];
109 node_data[2] = func_grad[1];
110 }
111 };
112
113 template<
114 typename Space_,
115 typename DataType_>
116 class NodeFunctional<Space_, Shape::Simplex<2>, 2, DataType_> :
117 public NodeFunctionalBase<Space_, DataType_>
118 {
119 public:
120 typedef NodeFunctionalBase<Space_, DataType_> BaseClass;
121 static constexpr int max_assigned_dofs = 1;
122
123 template<typename Function_>
124 struct Value
125 {
126 typedef typename Analytic::EvalTraits<DataType_, Function_>::ValueType Type;
127 };
128
129 protected:
130 typedef typename Space_::TrafoType TrafoType;
131 typedef typename Space_::ShapeType ShapeType;
132 typedef typename TrafoType::template Evaluator<Shape::Simplex<2>, DataType_>::Type TrafoEvalType;
133 typedef typename TrafoEvalType::EvalTraits TrafoEvalTraits;
134 typedef typename TrafoEvalTraits::DomainPointType DomainPointType;
135
136 // declare trafo evaluation data
137 typedef typename TrafoEvalType::template ConfigTraits<TrafoTags::img_point>::EvalDataType TrafoEvalData;
138
139 TrafoEvalType _trafo_eval;
140
141 public:
142 explicit NodeFunctional(const Space_& space) :
143 BaseClass(space),
144 _trafo_eval(space.get_trafo())
145 {
146 }
147
148 void prepare(Index cell_index)
149 {
150 BaseClass::prepare(cell_index);
151 _trafo_eval.prepare(cell_index);
152 }
153
154 void finish()
155 {
156 _trafo_eval.finish();
157 BaseClass::finish();
158 }
159
160 int get_num_assigned_dofs() const
161 {
162 return max_assigned_dofs;
163 }
164
165 template<typename NodeData_, typename Function_>
166 void operator()(NodeData_& node_data, const Function_& function) const
167 {
168 static_assert(std::is_base_of<Analytic::Function, Function_>::value, "invalid function object");
169 static_assert(Function_::can_value, "function cannot compute values");
170
171 // declare our evaluation traits
172 typedef Analytic::EvalTraits<DataType_, Function_> FuncEvalTraits;
173
174 // declare function evaluator
175 typename Function_::template Evaluator<FuncEvalTraits> func_eval(function);
176
177 // compute trafo data
178 DomainPointType dom_point(DataType_(1) / DataType_(3));
179 TrafoEvalData trafo_data;
180 _trafo_eval(trafo_data, dom_point);
181
182 // evaluate function
183 node_data[0] = func_eval.value(trafo_data.img_point);
184 }
185 };
186
187 template<
188 typename Space_,
189 typename DataType_>
190 class NodeFunctional<Space_, Shape::Hypercube<1>, 0, DataType_> :
191 public NodeFunctionalBase<Space_, DataType_>
192 {
193 public:
194 typedef NodeFunctionalBase<Space_, DataType_> BaseClass;
195 static constexpr int max_assigned_dofs = 2;
196
197 template<typename Function_>
198 struct Value
199 {
200 typedef typename Analytic::EvalTraits<DataType_, Function_>::ValueType Type;
201 };
202
203 protected:
204 typedef typename Space_::TrafoType TrafoType;
205 typedef typename Space_::ShapeType ShapeType;
206 typedef typename TrafoType::template Evaluator<Shape::Vertex, DataType_>::Type TrafoEvalType;
207 typedef typename TrafoEvalType::EvalTraits TrafoEvalTraits;
208 typedef typename TrafoEvalTraits::DomainPointType DomainPointType;
209
210 // declare trafo evaluation data
211 typedef typename TrafoEvalType::template ConfigTraits<TrafoTags::img_point>::EvalDataType TrafoEvalData;
212
213 TrafoEvalType _trafo_eval;
214
215 public:
216 explicit NodeFunctional(const Space_& space) :
217 BaseClass(space),
218 _trafo_eval(space.get_trafo())
219 {
220 }
221
222 void prepare(Index cell_index)
223 {
224 BaseClass::prepare(cell_index);
225 _trafo_eval.prepare(cell_index);
226 }
227
228 void finish()
229 {
230 _trafo_eval.finish();
231 BaseClass::finish();
232 }
233
234 int get_num_assigned_dofs() const
235 {
236 return max_assigned_dofs;
237 }
238
239 template<typename NodeData_, typename Function_>
240 void operator()(NodeData_& node_data, const Function_& function) const
241 {
242 static_assert(std::is_base_of<Analytic::Function, Function_>::value, "invalid function object");
243 static_assert(Function_::can_value, "function cannot compute values");
244 static_assert(Function_::can_grad, "function cannot compute gradients");
245
246 // declare our evaluation traits
247 typedef Analytic::EvalTraits<DataType_, Function_> FuncEvalTraits;
248
249 // declare function evaluator
250 typename Function_::template Evaluator<FuncEvalTraits> func_eval(function);
251
252 // compute trafo data
253 DomainPointType dom_point(DataType_(0));
254 TrafoEvalData trafo_data;
255 _trafo_eval(trafo_data, dom_point);
256
257 // evaluate function
258 const auto func_value = func_eval.value(trafo_data.img_point);
259 const auto func_grad = func_eval.gradient(trafo_data.img_point);
260
261 // set node functional values
262 node_data[0] = func_value;
263 node_data[1] = func_grad[0];
264 }
265 };
266
267 template<
268 typename Space_,
269 typename DataType_>
270 class NodeFunctional<Space_, Shape::Hypercube<2>, 0, DataType_> :
271 public NodeFunctionalBase<Space_, DataType_>
272 {
273 public:
274 typedef NodeFunctionalBase<Space_, DataType_> BaseClass;
275 static constexpr int max_assigned_dofs = 4;
276
277 template<typename Function_>
278 struct Value
279 {
280 typedef typename Analytic::EvalTraits<DataType_, Function_>::ValueType Type;
281 };
282
283 protected:
284 typedef typename Space_::TrafoType TrafoType;
285 typedef typename Space_::ShapeType ShapeType;
286 typedef typename TrafoType::template Evaluator<Shape::Vertex, DataType_>::Type TrafoEvalType;
287 typedef typename TrafoEvalType::EvalTraits TrafoEvalTraits;
288 typedef typename TrafoEvalTraits::DomainPointType DomainPointType;
289
290 // declare trafo evaluation data
291 typedef typename TrafoEvalType::template ConfigTraits<TrafoTags::img_point>::EvalDataType TrafoEvalData;
292
293 TrafoEvalType _trafo_eval;
294
295 public:
296 explicit NodeFunctional(const Space_& space) :
297 BaseClass(space),
298 _trafo_eval(space.get_trafo())
299 {
300 }
301
302 void prepare(Index cell_index)
303 {
304 BaseClass::prepare(cell_index);
305 _trafo_eval.prepare(cell_index);
306 }
307
308 void finish()
309 {
310 _trafo_eval.finish();
311 BaseClass::finish();
312 }
313
314
315 int get_num_assigned_dofs() const
316 {
317 return max_assigned_dofs;
318 }
319
320 template<typename NodeData_, typename Function_>
321 void operator()(NodeData_& node_data, const Function_& function) const
322 {
323 static_assert(std::is_base_of<Analytic::Function, Function_>::value, "invalid function object");
324 static_assert(Function_::can_value, "function cannot compute values");
325 static_assert(Function_::can_grad, "function cannot compute gradients");
326 static_assert(Function_::can_hess, "function cannot compute hessians");
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_(0));
336 TrafoEvalData trafo_data;
337 _trafo_eval(trafo_data, dom_point);
338
339 // evaluate function
340 const auto func_value = func_eval.value(trafo_data.img_point);
341 const auto func_grad = func_eval.gradient(trafo_data.img_point);
342 const auto func_hess = func_eval.hessian(trafo_data.img_point);
343
344 // set node functional values
345 node_data[0] = func_value;
346 node_data[1] = func_grad[0];
347 node_data[2] = func_grad[1];
348 node_data[3] = func_hess[0][1];
349 }
350 };
351 } // namespace Hermite3
352 } // namespace Space
353} // namespace FEAT
FEAT::Space::Hermite3::Evaluator
Hermite-3 Element Evaluator class template declaration.
Definition: evaluator.hpp:116
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