ModelExpressions

Arithmetic with models. More...

Modules
	ModelExpressionOptimizations
	Collapse the usual "zero" expressions into more simpler ones.

Classes
class	Dune::ACFem::BinaryModelExpression< BinOp, LeftModelType, RightModelType >
	Template for binary operations. More...
class	Dune::ACFem::UnaryModelExpression< UnOp, ModelType >
	Template for unary operations. More...
class	Dune::ACFem::UnaryModelExpression< IdentityOperation, Model >
	Unary identity operation which simply wraps the underlying model. More...
class	Dune::ACFem::UnaryModelExpression< MinusOperation, Model >
	Unary minus. More...
struct	Dune::ACFem::ModelTraits< BinaryModelExpression< BinOp, LeftModel, RightModel > >
	ModelExpression type traits. More...
class	Dune::ACFem::BinaryModelExpression< SMultiplyOperation, Factor, ModelType >
	S-multiplication with numbers (see below for S-multiplication with grid-functions). More...
class	Dune::ACFem::BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >
	Multiplication with grid-functions. More...

Functions
template<class LeftModelType , class RightModelType >
BinaryModelExpression< PlusOperation, LeftModelType, RightModelType >	Dune::ACFem::operator+ (const ModelInterface< LeftModelType > &f_, const ModelInterface< RightModelType > &g_)
	Add two models.
template<class LeftModelType , class RightModelType >
BinaryModelExpression< MinusOperation, LeftModelType, RightModelType >	Dune::ACFem::operator- (const ModelInterface< LeftModelType > &f_, const ModelInterface< RightModelType > &g_)
	Subtract two models.
template<class ModelType >
BinaryModelExpression< SMultiplyOperation, typename ModelType::RangeFieldType, ModelType >	Dune::ACFem::operator* (const typename ModelType::RangeFieldType &s_, const ModelInterface< ModelType > &f_)
	Multiplication with scalars from the left.
template<class ModelType >
auto	Dune::ACFem::operator* (const ModelInterface< ModelType > &m_, const typename ModelType::RangeFieldType &s_) -> decltype(s_ *asImp(m_))
	Multiplication with scalars from the right.
template<class Parameter , class ModelType >
BinaryModelExpression< SMultiplyOperation, Parameter, ModelType >	Dune::ACFem::operator* (const ParameterInterface< Parameter > &s_, const ModelInterface< ModelType > &f_)
	Multiplication with something satisfying ParameterInterface from the left.
template<class Parameter , class ModelType >
auto	Dune::ACFem::operator* (const ModelInterface< ModelType > &m_, const ParameterInterface< Parameter > &s_) -> decltype(asImp(s_) *asImp(m_))
	Multiplication with something satisfying ParameterInterface from the right.
template<class FactorFunction , class ModelType >
BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >	Dune::ACFem::operator* (const Fem::Function< typename FactorFunction::FunctionSpaceType::ScalarFunctionSpaceType, FactorFunction > &f_, const ModelInterface< ModelType > &m_)
	Left multiplication by a function. More...
template<class FactorFunction , class ModelType >
BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >	Dune::ACFem::operator* (const ModelInterface< ModelType > &m_, const Fem::Function< typename FactorFunction::FunctionSpaceType::ScalarFunctionSpaceType, FactorFunction > &f_)
	Right multiplication by a function.
template<class Model >
class UnaryModelExpression< MinusOperation, Model >	Dune::ACFem::operator- (const ModelInterface< Model > &m_)
	Unary minus.
template<class Model >
class UnaryModelExpression< IdentityOperation, Model >	Dune::ACFem::operator* (const ModelInterface< Model > &m_)
	Identity. More...
template<class Model >
auto	Dune::ACFem::operator+ (const ModelInterface< Model > &m_) -> decltype(*m_)
	Unary plus, acts like operator*(const ModelInterface<Model>&).
template<class Model , class DiscreteFunctionSpace , class Traits >
auto	Dune::ACFem::operator- (const ModelInterface< Model > &m_, const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &phi_) -> decltype(m_+std::declval< ForcesFunctionalModel< typename Traits::GlobalFunctionalType > >())
	Augment the model by a DiscreteLinearFunctional. More...
template<class Model , class DiscreteFunctionSpace , class Traits >
auto	Dune::ACFem::operator+ (const ModelInterface< Model > &m_, const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &phi_) -> decltype(m_ - std::declval< ForcesFunctionalModel< typename Traits::GlobalFunctionalType > >())
	Augment the model by a DiscreteLinearFunctional. More...
