dune-localfunctions  2.4.1
virtualwrappers.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_VIRTUALWRAPPERS_HH
4 #define DUNE_VIRTUALWRAPPERS_HH
5 
6 #include <array>
7 
8 #include <dune/common/function.hh>
9 
13 
14 namespace Dune
15 {
16 
17  // forward declaration needed by friend declarations
18  template<class Imp>
20 
21  // default clone method is the copy constructor
22  template<class Imp, bool IsInterface>
24  {
25  static Imp* clone(const Imp& imp)
26  {
27  return new Imp(imp);
28  }
29  };
30 
31  // if FE derives from virtual interface the clone method is used
32  template<class Imp>
34  {
35  static Imp* clone(const Imp& imp)
36  {
37  return imp.clone();
38  }
39  };
40 
41  // factory template to clone and create an objects
42  template<class Imp>
44  {
46 
47  static Imp* clone(const Imp& imp)
48  {
50  }
51 
52  static Imp* create()
53  {
54  return new Imp;
55  }
56  };
57 
58 
59 
60  // -----------------------------------------------------------------
61  // Basis
62  // -----------------------------------------------------------------
63 
73  template<class T , class Imp>
75  : public virtual LocalBasisVirtualInterface<T>,
76  public LocalBasisVirtualImp<typename LowerOrderLocalBasisTraits<T>::Traits,Imp>
77  {
78  template<class FEImp>
80 
82 
83  protected:
84 
86  LocalBasisVirtualImp( const Imp &imp )
87  : Base(imp)
88  {}
89 
90  public:
91  typedef T Traits;
92 
93  using Base::size;
94  using Base::order;
95  using Base::evaluateFunction;
96  using Base::evaluateJacobian;
97  using Base::evaluate;
98 
100  inline void evaluate(
101  const typename std::template array<int,Traits::diffOrder>& directions,
102  const typename Traits::DomainType& in,
103  std::vector<typename Traits::RangeType>& out) const
104  {
105  // Even for double virtualization it is save to call the template method
106  // since the interface provides it redirecting to the virtual method
107  // of the derived class
108  //
109  // Unfortunately not all compiler can determine Traits::diffOrder from the
110  // type of the arument directions
111  impl_.template evaluate<Traits::diffOrder>(directions, in, out);
112  }
113 
114  protected:
115  using Base::impl_;
116 
117  };
118 
119 
127  template<class DF, int n, class D, class RF, int m, class R, class J, class Imp>
128  class LocalBasisVirtualImp<LocalBasisTraits<DF,n,D,RF,m,R,J,0>, Imp>
129  : public virtual LocalBasisVirtualInterface<LocalBasisTraits<DF,n,D,RF,m,R,J,0> >
130  {
131  template<class FEImp>
133 
134  protected:
135 
137  LocalBasisVirtualImp( const Imp &imp )
138  : impl_(imp)
139  {}
140 
141  public:
143 
145  unsigned int size () const
146  {
147  return impl_.size();
148  }
149 
151  unsigned int order () const
152  {
153  return impl_.order();
154  }
155 
157  inline void evaluateFunction (const typename Traits::DomainType& in,
158  std::vector<typename Traits::RangeType>& out) const
159  {
160  impl_.evaluateFunction(in,out);
161  }
162 
164  inline void evaluateJacobian(
165  const typename Traits::DomainType& in,
166  std::vector<typename Traits::JacobianType>& out) const
167  {
168  impl_.evaluateJacobian(in,out);
169  }
170 
172  inline void evaluate(
173  const typename std::template array<int,Traits::diffOrder>& directions,
174  const typename Traits::DomainType& in,
175  std::vector<typename Traits::RangeType>& out) const
176  {
177  // impl_.template evaluate<Traits::diffOrder> (directions, in,out);
178  // impl_.template evaluate<0> (directions, in,out);
179  impl_.evaluateFunction(in,out);
180  }
181 
182  protected:
183  const Imp& impl_;
184  };
185 
186 
187 
188  // -----------------------------------------------------------------
189  // Interpolation
190  // -----------------------------------------------------------------
191 
200  template<class DomainType, class RangeType, class Imp>
202  : public LocalInterpolationVirtualInterface< DomainType, RangeType >
203  {
204  template<class FEImp>
206 
208 
209  protected:
210 
213  : impl_(imp) {}
214 
215  public:
216 
218 
220 
222  virtual void interpolate (const FunctionType& f, std::vector<CoefficientType>& out) const
223  {
224  impl_.interpolate(f,out);
225  }
226 
227  protected:
228  const Imp& impl_;
229 
230  };
231 
232 
233 
234  // -----------------------------------------------------------------
235  // Coefficients
236  // -----------------------------------------------------------------
237 
244  template<class Imp>
247  {
248  template<class FEImp>
250 
251  protected:
252 
254  LocalCoefficientsVirtualImp( const Imp &imp )
255  : impl_(imp)
256  {}
257 
258  public:
259 
261  std::size_t size () const
262  {
263  return impl_.size();
264  }
265 
267  const LocalKey& localKey (std::size_t i) const
268  {
269  return impl_.localKey(i);
270  }
271 
272  protected:
273  const Imp& impl_;
274 
275  };
276 
277 
278 
279  // -----------------------------------------------------------------
280  // Finite Element
281  // -----------------------------------------------------------------
282 
291  template<class Imp>
293  : public virtual LocalFiniteElementVirtualInterface<typename Imp::Traits::LocalBasisType::Traits>
294  {
295  typedef typename Imp::Traits::LocalBasisType::Traits T;
296  typedef LocalFiniteElementVirtualInterface<T> Interface;
297 
298  public:
299  typedef typename Interface::Traits Traits;
300 
307  {}
308 
311  : impl_(LocalFiniteElementCloneFactory<Imp>::create()),
315  {}
316 
323  {}
324 
326  {
327  delete impl_;
328  }
329 
331  const typename Traits::LocalBasisType& localBasis () const
332  {
333  return localBasisImp_;
334  }
335 
338  {
339  return localCoefficientsImp_;
340  }
341 
344  {
345  return localInterpolationImp_;
346  }
347 
349  unsigned int size () const
350  {
351  return impl_->size();
352  }
353 
355  const GeometryType type () const
356  {
357  return impl_->type();
358  }
359 
366  {
367  return new LocalFiniteElementVirtualImp<Imp>(*this);
368  }
369 
370  protected:
371  const Imp* impl_;
372 
376  const LocalInterpolationVirtualImp<typename T::DomainType,
377  typename T::RangeType,
378  typename Imp::Traits::LocalInterpolationType> localInterpolationImp_;
379  };
380 }
381 #endif
virtual LocalFiniteElementVirtualImp< Imp > * clone() const
clone this wrapper
Definition: virtualwrappers.hh:365
virtual base class for local finite elements with functions
Definition: virtualinterface.hh:381
static Imp * create()
Definition: virtualwrappers.hh:52
virtual base class for a local basis
Definition: virtualinterface.hh:24
void evaluateJacobian(const typename Traits::DomainType &in, std::vector< typename Traits::JacobianType > &out) const
Definition: virtualwrappers.hh:164
LocalBasisVirtualImp(const Imp &imp)
constructor taking an implementation of the interface
Definition: virtualwrappers.hh:137
const LocalKey & localKey(std::size_t i) const
get i'th index
Definition: virtualwrappers.hh:267
static Imp * clone(const Imp &imp)
Definition: virtualwrappers.hh:35
virtual void interpolate(const FunctionType &f, std::vector< CoefficientType > &out) const
determine coefficients interpolating a given function
Definition: virtualwrappers.hh:222
Base::CoefficientType CoefficientType
Definition: virtualwrappers.hh:219
void evaluate(const typename std::template array< int, Traits::diffOrder > &directions, const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
Definition: virtualwrappers.hh:100
Interface::Traits Traits
Definition: virtualwrappers.hh:299
const LocalCoefficientsVirtualImp< typename Imp::Traits::LocalCoefficientsType > localCoefficientsImp_
Definition: virtualwrappers.hh:375
unsigned int order() const
Definition: virtualwrappers.hh:151
~LocalFiniteElementVirtualImp()
Definition: virtualwrappers.hh:325
Definition: virtualwrappers.hh:43
const LocalInterpolationVirtualImp< typename T::DomainType, typename T::RangeType, typename Imp::Traits::LocalInterpolationType > localInterpolationImp_
Definition: virtualwrappers.hh:378
Base::FunctionType FunctionType
Definition: virtualwrappers.hh:217
class for wrapping a finite element using the virtual interface
Definition: virtualwrappers.hh:19
Definition: brezzidouglasmarini1cube2dlocalbasis.hh:14
const Imp & impl_
Definition: virtualwrappers.hh:273
const LocalBasisVirtualImp< T, typename Imp::Traits::LocalBasisType > localBasisImp_
Definition: virtualwrappers.hh:374
class for wrapping a basis using the virtual interface
Definition: virtualwrappers.hh:74
class for wrapping a local interpolation using the virtual interface
Definition: virtualwrappers.hh:201
void evaluate(const typename std::template array< int, Traits::diffOrder > &directions, const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
Definition: virtualwrappers.hh:172
LocalFiniteElementVirtualImp()
Default constructor. Assumes that the implementation class is default constructible as well...
Definition: virtualwrappers.hh:310
typename T::RangeType::field_type CoefficientType
type of the coefficient vector in the interpolate method
Definition: virtualinterface.hh:285
const Imp * impl_
Definition: virtualwrappers.hh:371
Definition: virtualwrappers.hh:23
void evaluateFunction(const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
Definition: virtualwrappers.hh:157
const Traits::LocalBasisType & localBasis() const
Definition: virtualwrappers.hh:331
LocalFiniteElementVirtualImp(const LocalFiniteElementVirtualImp &other)
Copy contructor needed for deep copy.
Definition: virtualwrappers.hh:318
virtual base class for local coefficients
Definition: virtualinterface.hh:354
const Traits::LocalCoefficientsType & localCoefficients() const
Definition: virtualwrappers.hh:337
unsigned int size() const
Definition: virtualwrappers.hh:145
traits helper struct
Definition: localfiniteelementtraits.hh:10
Dune::VirtualFunction< typename T::DomainType, typename T::RangeType > FunctionType
type of virtual function to interpolate
Definition: virtualinterface.hh:282
unsigned int size() const
Number of shape functions in this finite element.
Definition: virtualwrappers.hh:349
Type traits for LocalBasisVirtualInterface.
Definition: localbasis.hh:37
static Imp * clone(const Imp &imp)
Definition: virtualwrappers.hh:47
LI LocalInterpolationType
Definition: localfiniteelementtraits.hh:22
LocalFiniteElementVirtualInterface< typename Imp::Traits::LocalBasisType::Traits > Interface
Definition: virtualwrappers.hh:45
const Traits::LocalInterpolationType & localInterpolation() const
Definition: virtualwrappers.hh:343
LocalBasisTraits< DF, n, D, RF, m, R, J, 0 > Traits
Definition: virtualwrappers.hh:142
std::size_t size() const
number of coefficients
Definition: virtualwrappers.hh:261
LC LocalCoefficientsType
Definition: localfiniteelementtraits.hh:18
const GeometryType type() const
Definition: virtualwrappers.hh:355
class for wrapping local coefficients using the virtual interface
Definition: virtualwrappers.hh:245
const Imp & impl_
Definition: virtualwrappers.hh:228
static Imp * clone(const Imp &imp)
Definition: virtualwrappers.hh:25
T Traits
Definition: virtualwrappers.hh:91
LocalBasisVirtualImp(const Imp &imp)
constructor taking an implementation of the interface
Definition: virtualwrappers.hh:86
LocalCoefficientsVirtualImp(const Imp &imp)
constructor taking an implementation of the Dune::LocalCoefficientsVirtualInterface ...
Definition: virtualwrappers.hh:254
D DomainType
domain type
Definition: localbasis.hh:49
LocalInterpolationVirtualImp(const Imp &imp)
constructor taking an implementation of the Dune::LocalInterpolationVirtualInterface ...
Definition: virtualwrappers.hh:212
LB LocalBasisType
Definition: localfiniteelementtraits.hh:14
LocalFiniteElementVirtualImp(const Imp &imp)
taking a LocalFiniteElementVirtualInterface implementation
Definition: virtualwrappers.hh:302
Describe position of one degree of freedom.
Definition: localkey.hh:21
virtual base class for a local interpolation
Definition: virtualinterface.hh:21