dune-localfunctions  2.3.1
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 
19 namespace 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>
43  struct Iterator
44  {
47  };
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 >
76  struct MonomialEvaluator< B >::BaseIterator
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 
143  StandardEvaluator(const Basis &basis)
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>(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>(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 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
BaseIterator(Container &container)
Definition: basisevaluator.hh:89
Definition: basisevaluator.hh:128
bool done() const
Definition: basisevaluator.hh:105
static const int dimRange
Definition: basisevaluator.hh:35
Iterator< deriv >::All evaluate(const DVector &x)
Definition: basisevaluator.hh:147
std::vector< Field > Container
Definition: basisevaluator.hh:86
std::vector< Field > Container
Definition: basisevaluator.hh:134
Definition: basisevaluator.hh:40
MonomialEvaluator< B > Base
Definition: basisevaluator.hh:137
MonomialEvaluator(const Basis &basis, unsigned int order, unsigned int size)
Definition: basisevaluator.hh:55
unsigned int size_
Definition: basisevaluator.hh:69
Definition: basisevaluator.hh:43
std::vector< Field > Container
Definition: basisevaluator.hh:37
B Basis
Definition: basisevaluator.hh:131
static const int dimRange
Definition: basisevaluator.hh:136
Field operator*(const Unity< Field > &u, const Field &f)
Definition: field.hh:48
unsigned int order_
Definition: basisevaluator.hh:69
const Basis & basis_
Definition: basisevaluator.hh:68
Container container_
Definition: basisevaluator.hh:70
Deriv::Field Field
Definition: basisevaluator.hh:79
Definition: tensor.hh:165
Container::iterator CIter
Definition: basisevaluator.hh:87
Definition: basisevaluator.hh:29
StandardEvaluator(const Basis &basis)
Definition: basisevaluator.hh:143
Deriv Derivatives
Definition: basisevaluator.hh:78
B Basis
Definition: basisevaluator.hh:31
Definition: tensor.hh:165
Basis::DomainVector DomainVector
Definition: basisevaluator.hh:133
Dune::FieldVector< Field, blockSize > Block
Definition: basisevaluator.hh:81
DerivativeLayout
Definition: tensor.hh:165
Basis::Field Field
Definition: basisevaluator.hh:132
Definition: tensor.hh:168
BaseIterator< Derivatives< Field, dimension, dimRange, deriv, derivative > > All
Definition: basisevaluator.hh:45
void resize()
Definition: basisevaluator.hh:62
const Deriv & operator*() const
Definition: basisevaluator.hh:94
static const int dimension
Definition: basisevaluator.hh:34
const Deriv * operator->() const
Definition: basisevaluator.hh:100
static const int dimension
Definition: basisevaluator.hh:135
Iterator< 0 >::Integrate integrate()
Definition: basisevaluator.hh:153
StandardEvaluator(const Basis &basis, unsigned int size)
Definition: basisevaluator.hh:161
BaseIterator< Derivatives< Field, dimension, 1, 0, value > > Integrate
Definition: basisevaluator.hh:46
Basis::Field Field
Definition: basisevaluator.hh:32
unsigned int size() const
Definition: basisevaluator.hh:49
Basis::DomainVector DomainVector
Definition: basisevaluator.hh:33
Definition: basisevaluator.hh:140