dune-localfunctions  2.2.1
Classes | Public Types | Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | List of all members
Dune::PolynomialBasis< Eval, CM, D, R > Class Template Reference

#include <dune/localfunctions/utility/polynomialbasis.hh>

Inheritance diagram for Dune::PolynomialBasis< Eval, CM, D, R >:
Dune::PolynomialBasisWithMatrix< Eval, CM, D, R >

Classes

struct  Convert
 
struct  Convert< dummy, DomainVector >
 

Public Types

typedef CM CoefficientMatrix
 
typedef CoefficientMatrix::Field StorageField
 
typedef LocalBasisTraits< D,
dimension, FieldVector< D,
dimension >, R, dimRange,
FieldVector< R, dimRange >
, FieldMatrix< R, dimRange,
dimension > > 
Traits
 
typedef Evaluator::Basis Basis
 
typedef Evaluator::DomainVector DomainVector
 

Public Member Functions

 PolynomialBasis (const Basis &basis, const CoefficientMatrix &coeffMatrix, unsigned int size)
 
const Basisbasis () const
 
const CoefficientMatrixmatrix () const
 
const unsigned int order () const
 
const unsigned int size () const
 
void evaluateFunction (const typename Traits::DomainType &x, std::vector< typename Traits::RangeType > &out) const
 Evaluate all shape functions. More...
 
void evaluateJacobian (const typename Traits::DomainType &x, std::vector< typename Traits::JacobianType > &out) const
 Evaluate Jacobian of all shape functions. More...
 
template<unsigned int deriv, class F >
void evaluate (const DomainVector &x, F *values) const
 
template<unsigned int deriv, class DVector , class F >
void evaluate (const DVector &x, F *values) const
 
template<unsigned int deriv, class DVector , class RVector >
void evaluate (const DVector &x, RVector &values) const
 
template<class Fy >
void evaluate (const DomainVector &x, std::vector< FieldVector< Fy, dimRange > > &values) const
 
template<class DVector , class RVector >
void evaluate (const DVector &x, RVector &values) const
 
template<unsigned int deriv, class Vector >
void evaluateSingle (const DomainVector &x, Vector &values) const
 
template<unsigned int deriv, class Fy >
void evaluateSingle (const DomainVector &x, std::vector< FieldVector< FieldVector< Fy, LFETensor< Fy, dimension, deriv >::size >, dimRange > > &values) const
 
template<unsigned int deriv, class Fy >
void evaluateSingle (const DomainVector &x, std::vector< FieldVector< LFETensor< Fy, dimension, deriv >, dimRange > > &values) const
 
template<class Fy >
void jacobian (const DomainVector &x, std::vector< FieldMatrix< Fy, dimRange, dimension > > &values) const
 
template<class DVector , class RVector >
void jacobian (const DVector &x, RVector &values) const
 
template<class Fy >
void integrate (std::vector< Fy > &values) const
 

Static Public Attributes

static const unsigned int dimension = Evaluator::dimension
 
static const unsigned int dimRange = Evaluator::dimRange*CoefficientMatrix::blockSize
 

Protected Member Functions

 PolynomialBasis (const PolynomialBasis &other)
 
PolynomialBasisoperator= (const PolynomialBasis &)
 

Protected Attributes

const Basisbasis_
 
const CoefficientMatrixcoeffMatrix_
 
Evaluator eval_
 
unsigned int order_
 
unsigned int size_
 

Detailed Description

template<class Eval, class CM, class D = double, class R = double>
class Dune::PolynomialBasis< Eval, CM, D, R >

This is the basis class for a ''polynomial'' basis, i.e., a basis consisting of linear combiniations of a underlying second basis set. Examples are standard polynomials where the underlying basis is given by the MonomialBasis class. The basis evaluation is given by the matrix vector multiplication between the coefficient matrix and the vector filled by evaluating the underlying basis set. This class is constructed using a reference of the underlying basis and the coefficient matrix. A specialization holding an instance of the coefficient matrix is provided by the class template< class Eval, class CM = SparseCoeffMatrix<typename Eval::Field,Eval::dimRange> > class PolynomialBasisWithMatrix;

