dune-localfunctions 3.0-git
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
14namespace Dune
15{
16
17 // forward declaration needed by friend declarations
18 template<class Imp>
19 class LocalFiniteElementVirtualImp;
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>
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 using Base::partial;
99
100
102 inline void evaluate(
103 const std::array<int,Traits::diffOrder>& directions,
104 const typename Traits::DomainType& in,
105 std::vector<typename Traits::RangeType>& out) const
106 {
107 // Even for double virtualization it is save to call the template method
108 // since the interface provides it redirecting to the virtual method
109 // of the derived class
110 //
111 // Unfortunately not all compilers can determine Traits::diffOrder from
112 // the type of the argument directions
113 impl_.template evaluate<Traits::diffOrder>(directions, in, out);
114 }
115
116 protected:
117 using Base::impl_;
118
119 };
120
121
129 template<class DF, int n, class D, class RF, int m, class R, class J, class Imp>
130 class LocalBasisVirtualImp<LocalBasisTraits<DF,n,D,RF,m,R,J,0>, Imp>
131 : public virtual LocalBasisVirtualInterface<LocalBasisTraits<DF,n,D,RF,m,R,J,0> >
132 {
133 template<class FEImp>
135
136 protected:
137
139 LocalBasisVirtualImp( const Imp &imp )
140 : impl_(imp)
141 {}
142
143 public:
145
147 unsigned int size () const
148 {
149 return impl_.size();
150 }
151
153 unsigned int order () const
154 {
155 return impl_.order();
156 }
157
159 inline void evaluateFunction (const typename Traits::DomainType& in,
160 std::vector<typename Traits::RangeType>& out) const
161 {
162 impl_.evaluateFunction(in,out);
163 }
164
166 inline void evaluateJacobian(
167 const typename Traits::DomainType& in,
168 std::vector<typename Traits::JacobianType>& out) const
169 {
170 impl_.evaluateJacobian(in,out);
171 }
172
178 void partial(const std::array<unsigned int,Traits::dimDomain>& order,
179 const typename Traits::DomainType& in,
180 std::vector<typename Traits::RangeType>& out) const
181 {
182 impl_.partial(order,in,out);
183 }
184
186 inline void evaluate(
187 const std::array<int,Traits::diffOrder>& directions,
188 const typename Traits::DomainType& in,
189 std::vector<typename Traits::RangeType>& out) const
190 {
191 // impl_.template evaluate<Traits::diffOrder> (directions, in,out);
192 // impl_.template evaluate<0> (directions, in,out);
193 impl_.evaluateFunction(in,out);
194 }
195
196 protected:
197 const Imp& impl_;
198 };
199
200
201
202 // -----------------------------------------------------------------
203 // Interpolation
204 // -----------------------------------------------------------------
205
214 template<class DomainType, class RangeType, class Imp>
216 : public LocalInterpolationVirtualInterface< DomainType, RangeType >
217 {
218 template<class FEImp>
220
222
223 protected:
224
227 : impl_(imp) {}
228
229 public:
230
232
234
236 virtual void interpolate (const FunctionType& f, std::vector<CoefficientType>& out) const
237 {
238 impl_.interpolate(f,out);
239 }
240
241 protected:
242 const Imp& impl_;
243
244 };
245
246
247
248 // -----------------------------------------------------------------
249 // Coefficients
250 // -----------------------------------------------------------------
251
258 template<class Imp>
261 {
262 template<class FEImp>
264
265 protected:
266
269 : impl_(imp)
270 {}
271
272 public:
273
275 std::size_t size () const
276 {
277 return impl_.size();
278 }
279
281 const LocalKey& localKey (std::size_t i) const
282 {
283 return impl_.localKey(i);
284 }
285
286 protected:
287 const Imp& impl_;
288
289 };
290
291
292
293 // -----------------------------------------------------------------
294 // Finite Element
295 // -----------------------------------------------------------------
296
305 template<class Imp>
307 : public virtual LocalFiniteElementVirtualInterface<typename Imp::Traits::LocalBasisType::Traits>
308 {
309 typedef typename Imp::Traits::LocalBasisType::Traits T;
311
312 public:
313 typedef typename Interface::Traits Traits;
314
322
330
338
340 {
341 delete impl_;
342 }
343
345 const typename Traits::LocalBasisType& localBasis () const
346 {
347 return localBasisImp_;
348 }
349
352 {
354 }
355
358 {
360 }
361
363 unsigned int size () const
364 {
365 return impl_->size();
366 }
367
369 const GeometryType type () const
370 {
371 return impl_->type();
372 }
373
380 {
381 return new LocalFiniteElementVirtualImp<Imp>(*this);
382 }
383
384 protected:
385 const Imp* impl_;
386
390 const LocalInterpolationVirtualImp<typename T::DomainType,
391 typename T::RangeType,
392 typename Imp::Traits::LocalInterpolationType> localInterpolationImp_;
393 };
394}
395#endif
Definition brezzidouglasmarini1cube2d.hh:14
Type traits for LocalBasisVirtualInterface.
Definition localbasis.hh:38
D DomainType
domain type
Definition localbasis.hh:49
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:288
RangeType::field_type CoefficientType
type of the coefficient vector in the interpolate method
Definition virtualinterface.hh:295
Dune::VirtualFunction< DomainType, RangeType > FunctionType
type of virtual function to interpolate
Definition virtualinterface.hh:292
virtual base class for a local basis
Definition virtualinterface.hh:207
virtual base class for local coefficients
Definition virtualinterface.hh:365
virtual base class for local finite elements with functions
Definition virtualinterface.hh:393
class for wrapping a finite element using the virtual interface
Definition virtualwrappers.hh:308
const Traits::LocalBasisType & localBasis() const
Definition virtualwrappers.hh:345
const LocalBasisVirtualImp< T, typename Imp::Traits::LocalBasisType > localBasisImp_
Definition virtualwrappers.hh:388
virtual LocalFiniteElementVirtualImp< Imp > * clone() const
clone this wrapper
Definition virtualwrappers.hh:379
const LocalInterpolationVirtualImp< typename T::DomainType, typename T::RangeType, typename Imp::Traits::LocalInterpolationType > localInterpolationImp_
Definition virtualwrappers.hh:392
LocalFiniteElementVirtualImp(const Imp &imp)
taking a LocalFiniteElementVirtualInterface implementation
Definition virtualwrappers.hh:316
Interface::Traits Traits
Definition virtualwrappers.hh:313
LocalFiniteElementVirtualImp()
Default constructor. Assumes that the implementation class is default constructible as well.
Definition virtualwrappers.hh:324
LocalFiniteElementVirtualImp(const LocalFiniteElementVirtualImp &other)
Copy contructor needed for deep copy.
Definition virtualwrappers.hh:332
~LocalFiniteElementVirtualImp()
Definition virtualwrappers.hh:339
unsigned int size() const
Number of shape functions in this finite element.
Definition virtualwrappers.hh:363
const GeometryType type() const
Definition virtualwrappers.hh:369
const Imp * impl_
Definition virtualwrappers.hh:385
const Traits::LocalCoefficientsType & localCoefficients() const
Definition virtualwrappers.hh:351
const LocalCoefficientsVirtualImp< typename Imp::Traits::LocalCoefficientsType > localCoefficientsImp_
Definition virtualwrappers.hh:389
const Traits::LocalInterpolationType & localInterpolation() const
Definition virtualwrappers.hh:357
Definition virtualwrappers.hh:24
static Imp * clone(const Imp &imp)
Definition virtualwrappers.hh:25
static Imp * clone(const Imp &imp)
Definition virtualwrappers.hh:35
Definition virtualwrappers.hh:44
static Imp * clone(const Imp &imp)
Definition virtualwrappers.hh:47
static Imp * create()
Definition virtualwrappers.hh:52
LocalFiniteElementVirtualInterface< typename Imp::Traits::LocalBasisType::Traits > Interface
Definition virtualwrappers.hh:45
class for wrapping a basis using the virtual interface
Definition virtualwrappers.hh:77
void evaluate(const std::array< int, Traits::diffOrder > &directions, const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
Definition virtualwrappers.hh:102
T Traits
Definition virtualwrappers.hh:91
LocalBasisVirtualImp(const Imp &imp)
constructor taking an implementation of the interface
Definition virtualwrappers.hh:86
LocalBasisTraits< DF, n, D, RF, m, R, J, 0 > Traits
Definition virtualwrappers.hh:144
void evaluateJacobian(const typename Traits::DomainType &in, std::vector< typename Traits::JacobianType > &out) const
Definition virtualwrappers.hh:166
unsigned int size() const
Definition virtualwrappers.hh:147
void evaluateFunction(const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
Definition virtualwrappers.hh:159
unsigned int order() const
Definition virtualwrappers.hh:153
void evaluate(const std::array< int, Traits::diffOrder > &directions, const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
Definition virtualwrappers.hh:186
LocalBasisVirtualImp(const Imp &imp)
constructor taking an implementation of the interface
Definition virtualwrappers.hh:139
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:178
class for wrapping a local interpolation using the virtual interface
Definition virtualwrappers.hh:217
virtual void interpolate(const FunctionType &f, std::vector< CoefficientType > &out) const
determine coefficients interpolating a given function
Definition virtualwrappers.hh:236
const Imp & impl_
Definition virtualwrappers.hh:242
Base::FunctionType FunctionType
Definition virtualwrappers.hh:231
LocalInterpolationVirtualImp(const Imp &imp)
constructor taking an implementation of the Dune::LocalInterpolationVirtualInterface
Definition virtualwrappers.hh:226
Base::CoefficientType CoefficientType
Definition virtualwrappers.hh:233
class for wrapping local coefficients using the virtual interface
Definition virtualwrappers.hh:261
LocalCoefficientsVirtualImp(const Imp &imp)
constructor taking an implementation of the Dune::LocalCoefficientsVirtualInterface
Definition virtualwrappers.hh:268
const LocalKey & localKey(std::size_t i) const
get i'th index
Definition virtualwrappers.hh:281
std::size_t size() const
number of coefficients
Definition virtualwrappers.hh:275
const Imp & impl_
Definition virtualwrappers.hh:287