dune-localfunctions  2.8.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_LOCALFUNCTIONS_COMMON_VIRTUALWRAPPERS_HH
4 #define DUNE_LOCALFUNCTIONS_COMMON_VIRTUALWRAPPERS_HH
5 
6 #include <array>
7 
11 
12 namespace Dune
13 {
14 
15  // forward declaration needed by friend declarations
16  template<class Imp>
17  class LocalFiniteElementVirtualImp;
18 
19  // default clone method is the copy constructor
20  template<class Imp, bool IsInterface>
22  {
23  static Imp* clone(const Imp& imp)
24  {
25  return new Imp(imp);
26  }
27  };
28 
29  // if FE derives from virtual interface the clone method is used
30  template<class Imp>
31  struct LocalFiniteElementCloneFactoryHelper<Imp, true>
32  {
33  static Imp* clone(const Imp& imp)
34  {
35  return imp.clone();
36  }
37  };
38 
39  // factory template to clone and create an objects
40  template<class Imp>
42  {
44 
45  static Imp* clone(const Imp& imp)
46  {
48  }
49 
50  static Imp* create()
51  {
52  return new Imp;
53  }
54  };
55 
56 
57 
58  // -----------------------------------------------------------------
59  // Basis
60  // -----------------------------------------------------------------
61 
62 
63 
70  template<class T , class Imp>
72  : public LocalBasisVirtualInterface<T>
73  {
74  template<class FEImp>
76 
77  protected:
78 
80  LocalBasisVirtualImp( const Imp &imp )
81  : impl_(imp)
82  {}
83 
84  public:
85  using Traits = T;
86 
88  unsigned int size () const
89  {
90  return impl_.size();
91  }
92 
94  unsigned int order () const
95  {
96  return impl_.order();
97  }
98 
100  inline void evaluateFunction (const typename Traits::DomainType& in,
101  std::vector<typename Traits::RangeType>& out) const
102  {
103  impl_.evaluateFunction(in,out);
104  }
105 
107  inline void evaluateJacobian(
108  const typename Traits::DomainType& in,
109  std::vector<typename Traits::JacobianType>& out) const
110  {
111  impl_.evaluateJacobian(in,out);
112  }
113 
119  void partial(const std::array<unsigned int,Traits::dimDomain>& order,
120  const typename Traits::DomainType& in,
121  std::vector<typename Traits::RangeType>& out) const
122  {
123  impl_.partial(order,in,out);
124  }
125 
126  protected:
127  const Imp& impl_;
128  };
129 
130 
131 
132  // -----------------------------------------------------------------
133  // Interpolation
134  // -----------------------------------------------------------------
135 
144  template<class DomainType, class RangeType, class Imp>
146  : public LocalInterpolationVirtualInterface< DomainType, RangeType >
147  {
148  template<class FEImp>
150 
152 
153  protected:
154 
157  : impl_(imp) {}
158 
159  public:
160 
162 
164 
166  virtual void interpolate (const FunctionType& f, std::vector<CoefficientType>& out) const
167  {
168  impl_.interpolate(f,out);
169  }
170 
171  protected:
172  const Imp& impl_;
173 
174  };
175 
176 
177 
178  // -----------------------------------------------------------------
179  // Coefficients
180  // -----------------------------------------------------------------
181 
188  template<class Imp>
191  {
192  template<class FEImp>
194 
195  protected:
196 
198  LocalCoefficientsVirtualImp( const Imp &imp )
199  : impl_(imp)
200  {}
201 
202  public:
203 
205  std::size_t size () const
206  {
207  return impl_.size();
208  }
209 
211  const LocalKey& localKey (std::size_t i) const
212  {
213  return impl_.localKey(i);
214  }
215 
216  protected:
217  const Imp& impl_;
218 
219  };
220 
221 
222 
223  // -----------------------------------------------------------------
224  // Finite Element
225  // -----------------------------------------------------------------
226 
235  template<class Imp>
237  : public LocalFiniteElementVirtualInterface<typename Imp::Traits::LocalBasisType::Traits>
238  {
239  using LocalBasisTraits = typename Imp::Traits::LocalBasisType::Traits;
241 
242  public:
243  typedef typename Interface::Traits Traits;
244 
251  {}
252 
255  : impl_(LocalFiniteElementCloneFactory<Imp>::create()),
259  {}
260 
267  {}
268 
270  {
271  delete impl_;
272  }
273 
275  const typename Traits::LocalBasisType& localBasis () const
276  {
277  return localBasisImp_;
278  }
279 
282  {
283  return localCoefficientsImp_;
284  }
285 
288  {
289  return localInterpolationImp_;
290  }
291 
293  unsigned int size () const
294  {
295  return impl_->size();
296  }
297 
299  const GeometryType type () const
300  {
301  return impl_->type();
302  }
303 
310  {
311  return new LocalFiniteElementVirtualImp<Imp>(*this);
312  }
313 
314  protected:
315  const Imp* impl_;
316 
321  typename Imp::Traits::LocalInterpolationType> localInterpolationImp_;
322  };
323 }
324 #endif
Definition: bdfmcube.hh:16
D DomainType
domain type
Definition: common/localbasis.hh:43
R RangeType
range type
Definition: common/localbasis.hh:55
traits helper struct
Definition: localfiniteelementtraits.hh:11
LB LocalBasisType
Definition: localfiniteelementtraits.hh:14
LC LocalCoefficientsType
Definition: localfiniteelementtraits.hh:18
LI LocalInterpolationType
Definition: localfiniteelementtraits.hh:22
Describe position of one degree of freedom.
Definition: localkey.hh:21
virtual base class for a local interpolation
Definition: virtualinterface.hh:188
std::function< RangeType(DomainType)> FunctionType
type of function to interpolate
Definition: virtualinterface.hh:192
RangeType::field_type CoefficientType
type of the coefficient vector in the interpolate method
Definition: virtualinterface.hh:195
virtual base class for a local basis
Definition: virtualinterface.hh:95
T Traits
Definition: virtualinterface.hh:97
std::function< RangeType(DomainType)> FunctionType
type of function to interpolate
Definition: virtualinterface.hh:161
virtual base class for local coefficients
Definition: virtualinterface.hh:257
virtual base class for local finite elements with functions
Definition: virtualinterface.hh:284
class for wrapping a finite element using the virtual interface
Definition: virtualwrappers.hh:238
const Traits::LocalInterpolationType & localInterpolation() const
Definition: virtualwrappers.hh:287
const LocalInterpolationVirtualImp< typename LocalBasisTraits::DomainType, typename LocalBasisTraits::RangeType, typename Imp::Traits::LocalInterpolationType > localInterpolationImp_
Definition: virtualwrappers.hh:321
const Traits::LocalCoefficientsType & localCoefficients() const
Definition: virtualwrappers.hh:281
LocalFiniteElementVirtualImp(const Imp &imp)
taking a LocalFiniteElementVirtualInterface implementation
Definition: virtualwrappers.hh:246
Interface::Traits Traits
Definition: virtualwrappers.hh:243
const Traits::LocalBasisType & localBasis() const
Definition: virtualwrappers.hh:275
LocalFiniteElementVirtualImp()
Default constructor. Assumes that the implementation class is default constructible as well.
Definition: virtualwrappers.hh:254
LocalFiniteElementVirtualImp(const LocalFiniteElementVirtualImp &other)
Copy contructor needed for deep copy.
Definition: virtualwrappers.hh:262
virtual LocalFiniteElementVirtualImp< Imp > * clone() const
clone this wrapper
Definition: virtualwrappers.hh:309
~LocalFiniteElementVirtualImp()
Definition: virtualwrappers.hh:269
unsigned int size() const
Number of shape functions in this finite element.
Definition: virtualwrappers.hh:293
const GeometryType type() const
Definition: virtualwrappers.hh:299
const Imp * impl_
Definition: virtualwrappers.hh:315
const LocalBasisVirtualImp< LocalBasisTraits, typename Imp::Traits::LocalBasisType > localBasisImp_
Definition: virtualwrappers.hh:317
const LocalCoefficientsVirtualImp< typename Imp::Traits::LocalCoefficientsType > localCoefficientsImp_
Definition: virtualwrappers.hh:318
Definition: virtualwrappers.hh:22
static Imp * clone(const Imp &imp)
Definition: virtualwrappers.hh:23
Definition: virtualwrappers.hh:42
static Imp * create()
Definition: virtualwrappers.hh:50
LocalFiniteElementVirtualInterface< typename Imp::Traits::LocalBasisType::Traits > Interface
Definition: virtualwrappers.hh:43
static Imp * clone(const Imp &imp)
Definition: virtualwrappers.hh:45
class for wrapping a basis using the virtual interface
Definition: virtualwrappers.hh:73
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:119
void evaluateFunction(const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
Evaluate all basis function at given position.
Definition: virtualwrappers.hh:100
const Imp & impl_
Definition: virtualwrappers.hh:127
unsigned int size() const
Number of shape functions.
Definition: virtualwrappers.hh:88
void evaluateJacobian(const typename Traits::DomainType &in, std::vector< typename Traits::JacobianType > &out) const
Evaluate jacobian of all shape functions at given position.
Definition: virtualwrappers.hh:107
LocalBasisVirtualImp(const Imp &imp)
constructor taking an implementation of the interface
Definition: virtualwrappers.hh:80
unsigned int order() const
Polynomial order of the shape functions.
Definition: virtualwrappers.hh:94
class for wrapping a local interpolation using the virtual interface
Definition: virtualwrappers.hh:147
virtual void interpolate(const FunctionType &f, std::vector< CoefficientType > &out) const
determine coefficients interpolating a given function
Definition: virtualwrappers.hh:166
const Imp & impl_
Definition: virtualwrappers.hh:172
Base::FunctionType FunctionType
Definition: virtualwrappers.hh:161
LocalInterpolationVirtualImp(const Imp &imp)
constructor taking an implementation of the Dune::LocalInterpolationVirtualInterface
Definition: virtualwrappers.hh:156
Base::CoefficientType CoefficientType
Definition: virtualwrappers.hh:163
class for wrapping local coefficients using the virtual interface
Definition: virtualwrappers.hh:191
LocalCoefficientsVirtualImp(const Imp &imp)
constructor taking an implementation of the Dune::LocalCoefficientsVirtualInterface
Definition: virtualwrappers.hh:198
const LocalKey & localKey(std::size_t i) const
get i'th index
Definition: virtualwrappers.hh:211
std::size_t size() const
number of coefficients
Definition: virtualwrappers.hh:205
const Imp & impl_
Definition: virtualwrappers.hh:217