Template Parameters
BBasis set with static const int dimension -> dimension of reference element typedef DomainVector -> coordinates in reference element int size(int order) const -> number of basis functions void evaluate( order, x, val ) const int order DomainVector x Container val
CMstroage for coefficience with typedef Field -> field of coefficience static const int dimRange -> coeficience are of type FieldMatrix<Field,dimRange,dimRange> void mult( val, y ) Container val std::vector<RangeVector> y
Containeraccess to basis functions through forward iterator typedef value_type typedef const_iterator const_iterator begin()

Member Typedef Documentation

template<class Eval , class CM , class D = double, class R = double>
typedef Evaluator::Basis Dune::PolynomialBasis< Eval, CM, D, R >::Basis
template<class Eval , class CM , class D = double, class R = double>
typedef CM Dune::PolynomialBasis< Eval, CM, D, R >::CoefficientMatrix
template<class Eval , class CM , class D = double, class R = double>
typedef Evaluator::DomainVector Dune::PolynomialBasis< Eval, CM, D, R >::DomainVector
template<class Eval , class CM , class D = double, class R = double>
typedef CoefficientMatrix::Field Dune::PolynomialBasis< Eval, CM, D, R >::StorageField
template<class Eval , class CM , class D = double, class R = double>
typedef LocalBasisTraits<D,dimension,FieldVector<D,dimension>, R,dimRange,FieldVector<R,dimRange>, FieldMatrix<R,dimRange,dimension> > Dune::PolynomialBasis< Eval, CM, D, R >::Traits

Constructor & Destructor Documentation

template<class Eval , class CM , class D = double, class R = double>
Dune::PolynomialBasis< Eval, CM, D, R >::PolynomialBasis ( const Basis basis,
const CoefficientMatrix coeffMatrix,
unsigned int  size 
)
inline
template<class Eval , class CM , class D = double, class R = double>
Dune::PolynomialBasis< Eval, CM, D, R >::PolynomialBasis ( const PolynomialBasis< Eval, CM, D, R > &  other)
inlineprotected

Member Function Documentation