template<class Model , class GridFunction >
auto	Dune::ACFem::operator- (const ModelInterface< Model > &m, const Fem::Function< typename Model::FunctionSpaceType, GridFunction > &f) -> decltype(m+std::declval< BulkForcesFunctionModel< GridFunction > >())
	Augment the model by a right hand side, aka a "bulk forces function". More...
template<class Model , class GridFunction >
auto	Dune::ACFem::operator+ (const ModelInterface< Model > &m_, const Fem::Function< typename Model::FunctionSpaceType, GridFunction > &f) -> decltype(m_ - std::declval< BulkForcesFunctionModel< GridFunction > >())
	Augment the model by a right hand side, aka BulkForcesFunction. More...

Detailed Description

Arithmetic with models.

Function Documentation

operator*() [1/2]

template<class FactorFunction , class ModelType >

BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType > Dune::ACFem::operator*	(	const Fem::Function< typename FactorFunction::FunctionSpaceType::ScalarFunctionSpaceType, FactorFunction > &	f_,
		const ModelInterface< ModelType > &	m_
	)

Left multiplication by a function.

Note

The only natural way to treat functionals (see DiscreteLinearFunctional) as \(L^\infty\)-module is to multiply the argument of the functional by the \(L^\infty\)-function. This, however, is just the wrong side of the dual-pairing in comparison with the way all other parts of the model (see ModelInterface) are treated as \(L^\infty\)-module. Hence we do not allow multiplication by functions if ModelInterface::forcesFunctional does not return the zero-functional.

operator*() [2/2]

template<class Model >

class UnaryModelExpression< IdentityOperation, Model > Dune::ACFem::operator*

(

const ModelInterface< Model > &

m_

)

Identity.

Primarily meant in intermediate expressions in order to form something which is an expression data-type.

operator+() [1/2]

template<class Model , class DiscreteFunctionSpace , class Traits >

auto Dune::ACFem::operator+	(	const ModelInterface< Model > &	m_,
		const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &	phi_
	)		-> decltype(m_ - std::declval<ForcesFunctionalModel<typename Traits::GlobalFunctionalType> >())

Augment the model by a DiscreteLinearFunctional.

We use operator+ for this in order to express that we solve

Model + <Psi,.> = 0

although this function actually substracts two models.

Warning

You probably wanted to use Model - <Psi,.> = 0.

See also

operator-(const ModelInterface<Model>&, const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>&).

operator+() [2/2]

template<class Model , class GridFunction >

auto Dune::ACFem::operator+	(	const ModelInterface< Model > &	m_,
		const Fem::Function< typename Model::FunctionSpaceType, GridFunction > &	f
	)		-> decltype(m_ - std::declval<BulkForcesFunctionModel<GridFunction> >())

Augment the model by a right hand side, aka BulkForcesFunction.

We use operator+ for this in order to express that we solve

Model + F = 0

although this function actually substracts two models.

Warning

You probably wanted to use Model - F = 0.

See also

operator-(const ModelInterface<Model>&, const Fem::Function<typename Model::FunctionSpaceType, GridFunction>&)

operator-() [1/2]

template<class Model , class GridFunction >

auto Dune::ACFem::operator-	(	const ModelInterface< Model > &	m,
		const Fem::Function< typename Model::FunctionSpaceType, GridFunction > &	f
	)		-> decltype(m + std::declval<BulkForcesFunctionModel<GridFunction> >())

Augment the model by a right hand side, aka a "bulk forces function".

We use operator- for this in order to express that we solve

Model - F = 0

The resulting model will have the given function as ModelInterface::BulkForcesFunctionType and the respective method ModelInterface::bulkForcesFunction() will return an instance of this function.

operator-() [2/2]

template<class Model , class DiscreteFunctionSpace , class Traits >

auto Dune::ACFem::operator-	(	const ModelInterface< Model > &	m_,
		const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &	phi_
	)		-> decltype(m_ + std::declval<ForcesFunctionalModel<typename Traits::GlobalFunctionalType> >())

Augment the model by a DiscreteLinearFunctional.

We use operator- for this in order to express that we solve

Model - <Psi,.> = 0.

The resulting model will have the given function as ModelInterface::ForcesFunctionionalTraits::FunctionalType and the respective method ModelInterface::forcesFunctional() will return an instance of the functional.