dune-localfunctions  2.5.0
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/deprecated.hh>
9 #include <dune/common/function.hh>
10 
14 
15 namespace Dune
16 {
17 
18  // forward declaration needed by friend declarations
19  template<class Imp>
21 
22  // default clone method is the copy constructor
23  template<class Imp, bool IsInterface>
25  {
26  static Imp* clone(const Imp& imp)
27  {
28  return new Imp(imp);
29  }
30  };
31 
32  // if FE derives from virtual interface the clone method is used
33  template<class Imp>
35  {
36  static Imp* clone(const Imp& imp)
37  {
38  return imp.clone();
39  }
40  };
41 
42  // factory template to clone and create an objects
43  template<class Imp>
45  {
47 
48  static Imp* clone(const Imp& imp)
49  {
51  }
52 
53  static Imp* create()
54  {
55  return new Imp;
56  }
57  };
58 
59 
60 
61  // -----------------------------------------------------------------
62  // Basis
63  // -----------------------------------------------------------------
64 
74  template<class T , class Imp>
76  : public virtual LocalBasisVirtualInterface<T>,
77  public LocalBasisVirtualImp<typename LowerOrderLocalBasisTraits<T>::Traits,Imp>
78  {
79  template<class FEImp>
81 
83 
84  protected:
85 
87  LocalBasisVirtualImp( const Imp &imp )
88  : Base(imp)
89  {}
90 
91  public:
92  typedef T Traits;
93 
94  using Base::size;
95  using Base::order;
96  using Base::evaluateFunction;
97  using Base::evaluateJacobian;
98  using Base::evaluate;
99  using Base::partial;
100 
101 
103  inline void evaluate(
104  const std::array<int,Traits::diffOrder>& directions,
105  const typename Traits::DomainType& in,
106  std::vector<typename Traits::RangeType>& out) const
107  {
108  // Even for double virtualization it is save to call the template method
109  // since the interface provides it redirecting to the virtual method
110  // of the derived class
111  //
112  // Unfortunately not all compilers can determine Traits::diffOrder from
113  // the type of the argument directions
114  DUNE_NO_DEPRECATED_BEGIN
115  impl_.template evaluate<Traits::diffOrder>(directions, in, out);
116  DUNE_NO_DEPRECATED_END
117  }
118 
119  protected:
120  using Base::impl_;
121 
122  };
123 
124 
132  template<class DF, int n, class D, class RF, int m, class R, class J, class Imp>
133  class LocalBasisVirtualImp<LocalBasisTraits<DF,n,D,RF,m,R,J,0>, Imp>
134  : public virtual LocalBasisVirtualInterface<LocalBasisTraits<DF,n,D,RF,m,R,J,0> >
135  {
136  template<class FEImp>
138 
139  protected:
140 
142  LocalBasisVirtualImp( const Imp &imp )
143  : impl_(imp)
144  {}
145 
146  public:
148 
150  unsigned int size () const
151  {
152  return impl_.size();
153  }
154 
156  unsigned int order () const
157  {
158  return impl_.order();
159  }
160 
162  inline void evaluateFunction (const typename Traits::DomainType& in,
163  std::vector<typename Traits::RangeType>& out) const
164  {
165  impl_.evaluateFunction(in,out);
166  }
167 
169  inline void evaluateJacobian(
170  const typename Traits::DomainType& in,
171  std::vector<typename Traits::JacobianType>& out) const
172  {
173  impl_.evaluateJacobian(in,out);
174  }
175 
181  void partial(const std::array<unsigned int,Traits::dimDomain>& order,
182  const typename Traits::DomainType& in,
183  std::vector<typename Traits::RangeType>& out) const
184  {
185  impl_.partial(order,in,out);
186  }
187 
189  inline void evaluate(
190  const std::array<int,Traits::diffOrder>& directions,
191  const typename Traits::DomainType& in,
192  std::vector<typename Traits::RangeType>& out) const
193  {
194  // impl_.template evaluate<Traits::diffOrder> (directions, in,out);
195  // impl_.template evaluate<0> (directions, in,out);
196  impl_.evaluateFunction(in,out);
197  }
198 
199  protected:
200  const Imp& impl_;
201  };
202 
203 
204 
205  // -----------------------------------------------------------------
206  // Interpolation
207  // -----------------------------------------------------------------
208 
217  template<class DomainType, class RangeType, class Imp>
219  : public LocalInterpolationVirtualInterface< DomainType, RangeType >
220  {
221  template<class FEImp>
223 
225 
226  protected:
227 
230  : impl_(imp) {}
231 
232  public:
233 
235 
237 
239  virtual void interpolate (const FunctionType& f, std::vector<CoefficientType>& out) const
240  {
241  impl_.interpolate(f,out);
242  }
243 
244  protected:
245  const Imp& impl_;
246 
247  };
248 
249 
250 
251  // -----------------------------------------------------------------
252  // Coefficients
253  // -----------------------------------------------------------------
254 
261  template<class Imp>
264  {
265  template<class FEImp>
267 
268  protected:
269 
271  LocalCoefficientsVirtualImp( const Imp &imp )
272  : impl_(imp)
273  {}
274 
275  public:
276 
278  std::size_t size () const
279  {
280  return impl_.size();
281  }
282 
284  const LocalKey& localKey (std::size_t i) const
285  {
286  return impl_.localKey(i);
287  }
288 
289  protected:
290  const Imp& impl_;
291 
292  };
293 
294 
295 
296  // -----------------------------------------------------------------
297  // Finite Element
298  // -----------------------------------------------------------------
299 
308  template<class Imp>
310  : public virtual LocalFiniteElementVirtualInterface<typename Imp::Traits::LocalBasisType::Traits>
311  {
312  typedef typename Imp::Traits::LocalBasisType::Traits T;
313  typedef LocalFiniteElementVirtualInterface<T> Interface;
314 
315  public:
316  typedef typename Interface::Traits Traits;
317 
320  : impl_(LocalFiniteElementCloneFactory<Imp>::clone(imp)),
321  localBasisImp_(impl_->localBasis()),
322  localCoefficientsImp_(impl_->localCoefficients()),
323  localInterpolationImp_(impl_->localInterpolation())
324  {}
325 
328  : impl_(LocalFiniteElementCloneFactory<Imp>::create()),
329  localBasisImp_(impl_->localBasis()),
330  localCoefficientsImp_(impl_->localCoefficients()),
331  localInterpolationImp_(impl_->localInterpolation())
332  {}
333 
336  : impl_(LocalFiniteElementCloneFactory<Imp>::clone(*other.impl_)),
337  localBasisImp_(impl_->localBasis()),
338  localCoefficientsImp_(impl_->localCoefficients()),
339  localInterpolationImp_(impl_->localInterpolation())
340  {}
341 
343  {
344  delete impl_;
345  }
346 
348  const typename Traits::LocalBasisType& localBasis () const
349  {
350  return localBasisImp_;
351  }
352 
355  {
356  return localCoefficientsImp_;
357  }
358 
361  {
362  return localInterpolationImp_;
363  }
364 
366  unsigned int size () const
367  {
368  return impl_->size();
369  }
370 
372  const GeometryType type () const
373  {
374  return impl_->type();
375  }
376 
383  {
384  return new LocalFiniteElementVirtualImp<Imp>(*this);
385  }
386 
387  protected:
388  const Imp* impl_;
389 
393  const LocalInterpolationVirtualImp<typename T::DomainType,
394  typename T::RangeType,
395  typename Imp::Traits::LocalInterpolationType> localInterpolationImp_;
396  };
397 }
398 #endif
class for wrapping a basis using the virtual interface
Definition: virtualwrappers.hh:75
LocalFiniteElementVirtualImp()
Default constructor. Assumes that the implementation class is default constructible as well...
Definition: virtualwrappers.hh:327
LocalInterpolationVirtualImp(const Imp &imp)
constructor taking an implementation of the Dune::LocalInterpolationVirtualInterface ...
Definition: virtualwrappers.hh:229
virtual base class for a local basis
Definition: virtualinterface.hh:24
LocalCoefficientsVirtualImp(const Imp &imp)
constructor taking an implementation of the Dune::LocalCoefficientsVirtualInterface ...
Definition: virtualwrappers.hh:271
Base::CoefficientType CoefficientType
Definition: virtualwrappers.hh:236
unsigned int size() const
Definition: virtualwrappers.hh:150
unsigned int size() const
Number of shape functions in this finite element.
Definition: virtualwrappers.hh:366
const Imp & impl_
Definition: virtualwrappers.hh:245
void partial(const std::array< unsigned int, Traits::dimDomain > &order, const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
Evaluate partial derivatives of any order of all shape functions.
Definition: virtualwrappers.hh:181
void evaluateJacobian(const typename Traits::DomainType &in, std::vector< typename Traits::JacobianType > &out) const
Definition: virtualwrappers.hh:169
void evaluate(const std::array< int, Traits::diffOrder > &directions, const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
Definition: virtualwrappers.hh:103
~LocalFiniteElementVirtualImp()
Definition: virtualwrappers.hh:342
virtual base class for a local interpolation
Definition: virtualinterface.hh:21
LI LocalInterpolationType
Definition: localfiniteelementtraits.hh:22
const LocalInterpolationVirtualImp< typename T::DomainType, typename T::RangeType, typename Imp::Traits::LocalInterpolationType > localInterpolationImp_
Definition: virtualwrappers.hh:395
Definition: brezzidouglasmarini1cube2dlocalbasis.hh:15
virtual void interpolate(const FunctionType &f, std::vector< CoefficientType > &out) const
determine coefficients interpolating a given function
Definition: virtualwrappers.hh:239
const GeometryType type() const
Definition: virtualwrappers.hh:372
const Traits::LocalBasisType & localBasis() const
Definition: virtualwrappers.hh:348
typename T::RangeType ::field_type CoefficientType
type of the coefficient vector in the interpolate method
Definition: virtualinterface.hh:295
unsigned int order() const
Definition: virtualwrappers.hh:156
const LocalBasisVirtualImp< T, typename Imp::Traits::LocalBasisType > localBasisImp_
Definition: virtualwrappers.hh:391
Base::FunctionType FunctionType
Definition: virtualwrappers.hh:234
LocalBasisTraits< DF, n, D, RF, m, R, J, 0 > Traits
Definition: virtualwrappers.hh:147
virtual LocalFiniteElementVirtualImp< Imp > * clone() const
clone this wrapper
Definition: virtualwrappers.hh:382
T Traits
Definition: virtualwrappers.hh:92
static Imp * clone(const Imp &imp)
Definition: virtualwrappers.hh:26
D DomainType
domain type
Definition: localbasis.hh:49
Definition: virtualwrappers.hh:24
LocalBasisVirtualImp(const Imp &imp)
constructor taking an implementation of the interface
Definition: virtualwrappers.hh:87
const Imp & impl_
Definition: virtualwrappers.hh:290
static Imp * clone(const Imp &imp)
Definition: virtualwrappers.hh:36
Interface::Traits Traits
Definition: virtualwrappers.hh:316
LocalFiniteElementVirtualInterface< typename Imp::Traits::LocalBasisType::Traits > Interface
Definition: virtualwrappers.hh:46
class for wrapping a local interpolation using the virtual interface
Definition: virtualwrappers.hh:218
traits helper struct
Definition: localfiniteelementtraits.hh:10
const LocalCoefficientsVirtualImp< typename Imp::Traits::LocalCoefficientsType > localCoefficientsImp_
Definition: virtualwrappers.hh:392
const Imp * impl_
Definition: virtualwrappers.hh:388
virtual base class for local finite elements with functions
Definition: virtualinterface.hh:391
void evaluate(const std::array< int, Traits::diffOrder > &directions, const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
Definition: virtualwrappers.hh:189
const Traits::LocalInterpolationType & localInterpolation() const
Definition: virtualwrappers.hh:360
static Imp * create()
Definition: virtualwrappers.hh:53
const Traits::LocalCoefficientsType & localCoefficients() const
Definition: virtualwrappers.hh:354
Definition: virtualwrappers.hh:44
class for wrapping a finite element using the virtual interface
Definition: virtualwrappers.hh:20
virtual base class for local coefficients
Definition: virtualinterface.hh:364
LocalFiniteElementVirtualImp(const LocalFiniteElementVirtualImp &other)
Copy contructor needed for deep copy.
Definition: virtualwrappers.hh:335
LC LocalCoefficientsType
Definition: localfiniteelementtraits.hh:18
Dune::VirtualFunction< typename T::DomainType, typename T::RangeType > FunctionType
type of virtual function to interpolate
Definition: virtualinterface.hh:292
void evaluateFunction(const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
Definition: virtualwrappers.hh:162
static Imp * clone(const Imp &imp)
Definition: virtualwrappers.hh:48
Type traits for LocalBasisVirtualInterface.
Definition: localbasis.hh:37
LocalFiniteElementVirtualImp(const Imp &imp)
taking a LocalFiniteElementVirtualInterface implementation
Definition: virtualwrappers.hh:319
const LocalKey & localKey(std::size_t i) const
get i&#39;th index
Definition: virtualwrappers.hh:284
std::size_t size() const
number of coefficients
Definition: virtualwrappers.hh:278
LocalBasisVirtualImp(const Imp &imp)
constructor taking an implementation of the interface
Definition: virtualwrappers.hh:142
LB LocalBasisType
Definition: localfiniteelementtraits.hh:14
class for wrapping local coefficients using the virtual interface
Definition: virtualwrappers.hh:262
Describe position of one degree of freedom.
Definition: localkey.hh:20