dune-localfunctions 2.8.0
Loading...
Searching...
No Matches
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
12namespace 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>
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
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 {
284 }
285
288 {
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
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::LocalBasisType & localBasis() const
Definition: virtualwrappers.hh:275
virtual LocalFiniteElementVirtualImp< Imp > * clone() const
clone this wrapper
Definition: virtualwrappers.hh:309
const LocalInterpolationVirtualImp< typename LocalBasisTraits::DomainType, typename LocalBasisTraits::RangeType, typename Imp::Traits::LocalInterpolationType > localInterpolationImp_
Definition: virtualwrappers.hh:321
LocalFiniteElementVirtualImp(const Imp &imp)
taking a LocalFiniteElementVirtualInterface implementation
Definition: virtualwrappers.hh:246
Interface::Traits Traits
Definition: virtualwrappers.hh:243
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
~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 Traits::LocalCoefficientsType & localCoefficients() const
Definition: virtualwrappers.hh:281
const LocalBasisVirtualImp< LocalBasisTraits, typename Imp::Traits::LocalBasisType > localBasisImp_
Definition: virtualwrappers.hh:317
const LocalCoefficientsVirtualImp< typename Imp::Traits::LocalCoefficientsType > localCoefficientsImp_
Definition: virtualwrappers.hh:318
const Traits::LocalInterpolationType & localInterpolation() const
Definition: virtualwrappers.hh:287
Definition: virtualwrappers.hh:22
static Imp * clone(const Imp &imp)
Definition: virtualwrappers.hh:23
Definition: virtualwrappers.hh:42
static Imp * clone(const Imp &imp)
Definition: virtualwrappers.hh:45
static Imp * create()
Definition: virtualwrappers.hh:50
LocalFiniteElementVirtualInterface< typename Imp::Traits::LocalBasisType::Traits > Interface
Definition: virtualwrappers.hh:43
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
T Traits
Definition: virtualwrappers.hh:85
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