dune-fem  2.4.1-rc
localfunctiontuple.hh
Go to the documentation of this file.
1 #ifndef DUNE_FEM_PASS_COMMON_LOCALFUNCTIONTUPLE_HH
2 #define DUNE_FEM_PASS_COMMON_LOCALFUNCTIONTUPLE_HH
3 
4 #include <cassert>
5 #include <cstddef>
6 #include <tuple>
7 
8 #include <dune/common/exceptions.hh>
9 #include <dune/common/forloop.hh>
10 #include <dune/common/nullptr.hh>
11 #include <dune/common/tuples.hh>
12 #include <dune/common/tupleutility.hh>
13 
15 
16 #include "localfunctionselector.hh"
17 
18 namespace Dune
19 {
20 
21  namespace Fem
22  {
23  // LocalFunctionEvaluator
24  // ----------------------
25 
26  /*
27  * \brief Choose local function for given discrete function.
28  * Use LocalFunctionSelector to define the type of
29  * the local function.
30  */
31  template< class DiscreteFunction >
33  {
34  typedef typename Dune::Fem::LocalFunctionSelector<
35  typename Dune::TypeTraits< DiscreteFunction >::ReferredType
37 
38  static Type apply ( const DiscreteFunction &discreteFunction )
39  {
40  return Type( discreteFunction );
41  }
42  };
43 
44 
45 
46  // RangeTypeEvaluator
47  // ------------------
48 
49  /*
50  * \brief Get range type from local function type.
51  */
52  template< class LocalFunction >
54  {
55  typedef typename LocalFunction::RangeType Type;
56  };
57 
58 
59 
60  // JacobianRangeTypeEvaluator
61  // --------------------------
62 
63  /*
64  * \brief Get jacobian range type from local function type.
65  */
66  template< class LocalFunction >
68  {
70  };
71 
72 
73 
74  // HessianRangeTypeEvaluator
75  // --------------------------
76 
77  /*
78  * \brief Get hessian range type from local function type.
79  */
80  template< class LocalFunction >
82  {
84  };
85 
86  // LocalFunctionTuple
87  // ------------------
88 
89  /*
90  * \brief A wrapper for a tuple of localfunctions. It's interface
91  * mimicks the LocalFunction interface
92  * (see dune/fem/function/localfunction/localfunction.hh).
93  */
94  template< class DiscreteFunctionTuple, class Entity,
95  size_t TupleSize = tuple_size< DiscreteFunctionTuple >::value >
97  {
99 
100  template< int pos > struct SetEntity;
101  template< int pos > struct Evaluate;
102  template< int pos > struct EvaluateQuadrature;
103  template< int pos > struct Jacobian;
104  template< int pos > struct Hessian;
105 
106  public:
108  typedef DiscreteFunctionTuple DiscreteFunctionTupleType;
110  typedef Entity EntityType;
111 
112  protected:
113  typedef typename Dune::ForEachType< LocalFunctionEvaluator, DiscreteFunctionTupleType >::Type LocalFunctionTupleType;
114 
115  typedef typename EntityType::Geometry GeometryType;
116  typedef typename GeometryType::LocalCoordinate LocalCoordinateType;
117 
118  public:
119  // ! \brief type of range type tuple
120  typedef typename Dune::ForEachType< RangeTypeEvaluator, LocalFunctionTupleType >::Type RangeTupleType;
121  // ! \brief type of jacobian range type tuple
122  typedef typename Dune::ForEachType< JacobianRangeTypeEvaluator, LocalFunctionTupleType >::Type JacobianRangeTupleType;
123  // ! \brief type of hessian range type tuple
124  typedef typename Dune::ForEachType< HessianRangeTypeEvaluator, LocalFunctionTupleType >::Type HessianRangeTupleType;
125 
126  template< int i >
127  struct Get
128  {
129  typedef typename std::tuple_element< i, LocalFunctionTupleType >::type Type;
130  };
131 
132  template< class Factory >
133  LocalFunctionTuple ( Factory factory )
134  : localFunctionTuple_( Dune::transformTuple< LocalFunctionEvaluator, Factory >( factory ) )
135  {}
136 
141  void init ( const EntityType &entity )
142  {
143  ForLoop< SetEntity, 0, TupleSize-1 >::apply( localFunctions(), entity );
144  }
145 
147  const EntityType &entity () const
148  {
149  return std::get< 0 >( localFunctions() ).entity();
150  }
151 
157  template< class Point >
158  void evaluate ( const Point &x, RangeTupleType &values ) const
159  {
160  ForLoop< Evaluate, 0, TupleSize-1 >::apply( localFunctions(), x, values );
161  }
162 
168  template< class Point >
169  void jacobian ( const Point &x, JacobianRangeTupleType &jacobians ) const
170  {
171  ForLoop< Jacobian, 0, TupleSize-1 >::apply( localFunctions(), x, jacobians );
172  }
173 
179  template< class Point >
180  void hessian ( const Point &x, HessianRangeTupleType &hessians ) const
181  {
182  ForLoop< Hessian, 0, TupleSize-1 >::apply( localFunctions(), x, hessians );
183  }
184 
190  template< class QuadratureType, class TupleVectorType >
191  void evaluateQuadrature ( const QuadratureType &quadrature, TupleVectorType &vector ) const
192  {
193  assert( vector.size() >= quadrature.nop() );
194  ForLoop< EvaluateQuadrature, 0, TupleSize-1 >::apply( quadrature, localFunctions(), vector );
195  }
196 
198  template< int i >
199  typename Get< i >::Type &get () { return std::get< i >( localFunctions() ); }
200 
202  template< int i >
203  const typename Get< i >::Type &get () const { return std::get< i >( localFunctions() ); }
204 
205  protected:
206  LocalFunctionTupleType &localFunctions () { return localFunctionTuple_; }
207  const LocalFunctionTupleType &localFunctions () const { return localFunctionTuple_; }
208 
209  private:
210  mutable LocalFunctionTupleType localFunctionTuple_;
211  };
212 
213 
214 
215  // LocalFunctionTuple for Empty Tuples
216  // -----------------------------------
217 
218  template< class DiscreteFunctionTuple, class Entity >
219  class LocalFunctionTuple< DiscreteFunctionTuple, Entity, 0 >
220  {
222 
223  public:
224  typedef DiscreteFunctionTuple DiscreteFunctionTupleType;
225  typedef Entity EntityType;
226 
227  typedef std::tuple<> RangeTupleType;
228  typedef std::tuple<> JacobianRangeTupleType;
229  typedef std::tuple<> HessianRangeTupleType;
230 
231  template< class Factory >
232  LocalFunctionTuple ( Factory factory )
233  : entity_( nullptr )
234  {}
235 
236  void init ( const EntityType &entity ) { entity_ = &entity; }
237 
238  const EntityType &entity () const
239  {
240  assert( entity_ );
241  return *entity_;
242  }
243 
244  template< class Point >
245  void evaluate ( const Point &x, RangeTupleType &values ) const
246  {}
247 
248  template< class Point >
249  void jacobian ( const Point &x, JacobianRangeTupleType &jacobians ) const
250  {}
251 
252  template< class Point >
253  void hessian ( const Point &x, HessianRangeTupleType &hessians ) const
254  {}
255 
256  template< class QuadratureType, class TupleVectorType >
257  void evaluateQuadrature ( const QuadratureType &quadrature, TupleVectorType &vector ) const
258  {
259  assert( vector.size() >= quadrature.nop() );
260  }
261 
262  private:
263  EntityType *entity_;
264  };
265 
266 
267 
268  // Implementation of LocalFunctionTuple::SetEntity
269  // -----------------------------------------------
270 
271  template< class DiscreteFunctionTuple, class Entity, size_t TupleSize >
272  template< int pos >
273  struct LocalFunctionTuple< DiscreteFunctionTuple, Entity, TupleSize >::SetEntity
274  {
275  static void apply ( LocalFunctionTupleType &localFunctions,
276  const EntityType &entity )
277  {
278  std::get< pos >( localFunctions ).init( entity );
279  }
280  };
281 
282 
283 
284  // Implementation of LocalFunctionTuple::Evaluate
285  // ----------------------------------------------
286 
287  template< class DiscreteFunctionTuple, class Entity, size_t TupleSize >
288  template< int pos >
289  struct LocalFunctionTuple< DiscreteFunctionTuple, Entity, TupleSize >::Evaluate
290  {
291  template< class Point >
292  static void apply ( const LocalFunctionTupleType &localFunctions,
293  const Point &x,
294  RangeTupleType &values )
295  {
296  std::get< pos >( localFunctions ).evaluate( x, std::get< pos >( values ) );
297  }
298  };
299 
300 
301 
302  // Implementation of LocalFunctionTuple::EvaluateQuadrature
303  // --------------------------------------------------------
304 
305  template< class DiscreteFunctionTuple, class Entity, size_t TupleSize >
306  template< int pos >
307  struct LocalFunctionTuple< DiscreteFunctionTuple, Entity, TupleSize >::EvaluateQuadrature
308  {
309  template< class Quadrature, class VectorOfTuples >
310  static void apply ( const Quadrature &quadrature,
311  const LocalFunctionTupleType &localFunctions,
312  VectorOfTuples &vectorOfTuples )
313  {
314  TupleToVectorConverter< VectorOfTuples, pos > vector( vectorOfTuples );
315  std::get< pos >( localFunctions ).evaluateQuadrature( quadrature, vector );
316  }
317  };
318 
319 
320 
321  // Implementation of LocalFunctionTuple::Jacobian
322  // ----------------------------------------------
323 
324  template< class DiscreteFunctionTuple, class Entity, size_t TupleSize >
325  template< int pos >
326  struct LocalFunctionTuple< DiscreteFunctionTuple, Entity, TupleSize >::Jacobian
327  {
328  template< class Point >
329  static void apply ( const LocalFunctionTupleType &localFunctions,
330  const Point &x,
331  JacobianRangeTupleType &jacobians )
332  {
333  std::get< pos >( localFunctions ).jacobian( x, std::get< pos >( jacobians ) );
334  }
335  };
336 
337 
338 
339  // Implementation of LocalFunctionTuple::Hessian
340  // ---------------------------------------------
341 
342  template< class DiscreteFunctionTuple, class Entity, size_t TupleSize >
343  template< int pos >
344  struct LocalFunctionTuple< DiscreteFunctionTuple, Entity, TupleSize >::Hessian
345  {
346  template< class Point >
347  static void apply ( const LocalFunctionTupleType &localFunctions,
348  const Point &x,
349  HessianRangeTupleType &hessians )
350  {
351  std::get< pos >( localFunctions ).hessian( x, std::get< pos >( hessians ) );
352  }
353  };
354 
355  } // namespace Fem
356 
357 
358 
359  // get for LocalFunctionTuple
360  // --------------------------
361 
362  template< int i, class DiscreteFunctionTuple, class Entity, size_t TupleSize >
365  {
366  return localFunctionTuple.template get< i >();
367  }
368 
369  template< int i, class DiscreteFunctionTuple, class Entity, size_t TupleSize >
372  {
373  return localFunctionTuple.template get< i >();
374  }
375 
376 } // namespace Dune
377 
378 
379 
380 // Some Specializations for Tuple Access
381 // -------------------------------------
382 
384  // tuple_element for LocalFunctionTuple
385  // ------------------------------------
386 
387  template< size_t i, class DiscreteFunctionTuple, class Entity, size_t TupleSize >
388  struct tuple_element< i, Dune::Fem::LocalFunctionTuple< DiscreteFunctionTuple, Entity, TupleSize > >
389  {
391  };
393 
394 #endif // #ifndef DUNE_FEM_PASS_COMMON_LOCALFUNCTIONTUPLE_HH
GeometryType::LocalCoordinate LocalCoordinateType
Definition: localfunctiontuple.hh:116
std::tuple RangeTupleType
Definition: localfunctiontuple.hh:227
Dune::Fem::LocalFunctionSelector< typename Dune::TypeTraits< DiscreteFunction >::ReferredType >::Type Type
Definition: localfunctiontuple.hh:36
Dune::ForEachType< HessianRangeTypeEvaluator, LocalFunctionTupleType >::Type HessianRangeTupleType
Definition: localfunctiontuple.hh:124
DiscreteFunctionTuple DiscreteFunctionTupleType
discrete function tuple
Definition: localfunctiontuple.hh:104
void evaluate(const Point &x, RangeTupleType &values) const
evaluate local functions
Definition: localfunctiontuple.hh:158
const EntityType & entity() const
return entity
Definition: localfunctiontuple.hh:147
Definition: localfunctiontuple.hh:96
Definition: localfunctiontuple.hh:32
DiscreteFunctionTuple DiscreteFunctionTupleType
Definition: localfunctiontuple.hh:224
static Type apply(const DiscreteFunction &discreteFunction)
Definition: localfunctiontuple.hh:38
LocalFunction::JacobianRangeType Type
Definition: localfunctiontuple.hh:69
void hessian(const Point &x, HessianRangeTupleType &hessians) const
Definition: localfunctiontuple.hh:253
Dune::ForEachType< RangeTypeEvaluator, LocalFunctionTupleType >::Type RangeTupleType
Definition: localfunctiontuple.hh:120
std::tuple JacobianRangeTupleType
Definition: localfunctiontuple.hh:228
FunctionSpaceType::JacobianRangeType JacobianRangeType
type of the Jacobian, i.e., type of evaluated Jacobian matrix
Definition: localfunction.hh:73
void init(const EntityType &entity)
set local functions to given entity
Definition: localfunctiontuple.hh:141
void jacobian(const Point &x, JacobianRangeTupleType &jacobians) const
evaluate jacobians of local functions
Definition: localfunctiontuple.hh:169
void evaluate(const Point &x, RangeTupleType &values) const
Definition: localfunctiontuple.hh:245
Dune::ForEachType< JacobianRangeTypeEvaluator, LocalFunctionTupleType >::Type JacobianRangeTupleType
Definition: localfunctiontuple.hh:122
LocalFunctionTuple(Factory factory)
Definition: localfunctiontuple.hh:232
Definition: coordinate.hh:4
const EntityType & entity() const
Definition: localfunctiontuple.hh:238
Definition: localfunctiontuple.hh:67
wrapper class to convert a vector of tuples of RangeTypes into something that behaves like a vector< ...
Definition: tupleutility.hh:295
#define DUNE_CLOSE_TUPLE_NAMESPACE
Definition: tupleutility.hh:13
void evaluateQuadrature(const QuadratureType &quadrature, TupleVectorType &vector) const
evaluate local functions for quadrature
Definition: localfunctiontuple.hh:191
LocalFunctionTuple(Factory factory)
Definition: localfunctiontuple.hh:133
#define DUNE_OPEN_TUPLE_NAMESPACE
Definition: tupleutility.hh:12
Dune::Fem::LocalFunctionTuple< DiscreteFunctionTuple, Entity, TupleSize >::template Get< i >::Type type
Definition: localfunctiontuple.hh:390
LocalFunction::HessianRangeType Type
Definition: localfunctiontuple.hh:83
Definition: localfunctiontuple.hh:53
void jacobian(const Point &x, JacobianRangeTupleType &jacobians) const
Definition: localfunctiontuple.hh:249
Dune::ForEachType< LocalFunctionEvaluator, DiscreteFunctionTupleType >::Type LocalFunctionTupleType
Definition: localfunctiontuple.hh:113
A constant local function carrying values for one entity.
Definition: const.hh:31
LocalFunction::RangeType Type
Definition: localfunctiontuple.hh:55
Definition: localfunctiontuple.hh:127
LocalFunctionTupleType & localFunctions()
Definition: localfunctiontuple.hh:206
const LocalFunctionTupleType & localFunctions() const
Definition: localfunctiontuple.hh:207
std::tuple HessianRangeTupleType
Definition: localfunctiontuple.hh:229
EntityType::Geometry GeometryType
Definition: localfunctiontuple.hh:115
Definition: localfunctionselector.hh:20
std::tuple_element< i, LocalFunctionTupleType >::type Type
Definition: localfunctiontuple.hh:129
Entity EntityType
entity type
Definition: localfunctiontuple.hh:110
void evaluateQuadrature(const QuadratureType &quadrature, TupleVectorType &vector) const
Definition: localfunctiontuple.hh:257
Definition: localfunctiontuple.hh:81
Entity EntityType
Definition: localfunctiontuple.hh:225
FunctionSpaceType::HessianRangeType HessianRangeType
type of the Hessian
Definition: localfunction.hh:75
void init(const EntityType &entity)
Definition: localfunctiontuple.hh:236
FunctionSpaceType::RangeType RangeType
type of range vectors, i.e., type of function values
Definition: localfunction.hh:71
actual interface class for quadratures
Definition: quadrature.hh:320
void hessian(const Point &x, HessianRangeTupleType &hessians) const
evaluate hessians of local functions
Definition: localfunctiontuple.hh:180