dune-localfunctions  2.4.1
virtualinterface.hh
Go to the documentation of this file.
1 // -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 // vi: set et ts=4 sw=2 sts=2:
3 #ifndef DUNE_VIRTUALINTERFACE_HH
4 #define DUNE_VIRTUALINTERFACE_HH
5 
6 #include <array>
7 
8 #include <dune/common/function.hh>
9 
10 #include <dune/geometry/type.hh>
11 
15 
16 namespace Dune
17 {
18 
19  // forward declaration needed by the helper traits
20  template<class DomainType, class RangeType>
22 
23  template<class T>
25 
26  // -----------------------------------------------------------------
27  // Helper traits classes
28  // -----------------------------------------------------------------
29 
35  template<class T>
37  {
39  typedef LocalBasisTraits<
40  typename T::DomainFieldType,
41  T::dimDomain,
42  typename T::DomainType,
43  typename T::RangeFieldType,
44  T::dimRange,
45  typename T::RangeType,
46  typename T::JacobianType,
47  T::diffOrder-1> Traits;
48  };
49 
56  template<class T, int order>
58  {
60  typedef LocalBasisTraits<
61  typename T::DomainFieldType,
62  T::dimDomain,
63  typename T::DomainType,
64  typename T::RangeFieldType,
65  T::dimRange,
66  typename T::RangeType,
67  typename T::JacobianType,
68  order> Traits;
69  };
70 
76  template<class FE>
78  {
79  typedef typename FE::Traits::LocalBasisType::Traits::DomainType DomainType;
80  typedef typename FE::Traits::LocalBasisType::Traits::RangeType RangeType;
81 
83  typedef typename FE::Traits::LocalInterpolationType Implementation;
84 
85  public:
86 
87  typedef VirtualFunction<DomainType, RangeType> VirtualFunctionBase;
88  typedef Function<const DomainType&, RangeType&> FunctionBase;
89 
95  typedef typename conditional<IsBaseOf<Interface, Implementation>::value, VirtualFunctionBase, FunctionBase>::type type;
96  };
97 
98 
99 
100  // -----------------------------------------------------------------
101  // Basis
102  // -----------------------------------------------------------------
103 
104  // current versions of doxygen (<= 1.6.2) enter an infinite loop when parsing
105  // the following class
106 #ifndef DOXYGEN
107 
121  template<class T>
122  class LocalBasisVirtualInterfaceBase :
123  public virtual LocalBasisVirtualInterface<typename LowerOrderLocalBasisTraits<T>::Traits>
124  {
126  public:
127  typedef T Traits;
128 
130  virtual void evaluate (
131  const typename std::template array<int,Traits::diffOrder>& directions,
132  const typename Traits::DomainType& in,
133  std::vector<typename Traits::RangeType>& out) const = 0;
134 
135  using BaseInterface::evaluate;
136  };
137 #endif // DOXYGEN
138 
145  template<class DF, int n, class D, class RF, int m, class R, class J>
146  class LocalBasisVirtualInterfaceBase<LocalBasisTraits<DF,n,D,RF,m,R,J,0> >
147  {
148  public:
150 
152 
154  virtual unsigned int size () const = 0;
155 
157  virtual unsigned int order () const = 0;
158 
164  virtual void evaluateFunction (const typename Traits::DomainType& in,
165  std::vector<typename Traits::RangeType>& out) const = 0;
166 
175  virtual void evaluateJacobian(const typename Traits::DomainType& in, // position
176  std::vector<typename Traits::JacobianType>& out) const = 0;
177 
179  virtual void evaluate (
180  const typename std::template array<int,Traits::diffOrder>& directions,
181  const typename Traits::DomainType& in,
182  std::vector<typename Traits::RangeType>& out) const = 0;
183 
184  };
185 
195  template<class T>
197  public virtual LocalBasisVirtualInterfaceBase<T>
198  {
199  typedef LocalBasisVirtualInterfaceBase<T> BaseInterface;
200  public:
201  typedef T Traits;
202 
204  template <int k>
205  void evaluate (
206  const typename std::template array<int,k>& directions,
207  const typename Traits::DomainType& in,
208  std::vector<typename Traits::RangeType>& out) const
209  {
210  typedef LocalBasisVirtualInterfaceBase<typename FixedOrderLocalBasisTraits<T,k>::Traits > OrderKBaseInterface;
211  const OrderKBaseInterface& asBase = *this;
212  asBase.evaluate(directions, in, out);
213  }
214 
215  using BaseInterface::size;
216  using BaseInterface::order;
217  using BaseInterface::evaluateFunction;
218  using BaseInterface::evaluateJacobian;
219  /* Unfortunately, the intel compiler cannot use the different evaluate
220  * methods with varying argument lists. :-( */
221 #ifndef __INTEL_COMPILER
222  using BaseInterface::evaluate;
223 #endif
224  };
225 
226 
227 
228 
229  // -----------------------------------------------------------------
230  // Interpolation
231  // -----------------------------------------------------------------
232 
245  template<class DomainType, class RangeType>
247  {
248  public:
249 
251  typedef Dune::VirtualFunction<DomainType, RangeType> FunctionType;
252 
254  typedef typename RangeType::field_type CoefficientType;
255 
257 
265  virtual void interpolate (const FunctionType& f, std::vector<CoefficientType>& out) const = 0;
266  };
267 
275  template<class DomainType, class RangeType>
277  : public LocalInterpolationVirtualInterfaceBase<DomainType, RangeType>
278  {
279  public:
280 
282  typedef Dune::VirtualFunction<DomainType, RangeType> FunctionType;
283 
285  typedef typename RangeType::field_type CoefficientType;
286 
287 
289 
290  // This method is only notet again for to make the documentation complete.
291 
299  virtual void interpolate (const FunctionType& f, std::vector<CoefficientType>& out) const = 0;
300 
303  template<class F>
304  void interpolate (const F& f, std::vector<CoefficientType>& out) const
305  {
307  asBase.interpolate(VirtualFunctionWrapper<F>(f),out);
308  }
309 
310  template<class F, class C>
311  void interpolate (const F& f, std::vector<C>& out) const
312  {
313  std::vector<CoefficientType> outDummy;
315  asBase.interpolate(VirtualFunctionWrapper<F>(f),outDummy);
316  out.resize(outDummy.size());
317  for(typename std::vector<CoefficientType>::size_type i=0; i<outDummy.size(); ++i)
318  out[i] = outDummy[i];
319  }
320 
321  private:
322 
323  template <typename F>
324  struct VirtualFunctionWrapper
325  : public FunctionType
326  {
327  public:
328  VirtualFunctionWrapper(const F &f)
329  : f_(f)
330  {}
331 
332  virtual ~VirtualFunctionWrapper() {}
333 
334  virtual void evaluate(const DomainType& x, RangeType& y) const
335  {
336  f_.evaluate(x,y);
337  }
338 
339  const F &f_;
340  };
341  };
342 
343 
344 
345  // -----------------------------------------------------------------
346  // Coefficients
347  // -----------------------------------------------------------------
348 
355  {
356  public:
357 
359 
361  virtual std::size_t size () const = 0;
362 
364  const virtual LocalKey& localKey (std::size_t i) const = 0;
365 
366  };
367 
368 
369 
370  // -----------------------------------------------------------------
371  // Finite Element
372  // -----------------------------------------------------------------
373 
380  template<class T>
382  : public virtual LocalFiniteElementVirtualInterface<typename LowerOrderLocalBasisTraits<T>::Traits >
383  {
385 
386  public:
387  typedef LocalFiniteElementTraits<
391  typename T::DomainType,
392  typename T::RangeType> > Traits;
393 
395  virtual const typename Traits::LocalBasisType& localBasis () const = 0;
396 
397  using BaseInterface::localBasis;
398  using BaseInterface::localCoefficients;
399  using BaseInterface::localInterpolation;
400  using BaseInterface::type;
401 
402  virtual LocalFiniteElementVirtualInterface<T>* clone() const = 0;
403  };
404 
405 
412  template<class DF, int n, class D, class RF, int m, class R, class J>
414  {
416 
417  public:
418  typedef LocalFiniteElementTraits<
422  typename T::DomainType,
423  typename T::RangeType> > Traits;
424 
426 
428  virtual const typename Traits::LocalBasisType& localBasis () const = 0;
429 
431  virtual const typename Traits::LocalCoefficientsType& localCoefficients () const = 0;
432 
434  virtual const typename Traits::LocalInterpolationType& localInterpolation () const = 0;
435 
437  virtual unsigned int size () const = 0;
438 
440  virtual const GeometryType type () const = 0;
441 
442  virtual LocalFiniteElementVirtualInterface<T>* clone() const = 0;
443  };
444 
445 }
446 #endif
Definition: tensor.hh:165
void interpolate(const F &f, std::vector< CoefficientType > &out) const
determine coefficients interpolating a given function
Definition: virtualinterface.hh:304
traits helper struct
Definition: localfiniteelementtraits.hh:10
LocalFiniteElementTraits< LocalBasisVirtualInterface< T >, LocalCoefficientsVirtualInterface, LocalInterpolationVirtualInterface< typename T::DomainType, typename T::RangeType > > Traits
Definition: virtualinterface.hh:392
Type traits for LocalBasisVirtualInterface.
Definition: localbasis.hh:37
Dune::VirtualFunction< DomainType, RangeType > FunctionType
type of virtual function to interpolate
Definition: virtualinterface.hh:282
VirtualFunction< DomainType, RangeType > VirtualFunctionBase
Definition: virtualinterface.hh:87
virtual ~LocalInterpolationVirtualInterface()
Definition: virtualinterface.hh:288
Return a proper base class for functions to use with LocalInterpolation.
Definition: virtualinterface.hh:77
conditional< IsBaseOf< Interface, Implementation >::value, VirtualFunctionBase, FunctionBase >::type type
Base class type for functions to use with LocalInterpolation.
Definition: virtualinterface.hh:95
R RangeType
range type
Definition: localbasis.hh:61
virtual base class for local finite elements with functions
Definition: virtualinterface.hh:381
RangeType::field_type CoefficientType
type of the coefficient vector in the interpolate method
Definition: virtualinterface.hh:254
Describe position of one degree of freedom.
Definition: localkey.hh:21
LocalBasisTraits< typename T::DomainFieldType, T::dimDomain, typename T::DomainType, typename T::RangeFieldType, T::dimRange, typename T::RangeType, typename T::JacobianType, T::diffOrder-1 > Traits
The LocalBasisTraits with one order lower.
Definition: virtualinterface.hh:47
LocalBasisTraits< typename T::DomainFieldType, T::dimDomain, typename T::DomainType, typename T::RangeFieldType, T::dimRange, typename T::RangeType, typename T::JacobianType, order > Traits
The LocalBasisTraits specified order.
Definition: virtualinterface.hh:68
virtual base class for local coefficients
Definition: virtualinterface.hh:354
Definition: brezzidouglasmarini1cube2dlocalbasis.hh:14
LI LocalInterpolationType
Definition: localfiniteelementtraits.hh:22
virtual base class for a local basis
Definition: virtualinterface.hh:24
Construct LocalBasisTraits with fixed diff order.
Definition: virtualinterface.hh:57
LC LocalCoefficientsType
Definition: localfiniteelementtraits.hh:18
Dune::VirtualFunction< DomainType, RangeType > FunctionType
type of virtual function to interpolate
Definition: virtualinterface.hh:251
RangeType::field_type CoefficientType
type of the coefficient vector in the interpolate method
Definition: virtualinterface.hh:285
virtual void interpolate(const FunctionType &f, std::vector< CoefficientType > &out) const =0
determine coefficients interpolating a given function
virtual ~LocalCoefficientsVirtualInterface()
Definition: virtualinterface.hh:358
void interpolate(const F &f, std::vector< C > &out) const
Definition: virtualinterface.hh:311
LB LocalBasisType
Definition: localfiniteelementtraits.hh:14
virtual base class for a local interpolation
Definition: virtualinterface.hh:246
void evaluate(const typename std::template array< int, k > &directions, const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
Definition: virtualinterface.hh:205
D DomainType
domain type
Definition: localbasis.hh:49
virtual ~LocalInterpolationVirtualInterfaceBase()
Definition: virtualinterface.hh:256
LocalBasisTraits< DF, n, D, RF, m, R, J, 0 > Traits
Definition: virtualinterface.hh:149
Construct LocalBasisTraits with one diff order lower.
Definition: virtualinterface.hh:36
T Traits
Definition: virtualinterface.hh:201
virtual base class for a local interpolation
Definition: virtualinterface.hh:21
Function< const DomainType &, RangeType & > FunctionBase
Definition: virtualinterface.hh:88
LocalFiniteElementTraits< LocalBasisVirtualInterface< T >, LocalCoefficientsVirtualInterface, LocalInterpolationVirtualInterface< typename T::DomainType, typename T::RangeType > > Traits
Definition: virtualinterface.hh:423