dune-localfunctions 2.10
Loading...
Searching...
No Matches
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 >:
Inheritance graph

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
 
template<class Fy >
using HessianFyType = FieldVector< FieldMatrix< Fy, dimension, dimension >, dimRange >
 
using HessianType = HessianFyType< R >
 

Public Member Functions

 PolynomialBasis (const Basis &basis, const CoefficientMatrix &coeffMatrix, unsigned int size)
 
const Basisbasis () const
 
const CoefficientMatrixmatrix () const
 
unsigned int order () const
 
unsigned int size () const
 
void evaluateFunction (const typename Traits::DomainType &x, std::vector< typename Traits::RangeType > &out) const
 Evaluate all shape functions.
 
void evaluateJacobian (const typename Traits::DomainType &x, std::vector< typename Traits::JacobianType > &out) const
 Evaluate Jacobian of all shape functions.
 
void evaluateHessian (const typename Traits::DomainType &x, std::vector< HessianType > &out) const
 Evaluate Jacobian of all shape functions.
 
void partial (const std::array< unsigned int, dimension > &order, const typename Traits::DomainType &in, std::vector< typename Traits::RangeType > &out) const
 Evaluate partial derivatives of all shape functions.
 
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 hessian (const DomainVector &x, std::vector< HessianFyType< Fy > > &values) const
 
template<class DVector , class HVector >
void hessian (const DVector &x, HVector &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
CMstorage 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

◆ Basis

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

◆ CoefficientMatrix

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

◆ DomainVector

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

◆ HessianFyType

template<class Eval , class CM , class D = double, class R = double>
template<class Fy >
using Dune::PolynomialBasis< Eval, CM, D, R >::HessianFyType = FieldVector<FieldMatrix<Fy,dimension,dimension>,dimRange>

◆ HessianType

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

◆ StorageField

template<class Eval , class CM , class D = double, class R = double>
typedef CoefficientMatrix::Field Dune::PolynomialBasis< Eval, CM, D, R >::StorageField

◆ Traits

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

◆ PolynomialBasis() [1/2]

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

◆ PolynomialBasis() [2/2]

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

◆ basis()

template<class Eval , class CM , class D = double, class R = double>
const Basis & Dune::PolynomialBasis< Eval, CM, D, R >::basis ( ) const
inline

◆ evaluate() [1/5]

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

◆ evaluate() [2/5]

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

◆ evaluate() [3/5]

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

◆ evaluate() [4/5]

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

◆ evaluate() [5/5]

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

◆ evaluateFunction()

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

Evaluate all shape functions.

◆ evaluateHessian()

template<class Eval , class CM , class D = double, class R = double>
void Dune::PolynomialBasis< Eval, CM, D, R >::evaluateHessian ( const typename Traits::DomainType x,
std::vector< HessianType > &  out 
) const
inline

Evaluate Jacobian of all shape functions.

◆ evaluateJacobian()

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

Evaluate Jacobian of all shape functions.

◆ evaluateSingle() [1/3]

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

◆ evaluateSingle() [2/3]

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

◆ evaluateSingle() [3/3]

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

◆ hessian() [1/2]

template<class Eval , class CM , class D = double, class R = double>
template<class Fy >
void Dune::PolynomialBasis< Eval, CM, D, R >::hessian ( const DomainVector x,
std::vector< HessianFyType< Fy > > &  values 
) const
inline

◆ hessian() [2/2]

template<class Eval , class CM , class D = double, class R = double>
template<class DVector , class HVector >
void Dune::PolynomialBasis< Eval, CM, D, R >::hessian ( const DVector &  x,
HVector &  values 
) const
inline

◆ integrate()

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

◆ jacobian() [1/2]

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

◆ jacobian() [2/2]

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

◆ matrix()

template<class Eval , class CM , class D = double, class R = double>
const CoefficientMatrix & Dune::PolynomialBasis< Eval, CM, D, R >::matrix ( ) const
inline

◆ operator=()

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

◆ order()

template<class Eval , class CM , class D = double, class R = double>
unsigned int Dune::PolynomialBasis< Eval, CM, D, R >::order ( ) const
inline

◆ partial()

template<class Eval , class CM , class D = double, class R = double>
void Dune::PolynomialBasis< Eval, CM, D, R >::partial ( const std::array< unsigned int, dimension > &  order,
const typename Traits::DomainType in,
std::vector< typename Traits::RangeType > &  out 
) const
inline

Evaluate partial derivatives of all shape functions.

◆ size()

template<class Eval , class CM , class D = double, class R = double>
unsigned int Dune::PolynomialBasis< Eval, CM, D, R >::size ( ) const
inline

Member Data Documentation

◆ basis_

template<class Eval , class CM , class D = double, class R = double>
const Basis& Dune::PolynomialBasis< Eval, CM, D, R >::basis_
protected

◆ coeffMatrix_

template<class Eval , class CM , class D = double, class R = double>
const CoefficientMatrix* Dune::PolynomialBasis< Eval, CM, D, R >::coeffMatrix_
protected

◆ dimension

template<class Eval , class CM , class D = double, class R = double>
const unsigned int Dune::PolynomialBasis< Eval, CM, D, R >::dimension = Evaluator::dimension
static

◆ dimRange

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

◆ eval_

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

◆ order_

template<class Eval , class CM , class D = double, class R = double>
unsigned int Dune::PolynomialBasis< Eval, CM, D, R >::order_
protected

◆ size_

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: