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 P2Bubble
16 {
17 template<
18 typename Space_,
19 typename ShapeType_,
20 typename FaceType_,
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 ShapeType_,
35 typename DataType_>
36 class NodeFunctional<Space_, ShapeType_, Shape::Vertex, DataType_> :
37 public NodeFunctionalBase<Space_, DataType_>
38 {
39 public:
40 typedef NodeFunctionalBase<Space_, DataType_> BaseClass;
41 static constexpr int max_assigned_dofs = 1;
42
43 template<typename Function_>
44 struct Value
45 {
46 typedef typename Analytic::EvalTraits<DataType_, Function_>::ValueType Type;
47 };
48
49 protected:
50 typedef typename Space_::TrafoType TrafoType;
51 typedef typename TrafoType::template Evaluator<Shape::Vertex, DataType_>::Type TrafoEvalType;
52 typedef typename TrafoEvalType::EvalTraits TrafoEvalTraits;
53 typedef typename TrafoEvalTraits::DataType DataType;
54 typedef typename TrafoEvalTraits::DomainPointType DomainPointType;
55
56 // declare trafo evaluation data
57 typedef typename TrafoEvalType::template ConfigTraits<TrafoTags::img_point>::EvalDataType TrafoEvalData;
58
59 TrafoEvalType _trafo_eval;
60
61 public:
62 explicit NodeFunctional(const Space_& space) :
63 BaseClass(space),
64 _trafo_eval(space.get_trafo())
65 {
66 }
67
68 void prepare(Index cell_index)
69 {
70 BaseClass::prepare(cell_index);
71 _trafo_eval.prepare(cell_index);
72 }
73
74 void finish()
75 {
76 _trafo_eval.finish();
77 BaseClass::finish();
78 }
79
80 int get_num_assigned_dofs() const
81 {
82 return max_assigned_dofs;
83 }
84
85 template<typename NodeData_, typename Function_>
86 void operator()(NodeData_& node_data, const Function_& function) const
87 {
88 static_assert(std::is_base_of<Analytic::Function, Function_>::value, "invalid function object");
89 static_assert(Function_::can_value, "function cannot compute values");
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 node_data[0] = func_eval.value(trafo_data.img_point);
104 }
105 };
106
107 template<
108 typename Space_,
109 typename ShapeType_,
110 typename DataType_>
111 class NodeFunctional<Space_, ShapeType_, Shape::Simplex<1>, DataType_> :
112 public NodeFunctionalBase<Space_, DataType_>
113 {
114 public:
115 typedef NodeFunctionalBase<Space_, DataType_> BaseClass;
116 static constexpr int max_assigned_dofs = 1;
117
118 template<typename Function_>
119 struct Value
120 {
121 typedef typename Analytic::EvalTraits<DataType_, Function_>::ValueType Type;
122 };
123
124 protected:
125 typedef typename Space_::TrafoType TrafoType;
126 typedef typename TrafoType::template Evaluator<Shape::Simplex<1>, DataType_>::Type TrafoEvalType;
127 typedef typename TrafoEvalType::EvalTraits TrafoEvalTraits;
128 typedef typename TrafoEvalTraits::DataType DataType;
129 typedef typename TrafoEvalTraits::DomainPointType DomainPointType;
130
131 // declare trafo evaluation data
132 typedef typename TrafoEvalType::template ConfigTraits<TrafoTags::img_point>::EvalDataType TrafoEvalData;
133
134 TrafoEvalType _trafo_eval;
135
136 public:
137 explicit NodeFunctional(const Space_& space) :
138 BaseClass(space),
139 _trafo_eval(space.get_trafo())
140 {
141 }
142
143 void prepare(Index cell_index)
144 {
145 BaseClass::prepare(cell_index);
146 _trafo_eval.prepare(cell_index);
147 }
148
149 void finish()
150 {
151 _trafo_eval.finish();
152 BaseClass::finish();
153 }
154
155 int get_num_assigned_dofs() const
156 {
157 return max_assigned_dofs;
158 }
159
160 template<typename NodeData_, typename Function_>
161 void operator()(NodeData_& node_data, const Function_& function) const
162 {
163 static_assert(std::is_base_of<Analytic::Function, Function_>::value, "invalid function object");
164 static_assert(Function_::can_value, "function cannot compute values");
165
166 // declare our evaluation traits
167 typedef Analytic::EvalTraits<DataType_, Function_> FuncEvalTraits;
168
169 // declare function evaluator
170 typename Function_::template Evaluator<FuncEvalTraits> func_eval(function);
171
172 // compute trafo data
173 DomainPointType dom_point(DataType_(0.5));
174 TrafoEvalData trafo_data;
175 _trafo_eval(trafo_data, dom_point);
176
177 // evaluate function
178 node_data[0] = func_eval.value(trafo_data.img_point);
179 }
180 };
181
182
183 template<
184 typename Space_,
185 int dim_,
186 typename DataType_>
187 class NodeFunctional<Space_, Shape::Simplex<dim_>, Shape::Simplex<dim_>, DataType_> :
188 public NodeFunctionalBase<Space_, DataType_>
189 {
190 public:
191 typedef NodeFunctionalBase<Space_, DataType_> BaseClass;
192 static constexpr int max_assigned_dofs = 1;
193
194 template<typename Function_>
195 struct Value
196 {
197 typedef typename Analytic::EvalTraits<DataType_, Function_>::ValueType Type;
198 };
199
200 protected:
201 typedef typename Space_::TrafoType TrafoType;
202 typedef typename TrafoType::template Evaluator<Shape::Simplex<dim_>, DataType_>::Type TrafoEvalType;
203 typedef typename TrafoEvalType::EvalTraits TrafoEvalTraits;
204 typedef typename TrafoEvalTraits::DataType DataType;
205 typedef typename TrafoEvalTraits::DomainPointType DomainPointType;
206
207 // declare trafo evaluation data
208 typedef typename TrafoEvalType::template ConfigTraits<TrafoTags::img_point>::EvalDataType TrafoEvalData;
209
210 TrafoEvalType _trafo_eval;
211
212 public:
213 explicit NodeFunctional(const Space_& space) :
214 BaseClass(space),
215 _trafo_eval(space.get_trafo())
216 {
217 }
218
219 void prepare(Index cell_index)
220 {
221 BaseClass::prepare(cell_index);
222 _trafo_eval.prepare(cell_index);
223 }
224
225 void finish()
226 {
227 _trafo_eval.finish();
228 BaseClass::finish();
229 }
230
231 int get_num_assigned_dofs() const
232 {
233 return max_assigned_dofs;
234 }
235
236 template<typename NodeData_, typename Function_>
237 void operator()(NodeData_& node_data, const Function_& function) const
238 {
239 static_assert(std::is_base_of<Analytic::Function, Function_>::value, "invalid function object");
240 static_assert(Function_::can_value, "function cannot compute values");
241
242 // declare our evaluation traits
243 typedef Analytic::EvalTraits<DataType_, Function_> FuncEvalTraits;
244
245 // declare function evaluator
246 typename Function_::template Evaluator<FuncEvalTraits> func_eval(function);
247
248 // compute trafo data
249 DomainPointType dom_point;
250 for(int i(0); i < dim_; ++i)
251 dom_point[i] = Shape::ReferenceCell<Shape::Simplex<dim_>>::template centre<DataType_>(i);
252 TrafoEvalData trafo_data;
253 _trafo_eval(trafo_data, dom_point);
254
255 // evaluate function
256 node_data[0] = func_eval.value(trafo_data.img_point);
257 }
258 };
259 } // namespace P2Bubble
260 } // namespace Space
261} // namespace FEAT
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::Space::P2Bubble::Evaluator
P2-Bubble Element Evaluator class template declaration.
Definition: evaluator.hpp:35
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
FEAT::Shape::Simplex
Simplex shape tag struct template.
Definition: shape.hpp:44