dune-localfunctions  2.8.0
monomialbasis.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_MONOMIALBASIS_HH
4 #define DUNE_MONOMIALBASIS_HH
5 
6 #include <vector>
7 
8 #include <dune/common/fvector.hh>
9 #include <dune/common/fmatrix.hh>
10 
11 #include <dune/geometry/type.hh>
12 #include <dune/geometry/topologyfactory.hh>
13 
17 
18 namespace Dune
19 {
20  /************************************************
21  * Classes for evaluating ''Monomials'' on any order
22  * for all reference element type.
23  * For a simplex topology these are the normal
24  * monomials for cube topologies the bimonomials.
25  * The construction follows the construction of the
26  * generic geometries using tensor products for
27  * prism generation and duffy transform for pyramid
28  * construction.
29  * A derivative argument can be applied, in which case
30  * all derivatives up to the desired order are
31  * evaluated. Note that for higher order derivatives
32  * only the ''lower'' part of the symmetric tensor
33  * is evaluated, e.g., passing derivative equal to 2
34  * to the class will provide the vector
35  * (d/dxdx p, d/dxydx p, d/dydy p,
36  * d/dx p, d/dy p, p)
37  * Important:
38  * So far the computation of the derivatives has not
39  * been fully implemented for general pyramid
40  * construction, i.e., in the case where a pyramid is
41  * build over a non simplex base geometry.
42  *
43  * Central classes:
44  * 1) template< GeometryType::Id geometryId, class F >
45  * class MonomialBasisImpl;
46  * Implementation of the monomial evaluation for
47  * a given topology and field type.
48  * The method evaluate fills a F* vector
49  * 2) template< GeometryType::Id geometryId, class F >
50  * class MonomialBasis
51  * The base class for the static monomial evaluation
52  * providing addiional evaluate methods including
53  * one taking std::vector<F>.
54  * 3) template< int dim, class F >
55  * class VirtualMonomialBasis
56  * Virtualization of the MonomialBasis.
57  * 4) template< int dim, class F >
58  * struct MonomialBasisFactory;
59  * A factory class for the VirtualMonomialBasis
60  * 5) template< int dim, class F >
61  * struct MonomialBasisProvider
62  * A singleton container for the virtual monomial
63  * basis
64  ************************************************/
65 
66  // Internal Forward Declarations
67  // -----------------------------
68 
69  template< GeometryType::Id geometryId >
70  class MonomialBasisSize;
71 
72  template< GeometryType::Id geometryId, class F >
73  class MonomialBasis;
74 
75 
76 
77  // MonomialBasisSize
78  // -----------------
79 
80  template< GeometryType::Id geometryId >
82  {
84 
85  public:
86  static This &instance ()
87  {
88  static This _instance;
89  return _instance;
90  }
91 
92  unsigned int maxOrder_;
93 
94  // sizes_[ k ]: number of basis functions of exactly order k
95  mutable unsigned int *sizes_;
96 
97  // numBaseFunctions_[ k ] = sizes_[ 0 ] + ... + sizes_[ k ]
98  mutable unsigned int *numBaseFunctions_;
99 
101  : maxOrder_( 0 ),
102  sizes_( 0 ),
103  numBaseFunctions_( 0 )
104  {
105  computeSizes( 2 );
106  }
107 
109  {
110  delete[] sizes_;
111  delete[] numBaseFunctions_;
112  }
113 
114  unsigned int operator() ( const unsigned int order ) const
115  {
116  return numBaseFunctions_[ order ];
117  }
118 
119  unsigned int maxOrder() const
120  {
121  return maxOrder_;
122  }
123 
124  void computeSizes ( unsigned int order )
125  {
126  if (order <= maxOrder_)
127  return;
128 
129  maxOrder_ = order;
130 
131  delete[] sizes_;
132  delete[] numBaseFunctions_;
133  sizes_ = new unsigned int[ order+1 ];
134  numBaseFunctions_ = new unsigned int[ order+1 ];
135 
136  constexpr GeometryType geometry = geometryId;
137  constexpr auto dim = geometry.dim();
138 
139  sizes_[ 0 ] = 1;
140  for( unsigned int k = 1; k <= order; ++k )
141  sizes_[ k ] = 0;
142 
143  std::fill(numBaseFunctions_, numBaseFunctions_+order+1, 1);
144 
145  for( int codim=dim-1; codim>=0; codim--)
146  {
147  if (Impl::isPrism(geometry.id(),dim,codim))
148  {
149  for( unsigned int k = 1; k <= order; ++k )
150  {
151  sizes_[ k ] = numBaseFunctions_[ k ] + k*sizes_[ k ];
152  numBaseFunctions_[ k ] = numBaseFunctions_[ k-1 ] + sizes_[ k ];
153  }
154  }
155  else
156  {
157  for( unsigned int k = 1; k <= order; ++k )
158  {
159  sizes_[ k ] = numBaseFunctions_[ k ];
160  numBaseFunctions_[ k ] = numBaseFunctions_[ k-1 ] + sizes_[ k ];
161  }
162  }
163  }
164  }
165  };
166 
167 
168 
169  // MonomialBasisHelper
170  // -------------------
171 
172 
173  template< int mydim, int dim, class F >
175  {
176  typedef MonomialBasisSize< GeometryTypes::simplex(mydim).toId() > MySize;
177  typedef MonomialBasisSize< GeometryTypes::simplex(dim).toId() > Size;
178 
179  static void copy ( const unsigned int deriv, F *&wit, F *&rit,
180  const unsigned int numBaseFunctions, const F &z )
181  {
182  // n(d,k) = size<k>[d];
183  MySize &mySize = MySize::instance();
184  Size &size = Size::instance();
185 
186  const F *const rend = rit + size( deriv )*numBaseFunctions;
187  for( ; rit != rend; )
188  {
189  F *prit = rit;
190 
191  *wit = z * *rit;
192  ++rit, ++wit;
193 
194  for( unsigned d = 1; d <= deriv; ++d )
195  {
196  #ifndef NDEBUG
197  const F *const derivEnd = rit + mySize.sizes_[ d ];
198  #endif
199 
200  {
201  const F *const drend = rit + mySize.sizes_[ d ] - mySize.sizes_[ d-1 ];
202  for( ; rit != drend ; ++rit, ++wit )
203  *wit = z * *rit;
204  }
205 
206  for (unsigned int j=1; j<d; ++j)
207  {
208  const F *const drend = rit + mySize.sizes_[ d-j ] - mySize.sizes_[ d-j-1 ];
209  for( ; rit != drend ; ++prit, ++rit, ++wit )
210  *wit = F(j) * *prit + z * *rit;
211  }
212  *wit = F(d) * *prit + z * *rit;
213  ++prit, ++rit, ++wit;
214  assert(derivEnd == rit);
215  rit += size.sizes_[d] - mySize.sizes_[d];
216  prit += size.sizes_[d-1] - mySize.sizes_[d-1];
217  const F *const emptyWitEnd = wit + size.sizes_[d] - mySize.sizes_[d];
218  for ( ; wit != emptyWitEnd; ++wit )
219  *wit = Zero<F>();
220  }
221  }
222  }
223  };
224 
225 
226 
227  // MonomialBasisImpl
228  // -----------------
229 
230  template< GeometryType::Id geometryId, class F>
232  {
233  public:
234  typedef F Field;
235 
236  static constexpr GeometryType geometry = geometryId;
237 
238  static const unsigned int dimDomain = geometry.dim();
239 
240  typedef FieldVector< Field, dimDomain > DomainVector;
241 
242  private:
243  friend class MonomialBasis< geometryId, Field >;
244 
246  {}
247 
248  template< int dimD >
249  void evaluate ( const unsigned int deriv, const unsigned int order,
250  const FieldVector< Field, dimD > &x,
251  const unsigned int block, const unsigned int *const offsets,
252  Field *const values ) const
253  {
254  //start with vertex
255  *values = Unity< F >();
256  F *const end = values + block;
257  for( Field *it = values+1 ; it != end; ++it )
258  *it = Zero< F >();
259 
260  constexpr GeometryType gt = GeometryTypes::vertex;
261 
262  if constexpr ( geometry == gt)
263  return;
264  else
265  evaluate<gt,dimD>(deriv, order, x, block, offsets, values );
266  }
267 
268  template<GeometryType::Id baseGeometryId, int dimD >
269  void evaluate ( const unsigned int deriv, const unsigned int order,
270  const FieldVector< Field, dimD > &x,
271  const unsigned int block, const unsigned int *const offsets,
272  Field *const values ) const
273  {
274 
275  static constexpr GeometryType baseGeometry = baseGeometryId;
276 
277  auto constexpr isPrismatic = geometry.isPrismatic(baseGeometry.dim());
278 
279  // compute
280  typedef MonomialBasisHelper< baseGeometry.dim() + 1, dimD, Field > Helper;
281  typedef MonomialBasisSize<baseGeometryId> BaseSize;
282 
283  const BaseSize &size = BaseSize::instance();
284  const_cast<BaseSize&>(size).computeSizes(order);
285 
286  const Field &z = x[ baseGeometry.dim() ];
287 
288  Field *row0 = values;
289  for( unsigned int k = 1; k <= order; ++k )
290  {
291  Field *row1 = values + block*offsets[ k-1 ];
292  Field *wit = row1 + block*size.sizes_[ k ];
293  if constexpr ( isPrismatic )
294  Helper::copy( deriv, wit, row1, k*size.sizes_[ k ], z );
295  Helper::copy( deriv, wit, row0, size( k-1 ), z );
296  row0 = row1;
297  }
298 
299  // stop if desired dimension is reached
300  if constexpr( baseGeometry.dim() == dimDomain-1)
301  return;
302  else
303  {
304  constexpr GeometryType nextGeometry = isPrismatic ? GeometryTypes::prismaticExtension(baseGeometry)
305  : GeometryTypes::conicalExtension(baseGeometry);
306 
307  evaluate<nextGeometry.toId(),dimD>(deriv, order, x, block, offsets, values );
308  }
309  }
310 
311  void integrate ( const unsigned int order,
312  const unsigned int *const offsets,
313  Field *const values ) const
314  {
315  //start with vertex
316  values[ 0 ] = Unity< Field >();
317  static constexpr GeometryType gt = GeometryTypes::vertex;
318 
319  if constexpr ( geometry == gt)
320  return;
321  else
322  integrate<gt>(order, offsets, values);
323  }
324 
325  template<GeometryType::Id baseGeometryId>
326  void integrate ( const unsigned int order,
327  const unsigned int *const offsets,
328  Field *const values) const
329  {
330  static constexpr GeometryType baseGeometry = baseGeometryId;
331 
332  auto constexpr isPrismatic = geometry.isPrismatic(baseGeometry.dim());
333 
334  // decide which kind of integration should be performed
335  if constexpr ( isPrismatic )
336  integratePrismatic<baseGeometry>(order, offsets, values);
337  else
338  integrateConical<baseGeometry>(order, offsets, values);
339 
340  // stop if the desired dimension is reached
341  if constexpr( baseGeometry.dim() == dimDomain-1)
342  return;
343  else
344  {
345  static constexpr GeometryType nextGeometry = (isPrismatic ? GeometryTypes::prismaticExtension(baseGeometry)
346  : GeometryTypes::conicalExtension(baseGeometry));
347 
348  integrate<nextGeometry.toId()>(order, offsets, values);
349  }
350 
351  }
352 
353  template<GeometryType::Id baseGeometryId>
354  void integratePrismatic ( const unsigned int order,
355  const unsigned int *const offsets,
356  Field *const values ) const
357  {
358  typedef MonomialBasisSize<baseGeometryId> BaseSize;
359  static const BaseSize &size = BaseSize::instance();
360  const unsigned int *const baseSizes = size.sizes_;
361 
362  static constexpr GeometryType baseGeometry = baseGeometryId;
363  static constexpr GeometryType nextGeometry = GeometryTypes::prismaticExtension(baseGeometry);
364 
365  typedef MonomialBasisSize<nextGeometry.toId()> Size;
366  static const Size &mySize = Size::instance();
367 
368  Field *row0 = values;
369  for( unsigned int k = 1; k <= order; ++k )
370  {
371  Field *const row1begin = values + offsets[ k-1 ];
372  Field *const row1End = row1begin + mySize.sizes_[ k ];
373  assert( (unsigned int)(row1End - values) <= offsets[ k ] );
374 
375  Field *row1 = row1begin;
376  Field *it = row1begin + baseSizes[ k ];
377  for( unsigned int j = 1; j <= k; ++j )
378  {
379  Field *const end = it + baseSizes[ k ];
380  assert( (unsigned int)(end - values) <= offsets[ k ] );
381  for( ; it != end; ++row1, ++it )
382  *it = (Field( j ) / Field( j+1 )) * (*row1);
383  }
384  for( ; it != row1End; ++row0, ++it )
385  *it = (Field( k ) / Field( k+1 )) * (*row0);
386  row0 = row1;
387  }
388  }
389 
390 
391  template<GeometryType::Id baseGeometryId>
392  void integrateConical ( const unsigned int order,
393  const unsigned int *const offsets,
394  Field *const values) const
395  {
396  typedef MonomialBasisSize<baseGeometryId> BaseSize;
397  static const BaseSize &size = BaseSize::instance();
398  const unsigned int *const baseSizes = size.sizes_;
399 
400  static constexpr GeometryType baseGeometry = baseGeometryId;
401 
402  {
403  Field *const col0End = values + baseSizes[ 0 ];
404  for( Field *it = values; it != col0End; ++it )
405  *it *= Field( 1 ) / Field( int(baseGeometry.dim()+1) );
406  }
407 
408  Field *row0 = values;
409  for( unsigned int k = 1; k <= order; ++k )
410  {
411  const Field factor = (Field( 1 ) / Field( k + baseGeometry.dim()+1));
412 
413  Field *const row1 = values+offsets[ k-1 ];
414  Field *const col0End = row1 + baseSizes[ k ];
415  Field *it = row1;
416  for( ; it != col0End; ++it )
417  *it *= factor;
418  for( unsigned int i = 1; i <= k; ++i )
419  {
420  Field *const end = it + baseSizes[ k-i ];
421  assert( (unsigned int)(end - values) <= offsets[ k ] );
422  for( ; it != end; ++row0, ++it )
423  *it = (*row0) * (Field( i ) * factor);
424  }
425  row0 = row1;
426  }
427  }
428 
429  };
430 
431 
432  // MonomialBasis
433  // -------------
434 
435  template< GeometryType::Id geometryId, class F >
437  : public MonomialBasisImpl< geometryId, F >
438  {
439  static constexpr GeometryType geometry = geometryId;
442 
443  public:
444  static const unsigned int dimension = Base::dimDomain;
445  static const unsigned int dimRange = 1;
446 
447  typedef typename Base::Field Field;
448 
450 
451  typedef Dune::FieldVector<Field,dimRange> RangeVector;
452 
454 
455  MonomialBasis (unsigned int order)
456  : Base(),
457  order_(order),
458  size_(Size::instance())
459  {
460  assert(order<=1024); // avoid wrapping of unsigned int (0-1) order=1024 is quite hight...)
461  }
462 
463  const unsigned int *sizes ( unsigned int order ) const
464  {
465  size_.computeSizes( order );
466  return size_.numBaseFunctions_;
467  }
468 
469  const unsigned int *sizes () const
470  {
471  return sizes( order_ );
472  }
473 
474  unsigned int size () const
475  {
476  size_.computeSizes( order_ );
477  return size_( order_ );
478  }
479 
480  unsigned int derivSize ( const unsigned int deriv ) const
481  {
482  MonomialBasisSize< GeometryTypes::simplex(dimension).toId() >::instance().computeSizes( deriv );
483  return MonomialBasisSize< GeometryTypes::simplex(dimension).toId() >::instance() ( deriv );
484  }
485 
486  unsigned int order () const
487  {
488  return order_ ;
489  }
490 
491  unsigned int topologyId ( ) const
492  {
493  return geometry.id();
494  }
495 
496  void evaluate ( const unsigned int deriv, const DomainVector &x,
497  Field *const values ) const
498  {
499  Base::evaluate( deriv, order_, x, derivSize( deriv ), sizes( order_ ), values );
500  }
501 
502  template <unsigned int deriv>
503  void evaluate ( const DomainVector &x,
504  Field *const values ) const
505  {
506  evaluate( deriv, x, values );
507  }
508 
509  template<unsigned int deriv, class Vector >
510  void evaluate ( const DomainVector &x,
511  Vector &values ) const
512  {
513  evaluate<deriv>(x,&(values[0]));
514  }
515  template<unsigned int deriv, DerivativeLayoutNS::DerivativeLayout layout >
516  void evaluate ( const DomainVector &x,
518  {
519  evaluate<deriv>(x,&(values->block()));
520  }
521  template< unsigned int deriv >
522  void evaluate ( const DomainVector &x,
524  {
525  evaluate(0,x,&(values[0][0]));
526  }
527 
528  template<class Vector >
529  void evaluate ( const DomainVector &x,
530  Vector &values ) const
531  {
532  evaluate<0>(x,&(values[0]));
533  }
534 
535  template< class DVector, class RVector >
536  void evaluate ( const DVector &x, RVector &values ) const
537  {
538  assert( DVector::dimension == dimension);
539  DomainVector bx;
540  for( int d = 0; d < dimension; ++d )
541  field_cast( x[ d ], bx[ d ] );
542  evaluate<0>( bx, values );
543  }
544 
545  void integrate ( Field *const values ) const
546  {
547  Base::integrate( order_, sizes( order_ ), values );
548  }
549  template <class Vector>
550  void integrate ( Vector &values ) const
551  {
552  integrate( &(values[ 0 ]) );
553  }
554  private:
555  MonomialBasis(const This&);
556  This& operator=(const This&);
557  unsigned int order_;
558  Size &size_;
559  };
560 
561 
562 
563  // StdMonomialBasis
564  // ----------------
565 
566  template< int dim,class F >
568  : public MonomialBasis< GeometryTypes::simplex(dim).toId() , F >
569  {
571  typedef MonomialBasis< GeometryTypes::simplex(dim).toId(), F > Base;
572 
573  public:
574  static constexpr GeometryType geometry = GeometryTypes::simplex(dim);
575  static const int dimension = dim;
576 
577  StandardMonomialBasis ( unsigned int order )
578  : Base( order )
579  {}
580  };
581 
582 
583 
584  // StandardBiMonomialBasis
585  // -----------------------
586 
587  template< int dim, class F >
589  : public MonomialBasis< GeometryTypes::cube(dim).toId() , F >
590  {
592  typedef MonomialBasis< GeometryTypes::cube(dim).toId() , F > Base;
593 
594  public:
595  static constexpr GeometryType geometry = GeometryTypes::cube(dim);
596  static const int dimension = dim;
597 
599  : Base( order )
600  {}
601  };
602 
603  // -----------------------------------------------------------
604  // -----------------------------------------------------------
605  // VirtualMonomialBasis
606  // -------------------
607 
608  template< int dim, class F >
610  {
612 
613  public:
614  typedef F Field;
615  typedef F StorageField;
616  static const int dimension = dim;
617  static const unsigned int dimRange = 1;
618 
619  typedef FieldVector<Field,dimension> DomainVector;
620  typedef FieldVector<Field,dimRange> RangeVector;
621 
622  [[deprecated("Use VirtualMonomialBasis(GeometryType gt, unsigned int order) instead.")]]
623  explicit VirtualMonomialBasis(unsigned int topologyId,
624  unsigned int order)
625  : order_(order), geometry_(GeometryType(topologyId,dim)) {}
626 
627  explicit VirtualMonomialBasis(const GeometryType& gt,
628  unsigned int order)
629  : order_(order), geometry_(gt) {}
630 
632 
633  virtual const unsigned int *sizes ( ) const = 0;
634 
635  unsigned int size ( ) const
636  {
637  return sizes( )[ order_ ];
638  }
639 
640  unsigned int order () const
641  {
642  return order_;
643  }
644 
645  [[deprecated("Use type().id() instead.")]]
646  unsigned int topologyId ( ) const
647  {
648  return type().id();
649  }
650 
651  GeometryType type() const
652  {
653  return geometry_;
654  }
655 
656  virtual void evaluate ( const unsigned int deriv, const DomainVector &x,
657  Field *const values ) const = 0;
658  template < unsigned int deriv >
659  void evaluate ( const DomainVector &x,
660  Field *const values ) const
661  {
662  evaluate( deriv, x, values );
663  }
664  template < unsigned int deriv, int size >
665  void evaluate ( const DomainVector &x,
666  Dune::FieldVector<Field,size> *const values ) const
667  {
668  evaluate( deriv, x, &(values[0][0]) );
669  }
670  template<unsigned int deriv, DerivativeLayoutNS::DerivativeLayout layout >
671  void evaluate ( const DomainVector &x,
673  {
674  evaluate<deriv>(x,&(values->block()));
675  }
676  template <unsigned int deriv, class Vector>
677  void evaluate ( const DomainVector &x,
678  Vector &values ) const
679  {
680  evaluate<deriv>( x, &(values[ 0 ]) );
681  }
682  template< class Vector >
683  void evaluate ( const DomainVector &x,
684  Vector &values ) const
685  {
686  evaluate<0>(x,values);
687  }
688  template< class DVector, class RVector >
689  void evaluate ( const DVector &x, RVector &values ) const
690  {
691  assert( DVector::dimension == dimension);
692  DomainVector bx;
693  for( int d = 0; d < dimension; ++d )
694  field_cast( x[ d ], bx[ d ] );
695  evaluate<0>( bx, values );
696  }
697  template< unsigned int deriv, class DVector, class RVector >
698  void evaluate ( const DVector &x, RVector &values ) const
699  {
700  assert( DVector::dimension == dimension);
701  DomainVector bx;
702  for( int d = 0; d < dimension; ++d )
703  field_cast( x[ d ], bx[ d ] );
704  evaluate<deriv>( bx, values );
705  }
706 
707  virtual void integrate ( Field *const values ) const = 0;
708  template <class Vector>
709  void integrate ( Vector &values ) const
710  {
711  integrate( &(values[ 0 ]) );
712  }
713  protected:
714  unsigned int order_;
715  GeometryType geometry_;
716  };
717 
718  template< GeometryType::Id geometryId, class F >
720  : public VirtualMonomialBasis< static_cast<GeometryType>(geometryId).dim(), F >
721  {
722  static constexpr GeometryType geometry = geometryId;
723  typedef VirtualMonomialBasis< geometry.dim(), F > Base;
725 
726  public:
727  typedef typename Base::Field Field;
729 
731  : Base(geometry,order), basis_(order)
732  {}
733 
734  const unsigned int *sizes ( ) const
735  {
736  return basis_.sizes(order_);
737  }
738 
739  void evaluate ( const unsigned int deriv, const DomainVector &x,
740  Field *const values ) const
741  {
742  basis_.evaluate(deriv,x,values);
743  }
744 
745  void integrate ( Field *const values ) const
746  {
747  basis_.integrate(values);
748  }
749 
750  private:
752  using Base::order_;
753  };
754 
755  // MonomialBasisFactory
756  // --------------------
757 
758  template< int dim, class F >
760  {
761  static const unsigned int dimension = dim;
762  typedef F StorageField;
763 
764  typedef unsigned int Key;
766 
767  template < int dd, class FF >
769  {
771  };
772 
773  template< GeometryType::Id geometryId >
774  static Object* create ( const Key &order )
775  {
777  }
778  static void release( Object *object ) { delete object; }
779  };
780 
781 
782 
783  // MonomialBasisProvider
784  // ---------------------
785 
786  template< int dim, class SF >
788  : public TopologySingletonFactory< MonomialBasisFactory< dim, SF > >
789  {
790  static const unsigned int dimension = dim;
791  typedef SF StorageField;
792  template < int dd, class FF >
794  {
796  };
797  };
798 
799 }
800 
801 #endif
Definition: bdfmcube.hh:16
void field_cast(const F1 &f1, F2 &f2)
a helper class to cast from one field to another
Definition: field.hh:157
A class representing the unit of a given Field.
Definition: field.hh:28
A class representing the zero of a given Field.
Definition: field.hh:77
Definition: monomialbasis.hh:82
unsigned int * numBaseFunctions_
Definition: monomialbasis.hh:98
void computeSizes(unsigned int order)
Definition: monomialbasis.hh:124
unsigned int * sizes_
Definition: monomialbasis.hh:95
MonomialBasisSize()
Definition: monomialbasis.hh:100
static This & instance()
Definition: monomialbasis.hh:86
~MonomialBasisSize()
Definition: monomialbasis.hh:108
unsigned int operator()(const unsigned int order) const
Definition: monomialbasis.hh:114
unsigned int maxOrder_
Definition: monomialbasis.hh:92
unsigned int maxOrder() const
Definition: monomialbasis.hh:119
Definition: monomialbasis.hh:438
unsigned int size() const
Definition: monomialbasis.hh:474
static const unsigned int dimension
Definition: monomialbasis.hh:444
Dune::FieldVector< Field, dimRange > RangeVector
Definition: monomialbasis.hh:451
void evaluate(const unsigned int deriv, const DomainVector &x, Field *const values) const
Definition: monomialbasis.hh:496
const unsigned int * sizes() const
Definition: monomialbasis.hh:469
unsigned int topologyId() const
Definition: monomialbasis.hh:491
void integrate(Vector &values) const
Definition: monomialbasis.hh:550
Base::Field Field
Definition: monomialbasis.hh:447
void integrate(Field *const values) const
Definition: monomialbasis.hh:545
static const unsigned int dimRange
Definition: monomialbasis.hh:445
Base::DomainVector DomainVector
Definition: monomialbasis.hh:449
void evaluate(const DomainVector &x, Field *const values) const
Definition: monomialbasis.hh:503
void evaluate(const DomainVector &x, Vector &values) const
Definition: monomialbasis.hh:529
void evaluate(const DomainVector &x, FieldVector< Field, Derivatives< Field, dimension, 1, deriv, DerivativeLayoutNS::value >::size > *values) const
Definition: monomialbasis.hh:522
void evaluate(const DomainVector &x, Derivatives< Field, dimension, 1, deriv, layout > *values) const
Definition: monomialbasis.hh:516
void evaluate(const DVector &x, RVector &values) const
Definition: monomialbasis.hh:536
MonomialBasisSize< geometryId > Size
Definition: monomialbasis.hh:453
void evaluate(const DomainVector &x, Vector &values) const
Definition: monomialbasis.hh:510
MonomialBasis(unsigned int order)
Definition: monomialbasis.hh:455
unsigned int derivSize(const unsigned int deriv) const
Definition: monomialbasis.hh:480
const unsigned int * sizes(unsigned int order) const
Definition: monomialbasis.hh:463
unsigned int order() const
Definition: monomialbasis.hh:486
Definition: monomialbasis.hh:175
MonomialBasisSize< GeometryTypes::simplex(dim).toId() > Size
Definition: monomialbasis.hh:177
static void copy(const unsigned int deriv, F *&wit, F *&rit, const unsigned int numBaseFunctions, const F &z)
Definition: monomialbasis.hh:179
MonomialBasisSize< GeometryTypes::simplex(mydim).toId() > MySize
Definition: monomialbasis.hh:176
Definition: monomialbasis.hh:232
FieldVector< Field, dimDomain > DomainVector
Definition: monomialbasis.hh:240
static constexpr GeometryType geometry
Definition: monomialbasis.hh:236
F Field
Definition: monomialbasis.hh:234
static const unsigned int dimDomain
Definition: monomialbasis.hh:238
Definition: monomialbasis.hh:569
static constexpr GeometryType geometry
Definition: monomialbasis.hh:574
StandardMonomialBasis(unsigned int order)
Definition: monomialbasis.hh:577
static const int dimension
Definition: monomialbasis.hh:575
Definition: monomialbasis.hh:590
static const int dimension
Definition: monomialbasis.hh:596
static constexpr GeometryType geometry
Definition: monomialbasis.hh:595
StandardBiMonomialBasis(unsigned int order)
Definition: monomialbasis.hh:598
Definition: monomialbasis.hh:610
unsigned int topologyId() const
Definition: monomialbasis.hh:646
GeometryType geometry_
Definition: monomialbasis.hh:715
FieldVector< Field, dimension > DomainVector
Definition: monomialbasis.hh:619
unsigned int order_
Definition: monomialbasis.hh:714
void evaluate(const DomainVector &x, Vector &values) const
Definition: monomialbasis.hh:683
void evaluate(const DomainVector &x, Field *const values) const
Definition: monomialbasis.hh:659
F Field
Definition: monomialbasis.hh:614
void evaluate(const DomainVector &x, Vector &values) const
Definition: monomialbasis.hh:677
void evaluate(const DVector &x, RVector &values) const
Definition: monomialbasis.hh:689
unsigned int order() const
Definition: monomialbasis.hh:640
virtual const unsigned int * sizes() const =0
static const unsigned int dimRange
Definition: monomialbasis.hh:617
F StorageField
Definition: monomialbasis.hh:615
static const int dimension
Definition: monomialbasis.hh:616
VirtualMonomialBasis(unsigned int topologyId, unsigned int order)
Definition: monomialbasis.hh:623
unsigned int size() const
Definition: monomialbasis.hh:635
FieldVector< Field, dimRange > RangeVector
Definition: monomialbasis.hh:620
virtual ~VirtualMonomialBasis()
Definition: monomialbasis.hh:631
virtual void evaluate(const unsigned int deriv, const DomainVector &x, Field *const values) const =0
virtual void integrate(Field *const values) const =0
void evaluate(const DomainVector &x, Dune::FieldVector< Field, size > *const values) const
Definition: monomialbasis.hh:665
void evaluate(const DVector &x, RVector &values) const
Definition: monomialbasis.hh:698
GeometryType type() const
Definition: monomialbasis.hh:651
void evaluate(const DomainVector &x, Derivatives< Field, dimension, 1, deriv, layout > *values) const
Definition: monomialbasis.hh:671
VirtualMonomialBasis(const GeometryType &gt, unsigned int order)
Definition: monomialbasis.hh:627
void integrate(Vector &values) const
Definition: monomialbasis.hh:709
Definition: monomialbasis.hh:721
void integrate(Field *const values) const
Definition: monomialbasis.hh:745
const unsigned int * sizes() const
Definition: monomialbasis.hh:734
Base::DomainVector DomainVector
Definition: monomialbasis.hh:728
Base::Field Field
Definition: monomialbasis.hh:727
void evaluate(const unsigned int deriv, const DomainVector &x, Field *const values) const
Definition: monomialbasis.hh:739
VirtualMonomialBasisImpl(unsigned int order)
Definition: monomialbasis.hh:730
Definition: monomialbasis.hh:760
static void release(Object *object)
Definition: monomialbasis.hh:778
const VirtualMonomialBasis< dimension, F > Object
Definition: monomialbasis.hh:765
F StorageField
Definition: monomialbasis.hh:762
static const unsigned int dimension
Definition: monomialbasis.hh:761
static Object * create(const Key &order)
Definition: monomialbasis.hh:774
unsigned int Key
Definition: monomialbasis.hh:764
MonomialBasisFactory< dd, FF > Type
Definition: monomialbasis.hh:770
Definition: monomialbasis.hh:789
static const unsigned int dimension
Definition: monomialbasis.hh:790
SF StorageField
Definition: monomialbasis.hh:791
MonomialBasisProvider< dd, FF > Type
Definition: monomialbasis.hh:795
Definition: tensor.hh:170