dune-localfunctions 3.0-git
basisevaluator.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
4#ifndef DUNE_BASISEVALUATOR_HH
5#define DUNE_BASISEVALUATOR_HH
6
7#include <vector>
8
9#include <dune/common/fmatrix.hh>
10#include <dune/common/fvector.hh>
11#include <dune/common/typetraits.hh>
12
13#include <dune/geometry/genericgeometry/topologytypes.hh>
14
18
19namespace Dune
20{
21 /*******************************************
22 * Should be removed as soon as the Tensor
23 * classes have been revisited. See remarks
24 * in tensor.hh (also hold true here).
25 *******************************************/
26
27
28 template <class B>
30 {
31 typedef B Basis;
32 typedef typename Basis::Field Field;
33 typedef typename Basis::DomainVector DomainVector;
34 static const int dimension = Basis::dimension;
35 static const int dimRange = Basis::dimRange;
36
37 typedef std::vector<Field> Container;
38
39 template< class Deriv >
40 struct BaseIterator;
41
42 template <unsigned int deriv>
48
49 unsigned int size() const
50 {
51 return size_;
52 }
53
54 protected:
55 MonomialEvaluator(const Basis &basis,unsigned int order,unsigned int size)
56 : basis_(basis),
57 order_(order),
58 size_(size),
59 container_(0)
60 {}
61 template <int deriv>
62 void resize()
63 {
65 container_.resize(totalSize);
66 }
68 const Basis &basis_;
69 unsigned int order_,size_;
71 };
72
73
74 template< class B >
75 template< class Deriv >
77 {
78 typedef Deriv Derivatives;
79 typedef typename Deriv::Field Field;
80 static const unsigned int blockSize = Deriv::size;
81 typedef Dune::FieldVector<Field,blockSize> Block;
82 static const DerivativeLayout layout = Deriv::layout;
83 static const unsigned int dimDomain = Deriv::dimDomain;
84 static const unsigned int dimRange = Deriv::dimRange;
85
86 typedef std::vector<Field> Container;
87 typedef typename Container::iterator CIter;
88
89 explicit BaseIterator ( Container &container )
90 : pos_( container.begin() ),
91 end_( container.end() )
92 {}
93
94 const Deriv &operator*() const
95 {
96 assert(!done());
97 return reinterpret_cast<const Deriv&>(*pos_);
98 }
99
100 const Deriv *operator->() const
101 {
102 return &(operator*());
103 }
104
105 bool done () const
106 {
107 return pos_ == end_;
108 }
109
110 BaseIterator &operator++ ()
111 {
112 pos_ += blockSize;
113 return *this;
114 }
115
116 BaseIterator &operator+= ( unsigned int skip )
117 {
118 pos_ += skip*blockSize;
119 return *this;
120 }
121
122 private:
123 CIter pos_;
124 const CIter end_;
125 };
126
127 template< class B >
129 : public MonomialEvaluator< B >
130 {
131 typedef B Basis;
132 typedef typename Basis::Field Field;
133 typedef typename Basis::DomainVector DomainVector;
134 typedef std::vector<Field> Container;
135 static const int dimension = Basis::dimension;
136 static const int dimRange = Basis::dimRange;
138
139 template <unsigned int deriv>
140 struct Iterator : public Base::template Iterator<deriv>
141 {};
142
144 : Base(basis,basis.order(),basis.size())
145 {}
146 template <unsigned int deriv,class DVector>
147 typename Iterator<deriv>::All evaluate(const DVector &x)
148 {
149 Base::template resize<deriv>();
150 basis_.template evaluate<deriv>(x,&(container_[0]));
151 return typename Iterator<deriv>::All(container_);
152 }
154 {
155 Base::template resize<0>();
156 basis_.integrate(&(container_[0]));
157 return typename Iterator<0>::Integrate(container_);
158 }
159
160 protected:
161 StandardEvaluator ( const Basis &basis, unsigned int size )
162 : Base( basis, basis.order(), size )
163 {}
164
165 private:
167 using Base::basis_;
168 using Base::container_;
169 };
170
171#if 0 // OLD OLD
172 template< class B, class Fill >
173 struct VecEvaluator
174 : public StandardEvaluator< B >
175 {
176 typedef B Basis;
177 typedef typename Basis::Field Field;
178 static const int dimension = Basis::dimension;
179 static const int dimRange = Basis::dimRange*Fill::dimRange;
180 typedef typename Basis::DomainVector DomainVector;
181 typedef std::vector<Field> Container;
182 typedef StandardEvaluator<B> Base;
183
184 template <unsigned int deriv>
185 struct Iterator
186 {
187 typedef typename Base::template BaseIterator<Derivatives<Field,dimension,dimRange,deriv,Fill::layout> > All;
188 };
189
190 VecEvaluator ( const Basis &basis, const Fill &fill )
191 : Base( basis, basis.size() ),
192 fill_( fill ),
193 size_( basis.size()*dimRange )
194 {}
195 template <unsigned int deriv>
196 typename Iterator<deriv>::All evaluate(const DomainVector &x)
197 {
198 resize< deriv >();
199 fill_.template apply<deriv>( x,Base::template evaluate<deriv>(x), vecContainer_ );
200 std::vector<Derivatives<Field,dimension,dimRange,deriv,Fill::layout> >& derivContainer =
201 reinterpret_cast<std::vector<Derivatives<Field,dimension,dimRange,deriv,Fill::layout> >&>(vecContainer_);
202 return typename Iterator<deriv>::All(derivContainer);
203 }
204 template <unsigned int deriv,class DVector>
205 typename Iterator<deriv>::All evaluate(const DVector &x)
206 {
207 resize< deriv >();
208 fill_.template apply<deriv>( x,Base::template evaluate<deriv>(x), vecContainer_ );
209 std::vector<Derivatives<Field,dimension,dimRange,deriv,Fill::layout> >& derivContainer =
210 reinterpret_cast<std::vector<Derivatives<Field,dimension,dimRange,deriv,Fill::layout> >&>(vecContainer_);
211 return typename Iterator<deriv>::All(derivContainer);
212 }
213 unsigned int size() const
214 {
215 return size_;
216 }
217
218 protected:
219 VecEvaluator ( const Basis &basis, const Fill &fill, unsigned int size )
220 : Base( basis, basis.size() ),
221 fill_( fill ),
222 size_( size )
223 {
224 resize< 2 >();
225 }
226
227 template <int deriv>
228 void resize()
229 {
230 const int totalSize = Derivatives<Field,dimension,dimRange,deriv,derivative>::size*size_;
231 vecContainer_.resize(totalSize);
232 }
233
234 VecEvaluator(const VecEvaluator&);
235
236 Container vecContainer_;
237 const Fill &fill_;
238 unsigned int size_;
239 };
240
241 template <int dimR,DerivativeLayout layout>
242 struct DiagonalFill;
243
244 template <int dimR>
245 struct DiagonalFill<dimR,derivative>
246 {
247 static const DerivativeLayout layout = derivative;
248 static const int dimRange = dimR;
249 template <int deriv, class Domain, class Iter,class Field>
250 void apply(const Domain &x,
251 Iter iter,std::vector<Field> &vecContainer) const
252 {
253 typedef std::vector<Field> Container;
254 typename Container::iterator vecIter = vecContainer.begin();
255 for ( ; !iter.done(); ++iter)
256 {
257 const typename Iter::Block &block = iter->block();
258 for (int r1=0; r1<dimR; ++r1)
259 {
260 unsigned int b = 0;
261 apply<Field>(r1,x,block,b,vecIter);
262 }
263 }
264 }
265 template <class Field, class Domain, class Block,class VecIter>
266 void apply(int r1, const Domain &x,
267 const Block &block,unsigned int &b,
268 VecIter &vecIter) const
269 {
270 unsigned int bStart = b;
271 unsigned int bEnd = b+Block::size;
272 apply<Field>(r1,x,block,bStart,bEnd,vecIter);
273 b=bEnd;
274 }
275 template <class Field, class Domain, class Block,class VecIter>
276 void apply(int r1, const Domain &x,const Block &block,
277 unsigned int bStart, unsigned int bEnd,
278 VecIter &vecIter) const
279 {
280 for (int r2=0; r2<dimR; ++r2)
281 {
282 for (unsigned int bb=bStart; bb<bEnd; ++bb)
283 {
284 *vecIter = (r1==r2 ? block[bb] : Field(0));
285 ++vecIter;
286 }
287 }
288 }
289 };
290 template <int dimR>
291 struct DiagonalFill<dimR,value>
292 {
293 static const DerivativeLayout layout = value;
294 static const int dimRange = dimR;
295 template <int deriv, class Domain, class Iter,class Field>
296 void apply(const Domain &x,
297 Iter iter,std::vector<Field> &vecContainer) const
298 {
299 typedef std::vector<Field> Container;
300 typename Container::iterator vecIter = vecContainer.begin();
301 for ( ; !iter.done(); ++iter)
302 {
303 const typename Iter::Block &block = iter->block();
304 for (int r1=0; r1<dimR; ++r1)
305 {
306 unsigned int b = 0;
307 apply<Field>(std::integral_constant<int,deriv>(),r1,x,block,b,vecIter);
308 }
309 }
310 }
311 template <class Field, class Domain, class Block,class VecIter,int deriv>
312 void apply(const integral_constat<int,deriv>&, int r1, const Domain &x,
313 const Block &block,unsigned int &b,
314 VecIter &vecIter) const
315 {
316 apply<Field>(std::integral_constant<int,deriv-1>(),r1,x,block,b,vecIter);
317 unsigned int bStart = b;
318 unsigned int bEnd = b+LFETensor<Field,Domain::dimension,deriv>::size;
319 apply<Field>(r1,x,block,bStart,bEnd,vecIter);
320 b=bEnd;
321 }
322 template <class Field, class Domain, class Block,class VecIter>
323 void apply(const std::integral_constant<int,0>&, int r1, const Domain &x,
324 const Block &block,unsigned int &b,
325 VecIter &vecIter) const
326 {
327 apply<Field>(r1,x,block,b,b+1,vecIter);
328 ++b;
329 }
330 template <class Field, class Domain, class Block,class VecIter>
331 void apply(int r1, const Domain &x,const Block &block,
332 unsigned int bStart, unsigned int bEnd,
333 VecIter &vecIter) const
334 {
335 for (int r2=0; r2<dimR; ++r2)
336 {
337 for (unsigned int bb=bStart; bb<bEnd; ++bb)
338 {
339 *vecIter = (r1==r2 ? block[bb] : Field(0));
340 ++vecIter;
341 }
342 }
343 }
344 };
345
346 template <class B,int dimR,DerivativeLayout layout>
347 struct VectorialEvaluator
348 : public VecEvaluator<B,DiagonalFill<dimR,layout> >
349 {
350 typedef DiagonalFill<dimR,layout> Fill;
351 typedef VecEvaluator< B,Fill > Base;
352 VectorialEvaluator(const B &basis)
353 : Base(basis,fill_,basis.size()*dimR)
354 {}
355 private:
356 Fill fill_;
357 };
358#endif // OLD OLD
359
360}
361
362#endif
Definition brezzidouglasmarini1cube2d.hh:14
DerivativeLayout
Definition tensor.hh:165
@ derivative
Definition tensor.hh:165
@ value
Definition tensor.hh:165
Field operator*(const Unity< Field > &u, const Field &f)
Definition field.hh:48
Definition basisevaluator.hh:30
static const int dimRange
Definition basisevaluator.hh:35
B Basis
Definition basisevaluator.hh:31
unsigned int order_
Definition basisevaluator.hh:69
const Basis & basis_
Definition basisevaluator.hh:68
MonomialEvaluator(const Basis &basis, unsigned int order, unsigned int size)
Definition basisevaluator.hh:55
Basis::Field Field
Definition basisevaluator.hh:32
unsigned int size_
Definition basisevaluator.hh:69
Basis::DomainVector DomainVector
Definition basisevaluator.hh:33
void resize()
Definition basisevaluator.hh:62
Container container_
Definition basisevaluator.hh:70
unsigned int size() const
Definition basisevaluator.hh:49
std::vector< Field > Container
Definition basisevaluator.hh:37
MonomialEvaluator(const MonomialEvaluator &)
static const int dimension
Definition basisevaluator.hh:34
Definition basisevaluator.hh:77
BaseIterator(Container &container)
Definition basisevaluator.hh:89
const Deriv & operator*() const
Definition basisevaluator.hh:94
Dune::FieldVector< Field, blockSize > Block
Definition basisevaluator.hh:81
bool done() const
Definition basisevaluator.hh:105
Container::iterator CIter
Definition basisevaluator.hh:87
const Deriv * operator->() const
Definition basisevaluator.hh:100
Deriv Derivatives
Definition basisevaluator.hh:78
std::vector< Field > Container
Definition basisevaluator.hh:86
Deriv::Field Field
Definition basisevaluator.hh:79
Definition basisevaluator.hh:44
BaseIterator< Derivatives< Field, dimension, dimRange, deriv, derivative > > All
Definition basisevaluator.hh:45
BaseIterator< Derivatives< Field, dimension, 1, 0, value > > Integrate
Definition basisevaluator.hh:46
Definition basisevaluator.hh:130
Basis::Field Field
Definition basisevaluator.hh:132
Basis::DomainVector DomainVector
Definition basisevaluator.hh:133
Iterator< deriv >::All evaluate(const DVector &x)
Definition basisevaluator.hh:147
MonomialEvaluator< B > Base
Definition basisevaluator.hh:137
StandardEvaluator(const Basis &basis)
Definition basisevaluator.hh:143
static const int dimRange
Definition basisevaluator.hh:136
std::vector< Field > Container
Definition basisevaluator.hh:134
Iterator< 0 >::Integrate integrate()
Definition basisevaluator.hh:153
B Basis
Definition basisevaluator.hh:131
StandardEvaluator(const Basis &basis, unsigned int size)
Definition basisevaluator.hh:161
static const int dimension
Definition basisevaluator.hh:135
Definition basisevaluator.hh:141
Definition tensor.hh:168