template<class Eval , class CM , class D = double, class R = double>
const Basis& Dune::PolynomialBasis< Eval, CM, D, R >::basis ( ) const
inline
template<class Eval , class CM , class D = double, class R = double>
template<unsigned int deriv, class F >
void Dune::PolynomialBasis< Eval, CM, D, R >::evaluate ( const DomainVector x,
F *  values 
) const
inline
template<class Eval , class CM , class D = double, class R = double>
template<unsigned int deriv, class DVector , class F >
void Dune::PolynomialBasis< Eval, CM, D, R >::evaluate ( const DVector &  x,
F *  values 
) const
inline
template<class Eval , class CM , class D = double, class R = double>
template<unsigned int deriv, class DVector , class RVector >
void Dune::PolynomialBasis< Eval, CM, D, R >::evaluate ( const DVector &  x,
RVector &  values 
) const
inline
template<class Eval , class CM , class D = double, class R = double>
template<class Fy >
void Dune::PolynomialBasis< Eval, CM, D, R >::evaluate ( const DomainVector x,
std::vector< FieldVector< Fy, dimRange > > &  values 
) const
inline
template<class Eval , class CM , class D = double, class R = double>
template<class DVector , class RVector >
void Dune::PolynomialBasis< Eval, CM, D, R >::evaluate ( const DVector &  x,
RVector &  values 
) const
inline
template<class Eval , class CM , class D = double, class R = double>
void Dune::PolynomialBasis< Eval, CM, D, R >::evaluateFunction ( const typename Traits::DomainType x,
std::vector< typename Traits::RangeType > &  out 
) const
inline
template<class Eval , class CM , class D = double, class R = double>
void Dune::PolynomialBasis< Eval, CM, D, R >::evaluateJacobian ( const typename Traits::DomainType x,
std::vector< typename Traits::JacobianType > &  out 
) const
inline
template<class Eval , class CM , class D = double, class R = double>
template<unsigned int deriv, class Vector >
void Dune::PolynomialBasis< Eval, CM, D, R >::evaluateSingle ( const DomainVector x,
Vector &  values 
) const
inline
template<class Eval , class CM , class D = double, class R = double>
template<unsigned int deriv, class Fy >
void Dune::PolynomialBasis< Eval, CM, D, R >::evaluateSingle ( const DomainVector x,
std::vector< FieldVector< FieldVector< Fy, LFETensor< Fy, dimension, deriv >::size >, dimRange > > &  values 
) const
inline
template<class Eval , class CM , class D = double, class R = double>
template<unsigned int deriv, class Fy >
void Dune::PolynomialBasis< Eval, CM, D, R >::evaluateSingle ( const DomainVector x,
std::vector< FieldVector< LFETensor< Fy, dimension, deriv >, dimRange > > &  values 
) const
inline
template<class Eval , class CM , class D = double, class R = double>
template<class Fy >
void Dune::PolynomialBasis< Eval, CM, D, R >::integrate ( std::vector< Fy > &  values) const
inline
template<class Eval , class CM , class D = double, class R = double>
template<class Fy >
void Dune::PolynomialBasis< Eval, CM, D, R >::jacobian ( const DomainVector x,
std::vector< FieldMatrix< Fy, dimRange, dimension > > &  values 
) const
inline
template<class Eval , class CM , class D = double, class R = double>
template<class DVector , class RVector >
void Dune::PolynomialBasis< Eval, CM, D, R >::jacobian ( const DVector &  x,
RVector &  values 
) const
inline
template<class Eval , class CM , class D = double, class R = double>
const CoefficientMatrix& Dune::PolynomialBasis< Eval, CM, D, R >::matrix ( ) const
inline
template<class Eval , class CM , class D = double, class R = double>
PolynomialBasis& Dune::PolynomialBasis< Eval, CM, D, R >::operator= ( const PolynomialBasis< Eval, CM, D, R > &  )
protected
template<class Eval , class CM , class D = double, class R = double>
const unsigned int Dune::PolynomialBasis< Eval, CM, D, R >::order ( ) const
inline
template<class Eval , class CM , class D = double, class R = double>
const unsigned int Dune::PolynomialBasis< Eval, CM, D, R >::size ( ) const
inline

Member Data Documentation

template<class Eval , class CM , class D = double, class R = double>
const Basis& Dune::PolynomialBasis< Eval, CM, D, R >::basis_
protected
template<class Eval , class CM , class D = double, class R = double>
const CoefficientMatrix* Dune::PolynomialBasis< Eval, CM, D, R >::coeffMatrix_
protected
template<class Eval , class CM , class D = double, class R = double>
const unsigned int Dune::PolynomialBasis< Eval, CM, D, R >::dimension = Evaluator::dimension
static
template<class Eval , class CM , class D = double, class R = double>
const unsigned int Dune::PolynomialBasis< Eval, CM, D, R >::dimRange = Evaluator::dimRange*CoefficientMatrix::blockSize
static
template<class Eval , class CM , class D = double, class R = double>
Evaluator Dune::PolynomialBasis< Eval, CM, D, R >::eval_
mutableprotected
template<class Eval , class CM , class D = double, class R = double>
unsigned int Dune::PolynomialBasis< Eval, CM, D, R >::order_
protected
template<class Eval , class CM , class D = double, class R = double>
unsigned int Dune::PolynomialBasis< Eval, CM, D, R >::size_
protected

The documentation for this class was generated from the following file: