Dune::ACFem Namespace Reference

A namespace encapsulating everything defined in our dune-acfem project. More...

Classes
class	EllipticFemSchemeBase
	Adaptive fem-scheme for "elliptic" problems. More...
class	EllipticFemScheme
	Constructor for the elliptic fem-scheme. More...
class	EllipticFemScheme< DiscreteFunction, Model, ZeroGridFunction< typename Model::FunctionSpaceType, typename Model::GridPartType > >
	Constructor for the elliptic fem-scheme. More...
class	BasicFemScheme
	Abstract non-adaptive basic FEM scheme. More...
class	AdaptiveFemScheme
	Abstract space adaptative FEM scheme. More...
class	ParabolicFemScheme
	Basic parabolic fem-scheme class. More...
class	SplittingFemSchemeBase
	Basic fem-scheme class. More...
class	SplittingFemScheme
	Constructor. More...
class	SplittingFemScheme< DiscreteFunction, ImplicitModel, ExplicitDataFunction, ExplicitModel, ZeroGridFunction< typename ImplicitModel::FunctionSpaceType, typename ImplicitModel::GridPartType > >
	Constructor. More...
class	SplittingFemScheme< DiscreteFunction, ImplicitModel, ZeroGridFunction< typename ImplicitModel::FunctionSpaceType, typename ImplicitModel::GridPartType >, ZeroModel< typename ImplicitModel::FunctionSpaceType, typename ImplicitModel::GridPartType >, InitialGuess >
	Constructor. More...
class	SplittingFemScheme< DiscreteFunction, ImplicitModel, ZeroGridFunction< typename ImplicitModel::FunctionSpaceType, typename ImplicitModel::GridPartType >, ZeroModel< typename ImplicitModel::FunctionSpaceType, typename ImplicitModel::GridPartType >, ZeroGridFunction< typename ImplicitModel::FunctionSpaceType, typename ImplicitModel::GridPartType > >
	Constructor. More...
class	DataOutputParameters
	Potentially overwrite some parameters. More...
struct	LagrangeLeafFunctionSelector
	Helper class which defines likey discrete function types. More...
struct	DiscontinuousGalerkinLeafFunctionSelector
	Helper class which defines likey discrete function types. More...
struct	DiscontinuousLagrangeLeafFunctionSelector
	Helper class which defines likey discrete function types. More...
struct	ExtractFunctor
	A functor which extracts values from a global array and copies them to a local array. More...
struct	ExtractFunctor< T *, GlobalArray >
	A functor which extracts values from a global array and copies them to a local array. More...
struct	PairFunctor
	Generate a compound functor out of two functors. More...
struct	TupleFunctor
	Generate a compound functor out of a tuple of functors. More...
class	IntersectionDataHandle
	General intersection - intersection communication which communicates for each intersection a potentially variable number of data-items. More...
class	LocalObjectFactory
	Define a factory for a "local object" which has a constructor which accepts a single argument, a "global object". More...
class	LocalObjectStack
	Local object stack which (hopefully) efficiently caches local objects. More...
struct	MutableLocalObjectStorageProvider
	Provide a writable object stack for technical reasons. More...
struct	MutableNoStorageProvider
	Provide a writable pseudo object stack which is only a reference to the global object. More...
struct	DefaultQuadratureTraits
	Helper traits-class, defining likely quadrature types. More...
struct	LumpingQuadratureTraits
	Helper traits-class, defining likely quadrature types for mass-lumping. More...
struct	SolverFamily
	Define some symbolic constants for SolverSelector and "parse" some preprocessort defines. More...
struct	SolverSelector
	Select one appropriate (linear) solver depending on whether the model is symmetric and/or semidefinite. More...
class	EllipticEstimator
	An standard residual estimator for elliptic problems. More...
class	ParabolicEulerEstimator
	Residual estimator for the heat equation. More...
class	TrueErrorEstimator
	"estimator" which return the "true" error with respect to some given function in some standard norm. More...
struct	ExpressionTemplate
	Provide up-cast functionality for expression templates. More...
struct	ExpressionReferenceStorage
	Store things as reference, serves as default implementation for the ExpressionStorage class. More...
struct	ExpressionCopyStorage
	Store things as copy, serves as default implementation for the ExpressionStorage class. More...
struct	ExpressionStorage
	An ExpressionStorage object stores either a copy or a reference of an object. More...
struct	PlusOperation
	Addition of two objects. More...
struct	MinusOperation
	Subtraction of two objects and unary minus. More...
struct	MultiplyOperation
	Multiplication of two objects. More...
struct	SMultiplyOperation
	Multiplication by scalars from the left. More...
struct	MutableSMultiplyOperation
	Multiplication by mutable scalars from the left. More...
struct	InvertOperation
	Inversion of an object. More...
struct	IdentityOperation
	Identity, i.e. just wrap the object. More...
struct	ExpOperation
	Exponentiation of an object. More...
struct	LogOperation
	Taking the logarithm of an object. More...
struct	SqrtOperation
	Taking the square root of an object. More...
struct	SquareOperation
	Taking the square of an object. More...
struct	SinOperation
	Taking the sine of an object. More...
struct	CosOperation
	Taking the cosine of an object. More...
struct	TanOperation
	Taking the cosine of an object. More...
struct	AtanOperation
	Taking the cosine of an object. More...
struct	AsinOperation
	Taking the cosine of an object. More...
struct	AcosOperation
	Taking the cosine of an object. More...
struct	ZeroExpression
	A tag structure which can be attached as base class to zero-expressions like the ZeroGridFunction, the ZeroModel, the ZeroFunctional. More...
struct	NonZeroExpression
	Complementary to ZeroExpression for use in std::conditional, for example, otherwise unused. More...
struct	OneExpression
	A tag structure which can be attached as base-class to expressions modelling a 1 (in a field, e.g., or the constant-one function) More...
struct	DefaultExpressionTraits
	Default expressions traits. More...
struct	ExpressionTraits
	A traits class in order to collect properties of expressions. More...
struct	ExpressionResult
	Automatically deduce the type by applying the respective operation. More...
struct	UnaryExpressionTraits
	The default result type is void in order to trigger compilation errors. More...
struct	BinaryExpressionTraits
	The default result type is void in order to trigger compilation errors. More...
struct	ParameterSpace
	A model for the vector space a parameter value lives in. More...
class	ParameterInterface
	Parameters are quasi-constant quantities, like the time-step size in one time-step when solving transient problems with finite element methods. More...
class	DefaultParameter
	Just for completeness, there is no default implementation. More...
struct	ParameterSpaceTraits
	The default template definition for this struct constructs a 1-dimensional parameter-value space (i.e. More...
struct	ParameterSpaceTraits< FieldVector< Field, dim > >
	The default template definition for this struct constructs a 1-dimensional parameter-value space (i.e. More...
class	TrivialParameter
	A simple wrapper: a really constant parameter. More...
class	ZeroParameter
	The zero parameter, unconditionally evalute to zero. More...
struct	UnaryParameterOperation< SinOperation >
	Componentwise sin. More...
struct	UnaryParameterOperation< CosOperation >
	Componentwise cos. More...
struct	UnaryParameterOperation< TanOperation >
	Componentwise tan. More...
struct	UnaryParameterOperation< AtanOperation >
	Componentwise atan. More...
struct	UnaryParameterOperation< AsinOperation >
	Componentwise asin. More...
struct	UnaryParameterOperation< AcosOperation >
	Componentwise acos. More...
struct	UnaryParameterOperation< SqrtOperation >
	Componentwise square root. More...
struct	UnaryParameterOperation< ExpOperation >
	Componentwise exp. More...
struct	UnaryParameterOperation< SquareOperation >
	Componentwise square. More...
class	VectorExpression
	Tag structure, flag all these as ExpressionTemplates. More...
class	BinaryVectorExpression
	Binary vector expressions. More...
class	UnaryVectorExpression
	Unary vector expressions. More...
class	BinaryVectorExpression< SMultiplyOperation, Scalar, Vector >
	Special case for S-multiplication. More...
class	UnaryVectorExpression< IdentityOperation, Vector >
	This is the only allowed starting point for vector-expressions: here we allow vectors to be wrapped inside the Identity-operation in order to be valid ExpressionTemplates for further operation. More...
class	UnaryVectorExpression< IdentityOperation, FieldMatrix< Field, rows, cols > >
	Wrap a FieldMatrix into an IdentityOperation. More...
struct	X
	Used as "tag" for coordinateGridFunction() and coordinateVectorFunction(). More...
struct	HasBoundarySupport
	Tag-structure to indicate additional functionality. More...
struct	HasNoBoundarySupport
	Negative tag-structure for use with std::conditional, complementary to HasBoundarySupport. More...
class	BoundarySupportedFunction
	A function with potentially partial support on the boundary. More...
struct	BoundaryFunctionTraits
	Helper traits in order to treat function w/o dedicated boundary support in the same way, mostly for the sake of ExpressionTemplates. More...
struct	BoundaryFunctionTraits< F, true >
struct	BoundaryFunctionTraits< F, false >
class	ConstantFunction
	A class describing a constant function. More...
class	ConstantGridFunction
	ConstantGridFunction implements a constant function. More...
class	ZeroGridFunction
	A grid-function always returning 0. More...
struct	ZeroGridFunctionTraits
	A grid-function tight to zero. More...
class	FractionGridFunction
	A grid-function which is constant with a scalar fractional value. More...
struct	FractionGridFunctionTraits
	A grid-function which is constant with a fractional value. More...
class	IdentityFunction
	A function which returns its argument. More...
class	CoordinateFunction
	Coordinate function returns a specific component of the world point, x_N, so to say. More...
class	LocalDivergenceAdapter
	An adapter class to compute the divergence of a GridFunction. More...
class	FunctionExpression
	Underlying tag-structure. More...
class	UnaryFunctionExpression
	Binary expressions. More...
class	BinaryFunctionExpression
	Unary expressions. More...
struct	BinaryFunctionExpressionTraits
	traits of BinaryFunctionExpression More...
struct	BinaryFunctionExpressionTraits< SMultiplyOperation, Factor, Function >
	S-multiplication with RangeFieldType scalars. More...
struct	BinaryFunctionExpressionTraits< PlusOperation, LeftFunction, RightFunction >
	Simple addition. More...
struct	BinaryFunctionExpressionTraits< MinusOperation, LeftFunction, RightFunction >
	Substraction. More...
class	BinaryFunctionExpression< SMultiplyOperation, FactorType, FunctionType >
	S-multiplication with RangeFieldType scalars. More...
struct	UnaryFunctionExpressionTraits
	traits of UnaryFunctionExpression More...
class	UnaryFunctionExpression< IdentityOperation, FunctionType >
	Specialize for the identity wrapper operation. More...
struct	BinaryFunctionExpressionOperation< MultiplyOperation >
	S-multiplication with scalar functions and scalar products. More...
struct	BinaryFunctionExpressionOperation< SMultiplyOperation >
	Multiplication from the left by a scalar constant. More...
class	LocalGradientAdapter
	An adapter class to compute the gradient of a scalar GridFunction. More...
class	GridFunctionAdapter
	GridFunctionAdapter provides local functions for a Function. More...
struct	GridFunctionAdapterTraits
	traits of GridFunctionAdapter More...
struct	BinaryGridFunctionExpressionTraits
	traits of BinaryGridFunctionExpression More...
class	BinaryGridFunctionExpression
	BinaryGridFunctionExpression implements point-wise vector-space operations for GridFunction-types. More...
struct	BinaryGridFunctionExpressionTraits< SMultiplyOperation, Factor, Function >
	S-multiplication with RangeFieldType scalars. More...
class	BinaryGridFunctionExpression< SMultiplyOperation, Factor, Function >
	S-multiplication with RangeFieldType scalars. More...
struct	UnaryGridFunctionExpressionTraits
	traits of UnaryGridFunctionExpression More...
class	UnaryGridFunctionExpression
	UnaryGridFunctionExpression implements point-wise unary operations for GridFunction-types. More...
class	UnaryGridFunctionExpression< IdentityOperation, FunctionType >
	Specialize for the identity wrapper operation. More...
class	UnaryGridFunctionExpression< InvertOperation, FunctionType >
	For the sake of BoundarySupportedFunction we need to specialize the InvertOperation. More...
class	GridFunctionExpression
	A class providing some basic functionality common to all expressions. More...
class	ZeroGridFunctionExpression
	A base class for zero function expression. More...
struct	IsPieceWiseConstant
	Tag type, consequences are zero Jacobian and Hessian. More...
struct	IsNotPieceWiseConstant
	Negation of IsPieceWiseConstant, in order to have something to branch to with std::conditional. More...
class	GridFunctionWrapper
	A special version of Fem::GridFunctionAdapter which stores a copy to the function, not a reference. More...
struct	GridFunctionConverter
	Helper class for wrapToGridFunction() and adaptToGridFunction() More...
class	LocalFunctionWrapper
	LocalFunctionWrapper wraps a class with a local evaluate method into a grid function. More...
struct	LocalFunctionWrapperTraits
	traits of DiscreteFunctionAdapter More...
class	LocalMaxAdapter
	An adapter class to compute the (pointwise) maximum of two scalar GridFunctions. More...
class	LocalNormAdapter< GridFunction, 2 >
	An adapter class to represent the pointwise euclidean norm of a (usually vector-valued) GridFunction. More...
class	ParameterFunction
	A class describing a constant function. More...
class	ParameterGridFunction
	ParameterGridFunction implements a constant function where the value is defined by something which fulfills the ParameterInterface. More...
class	LocalPiecewiseAdapter
	An adapter class to form a piecewise defined function where the domain decomposition is given by the characteristic function of one of the sub-domains. More...
class	LocalRightHandSideAdapter
	An adapter class which takes any ACFem-PDE model and computes from its bulk contributions and any given GridFunction a bulk forces density field (AKA "right hand side") such that the discrete solution of the PDE model should approximate the underlying "exact solution". More...
class	BoundaryIndicatorInterface
	A simple interface class for a boundary-indicator. More...
struct	DefaultBoundaryIndicator
	Default boundary indicator: like EntireBoundaryIndicator<false> More...
struct	BoundaryIndicatorExpression
	Expression tag-class for boundary indicators. More...
struct	BoundaryIdIndicator
	Apply to boundary segments which carry the respective id. More...
struct	ComplementBoundaryIndicator
	Turn any boundary-indicator into its complement. More...
struct	BoundaryIndicatorWrapper
	Wrap another boundary indicator. More...
struct	UnionBoundaryIndicator
	Union of two indicators, apply to the union of both boundary parts. More...
struct	IntersectionBoundaryIndicator
	Intersection of two indicators, apply iff both apply. More...
struct	EllipticModel
	A model for a second order elliptic operator. More...
class	BinaryModelExpression
	Template for binary operations. More...
class	UnaryModelExpression
	Template for unary operations. More...
class	UnaryModelExpression< IdentityOperation, Model >
	Unary identity operation which simply wraps the underlying model. More...
class	UnaryModelExpression< MinusOperation, Model >
	Unary minus. More...
struct	ModelTraits< BinaryModelExpression< BinOp, LeftModel, RightModel > >
	ModelExpression type traits. More...
class	BinaryModelExpression< SMultiplyOperation, Factor, ModelType >
	S-multiplication with numbers (see below for S-multiplication with grid-functions). More...
class	BinaryModelExpression< MultiplyOperation, FactorFunction, ModelType >
	Multiplication with grid-functions. More...
struct	ModelTraits
	Traits-template which has to be specialized for each individual model. More...
struct	DefaultModelTraits
	A structure defining some trivial default values for the template structure ModelTraits<ModelType>, given the function-space the beast maps to, and the grid part. More...
class	ModelInterface
	Interface class for second order elliptic models. More...
class	DefaultModel
	Default model implementation. More...
struct	ModelConstituents
	A helper class which identifies which components are provided by the given model. More...
struct	ModelConstituents< ModelInterface< Model > >
	Redirect to the real ModelConstituents from the interface class. More...
struct	FixedForcesFunctionalTraits
	Utiliy class to aid in the definition of ModelInterface::ForcesFunctionalTraits. More...
struct	BulkForcesFunctionModel
	Wrap an existing GridFunction into a model which only conatains this ModelConstituent. More...
class	BulkForcesFunctionModel< ZeroGridFunction< FunctionSpace, GridPart > >
	Special case for the ZeroGridFunction. More...
class	DeformationTensorOperatorParts
	Define the a model where the flux-part is formed from the symmetric gradient. More...
class	DirichletBoundaryModel
	A Dirichlet model. More...
class	DirichletBoundaryModel< GridFunction, EmptyBoundaryIndicatorType >
	Special case for the EmptyBoundaryIndicatorType. More...
class	DivergenceOperatorParts
	For a given grid-function define a model implementing the weak divergence. More...
class	FluidSelfTransportOperatorParts
	Define a model for the "Navier-Stokes" non-lineariry. More...
struct	ForcesFunctionalModel
	Wrap an existing DiscreteLinearFunctional into a model which only conatains this ModelConstituent. More...
class	ForcesFunctionalModel< ZeroFunctional< DiscreteFunctionSpace > >
	Special case for the ZeroFunctional. More...
class	GradientOperatorParts
	For a given grid-function define a model implementing the weak gradient. More...
class	IncompressibleSelfTransportOperatorParts
	Define a model for the "Navier-Stokes" non-lineariry. More...
class	IncompressibleTransportOperatorParts
	Define a model for an advection term with a divergence-free velocity field. More...
class	LaplacianOperatorParts
	Define a simple Laplacian-model, given function-space and grid-part. More...
class	MassOperatorParts
	Define a simple mass-model, given function-space and grid-part. More...
class	MeanCurvatureOperatorParts
	Define a mean-curvature model for graphs and level-sets. More...
class	NeumannBoundaryModel
	A Neumann-boundary model. More...
class	NeumannBoundaryModel< GridFunction, EmptyBoundaryIndicatorType >
	Special case for the EmptyBoundaryIndicatorType. More...
class	P_LaplacianOperatorParts
	The p-Laplacian-model. More...
class	P_MassOperatorParts
	A simplistic non-linear example. More...
class	RobinBoundaryOperatorParts
	A (homogeneous) Robin-boundary model. More...
class	RobinBoundaryOperatorParts< FunctionSpace, EmptyBoundaryIndicatorType >
	Special case for the EmptyBoundaryIndicatorType. More...
class	TransportOperatorParts
	Define a model for an advection term. More...
class	WeakDivergenceOperatorParts
	For a given grid-function define a model implementing the weak divergence. More...
struct	OperatorPartsTraits
	Traits-template which has to be specialized for each individual model. More...
struct	DefaultOperatorPartsTraits
	A structure defining some trivial default values for the template structure OperatorPartsTraits<PartsImpl>, given the function-space the beast maps to, and the grid part. More...
class	OperatorPartsInterface
	Interface class for second order elliptic models. More...
class	DefaultOperatorParts
	Default model implementation. More...
class	BinaryOperatorPartsExpression
	Template for binary operations. More...
class	UnaryOperatorPartsExpression
	Template for unary operations. More...
class	UnaryOperatorPartsExpression< IdentityOperation, Operand >
	Unary identity operation which simply wraps the underlying stuff. More...
class	UnaryOperatorPartsExpression< MinusOperation, Operand >
	Unary minus. More...
struct	OperatorPartsTraits< BinaryOperatorPartsExpression< BinOp, LeftOperand, RightOperand > >
	OperatorPartsExpression type traits. More...
class	BinaryOperatorPartsExpression< SMultiplyOperation, Factor, OperandType >
	S-multiplication with numbers (see below for S-multiplication with grid-functions). More...
class	BinaryOperatorPartsExpression< MultiplyOperation, FactorFunction, OperandType >
	Multiplication with grid-functions. More...
class	ZeroOperatorParts
	Define a simple zero model to optimize expression templates. More...
class	ProblemInterface
	Problem interface which describes a second order elliptic boundary problem: More...
class	TransientProblemInterface
	problem interface class for time dependent problem descriptions, i.e. More...
class	TimeStepParameter
	A Parameter-class which gives access to the current time-step size of an underlying Dune::Fem::TimeProvider. More...
class	InverseTimeStepParameter
	A Parameter-class which gives access to the inverse of the current time-step size of an underlying Dune::Fem::TimeProvider. More...
class	TimeViewParameter
	A Parameter-class which returns the absolute time corresponding to a fixed fraction of the current time-step. More...
class	TimeView
	Generate a view on the current time-step. More...
class	ZeroModel
	Define a simple zero model to optimize expression templates. More...
struct	BlockConstraintsDefaultTraits
	We need the type of the implementation and the local operator type. More...
struct	BlockConstraintsDefaultStorageTraits
	Default traits for BlockConstraints which LocalObjectStack usage. More...
class	BlockConstraintsOperatorInterface
	Interface class for a block-constraints-operator. More...
class	DifferentiableBlockConstraintsOperatorInterface
	Interface class for a differentiable block-constraints-operator. More...
class	BulkBlockConstraints
	A default implementation for bulk block constraints. More...
class	DirichletConstraints
	Implementation of Dirichlet constraints. More...
struct	DirichletBlockConstraintsTraits< JacobianOperator, BoundaryValues, EmptyBoundaryIndicatorType >
	Spezialization of Dirichlet constraints for emptyboundaryindicator. More...
class	EmptyBlockConstraints
	A class modelling do-nothing constraints. More...
class	DifferentiableEmptyBlockConstraints
	A class modelling differentiable do-nothing constraints. More...
class	EllipticOperator
	A class defining an elliptic operator. More...
class	DiracDistribution
	Dirac-distribution. More...
class	BinaryFunctionalExpression
	Binary functional expression. More...
struct	UnaryFunctionalExpressionTraits
	"No-storage", traits, stuff lives on the stack More...
struct	BinaryFunctionalExpressionTraits
	"No-storage", traits, stuff lives on the stack More...
class	BinaryLocalFunctionalExpression< SMultiplyOperation, LeftArg, RightArg >
	Implement S-multiplication by scalars and parameters from the left, multiplication from the right will be redirected to this class. More...
struct	LinearFunctionalTraitsDefault
	Default traits were the local objects are not cached, but created on the fly. More...
class	DiscreteLinearFunctional
	Interface class for a discrete linear functional. More...
class	DiscreteLinearFunctionalDefault
	Default implementation for linear functionals. More...
class	LocalLinearFunctional
	Interface or better: factory for local functionals. More...
class	LocalLinearFunctionalDefault
	Default implementation for LocalLinearFunctional. More...
class	NonZeroFunctional
	Just a place-holder to aid in automatic type-deduction. More...
class	ZeroFunctional
	This is the famous "do-nothing" functional. More...
class	L2ProjectionOperator
	Compute the L2-projection of the given functional to a discrete space. More...
class	RestrictProlongPair
	Chain two RestrictProlong implementations together. More...
struct	RestrictProlongDefaultTraits
	A helper class which defines the proper RestrictProlong compound data-type for tuples of Fem::DiscreteFunction implementations. More...
struct	RestrictProlongDefaultTraits< DiscreteFunction >
	A helper class which defines the proper RestrictProlong compound data-type for tuples of Fem::DiscreteFunction implementations. More...
struct	RestrictProlongDefaultTupleHelper
	AFAIK, C++11 is not capable of expanding tuples into parameter packs, so this recursive helper function is used to unpack a tuple and perform the necessary constructions in order to finally have a compound RestrictProlong type. More...
struct	RestrictProlongDefaultTupleHelper< Tuple, std::integral_constant< size_t, std::tuple_size< Tuple >::value-1 > >
	Recursion end-point to access the last argument of the tuple. More...

Functions
static std::pair< double, double >	adaptiveAlgorithm (AdaptiveFemScheme &scheme, const std::string &prefix_="")
	Stationary adaptive algorithm like adapt_method_stat() from poor old ALBERTA. More...
template<class TimeProvider >
static double	adaptiveAlgorithm (TransientAdaptiveFemScheme &scheme, TimeProvider &timeProvider, double endTime, const std::string &prefix_="")
	Space-time adaptive algorithm like adapt_method_instat() from poor old ALBERTA. More...
template<class FunctorOne , class FunctorTwo >
PairFunctor< FunctorOne, FunctorTwo >	makePairFunctor (FunctorOne &&func1, FunctorTwo &&func2)
	Combine two functors into one. More...
template<class... Types>
TupleFunctor< Types... >	makeTupleFunctor (Types &&... args)
	Combine several functors into one. More...
template<class Geometry >
Geometry::ctype	h2Estimate (const Geometry &geometry)
	Compute a rough estimate of the square of the diameter of the element's Geometry.
template<class Geometry >
Geometry::ctype	hEstimate (const Geometry &geometry)
	Compute a rough estimate of the diameter of the element's Geometry.
template<typename T >
bool	objectToString (const T &something, std::string &text)
	Convert any object which has an associated output stream operator "<<" to a string, return true on success and false on failure.
template<typename T >
bool	stringToObject (const std::string &text, T &something)
	Convert a string to any object with an associated input stream operator ">>", return true on success and false on failure.
static bool	checkParenthesis (const std::string &name, unsigned start, unsigned end)
	Check name for correct parenthesis. More...
static void	trimParenthesis (std::string &name)
	Remove any outer redundant parenthesis.
template<class DofMapper , int coDimension, class Functor >
void	mapEntityHierarchy (const DofMapper &mapper, const typename DofMapper::ElementType &element, int subIndex, const std::integral_constant< int, coDimension > &dummy, Functor f)
	Iterate over the entire sub-entity hierarchy below one given sub-entity (including the given one) and call the dof-mapper on each sub-entity in turn. More...
template<class DofMapper , class Intersection , class Functor >
void	mapEachFaceDof (const DofMapper &mapper, const Intersection &intersection, Functor f)
	Iterate over the codim-1 sub-entity hierarchy linked to the given intersection and call the dof-mapper on each sub-entity in turn. More...
template<class DofMapper , class Intersection , class LocalIndices , class GlobalIndices >
unsigned	mapFaceDofs (const DofMapper &mapper, const Intersection &intersection, LocalIndices &localIndices, GlobalIndices &globalIndices)
	Fetch all global DoFs of the codim-1 entity intersection belongs to. More...
template<class Interface , class Implementation >
const Implementation &	asImp (const Fem::BartonNackmanInterface< Interface, Implementation > &arg)
	Up-cast to the implementation for any Fem::BartonNackmanInterface. More...
template<class Expression >
constexpr bool	isZero (Expression &&)
	Specialize to evaluate to true for zero expressions.
template<class Left , class Right >
BinaryParameterExpression< MinusOperation, Left, Right >	operator- (const ParameterInterface< Left > &left, const ParameterInterface< Right > &right)
	Difference between parameters.
template<class Right >
BinaryParameterExpression< MinusOperation, typename Right::ValueType, Right >	operator- (const typename Right::ValueType &left, const ParameterInterface< Right > &right)
	Difference with vectors from the left.
template<class Left >
BinaryParameterExpression< MinusOperation, Left, typename Left::ValueType >	operator- (const ParameterInterface< Left > &left, const typename Left::ValueType &right)
	Difference with vectors from the right.
template<class Left , class Right >
BinaryParameterExpression< MultiplyOperation, Left, Right >	operator* (const ParameterInterface< Left > &left, const ParameterInterface< Right > &right)
	Scalar product between parameters.
template<class Right >
BinaryParameterExpression< MultiplyOperation, typename Right::ValueType, Right >	operator* (const typename Right::ValueType &left, const ParameterInterface< Right > &right)
	Multiplication by vectors from the left.
template<class Left >
auto	operator* (const ParameterInterface< Left > &left, const typename Left::ValueType &right) -> decltype(right *asImp(left))
	Multiplication by vectors from the right.
template<class Right >
BinaryParameterExpression< SMultiplyOperation, typename FieldTraits< typename Right::ValueType >::field_type, Right >	operator* (const typename FieldTraits< typename Right::ValueType >::field_type &left, const ParameterInterface< Right > &right)
	Multiplication by scalars from the left.
template<class Left >
auto	operator* (const ParameterInterface< Left > &left, const typename FieldTraits< typename Left::ValueType >::field_type &right) -> decltype(right *asImp(left))
	Multiplication by scalars from the right.
template<class Field , class Parameter >
static auto	operator* (const Field &s_, const BinaryParameterExpression< SMultiplyOperation, Field, Parameter > &P_) -> decltype((s_ *P_.left()) *P_.right())
	Fold s * (s * P) into (s*s) * P.
template<class Field , class Parameter1 , class Parameter2 >
static auto	operator* (const BinaryParameterExpression< SMultiplyOperation, Field, Parameter1 > &P1_, const ParameterInterface< Parameter2 > &P2_) -> decltype(P1_.left() *(P1_.right() *asImp(P2_)))
	Fold (s * P1) * P2 into s * (P1 * P2)
template<class Field , class Parameter1 , class Parameter2 >
static auto	operator* (const ParameterInterface< Parameter1 > &P1_, const BinaryParameterExpression< SMultiplyOperation, Field, Parameter2 > &P2_) -> decltype(P2_.left() *(asImp(P1_) *P2_.right()))
	Fold P1 * (s * P2) into s * (P1 * P2)
template<class Field , class Parameter1 , class Parameter2 >
static auto	operator* (const BinaryParameterExpression< SMultiplyOperation, Field, Parameter1 > &P1_, const BinaryParameterExpression< SMultiplyOperation, Field, Parameter2 > &P2_) -> decltype((P2_.left() *P2_.left()) *(P1_.right() *P2_.right()))
	Fold (s1 * P1) * (s2 * P2) into (s1 * s2) * (P1 * P2)
template<class Value >
ParameterValue< Value >::ResultType	parameterValue (const Value &value)
	Return the unaltered argument for non-parameters and otherwise the parameter value. More...
template<class Expr1 , class Expr2 >
static BinaryVectorExpression< PlusOperation, Expr1, Expr2 >	operator+ (const VectorExpression< Expr1 > &e1, const VectorExpression< Expr2 > &e2)
	Expr + Expr.
template<class Expr1 , class Expr2 >
static BinaryVectorExpression< MinusOperation, Expr1, Expr2 >	operator- (const VectorExpression< Expr1 > &e1, const VectorExpression< Expr2 > &e2)
	Expr - Expr.
template<class Expr1 , class Expr2 >
static InnerProductHelper< Expr1, Expr2 >::ResultType	operator* (const VectorExpression< Expr1 > &e1, const VectorExpression< Expr2 > &e2)
	Inner-product support. More...
template<class Expr >
static BinaryVectorExpression< SMultiplyOperation, typename Expr::FieldType, Expr >	operator* (const typename Expr::FieldType &s, const VectorExpression< Expr > &e)
	s * Expr.
template<class Expr >
static auto	operator* (const VectorExpression< Expr > &e, const typename Expr::FieldType &s) -> decltype(s *e)
	Expr * s.
template<class Expr >
static BinaryVectorExpression< SMultiplyOperation, typename Expr::FieldType, Expr >	operator* (const FieldVector< typename Expr::FieldType, 1 > &s, const VectorExpression< Expr > &e)
	s * e, specialize for scalar FieldVector case
template<class Expr >
static BinaryVectorExpression< SMultiplyOperation, typename Expr::FieldType, Expr >	operator* (const VectorExpression< Expr > &e, const FieldVector< typename Expr::FieldType, 1 > &s)
	e * s, specialize for scalar FieldVector case
template<class Expr >
static UnaryVectorExpression< MinusOperation, Expr >	operator- (const VectorExpression< Expr > &arg)
	-Expr
template<class Vector >
static UnaryVectorExpression< IdentityOperation, Vector >	asExpr (const Vector &arg)
	Catch all starting point.
template<class Field , int rows, int cols>
static UnaryVectorExpression< IdentityOperation, FieldMatrix< Field, rows, cols > >	asExpr (const FieldMatrix< Field, rows, cols > &arg)
	Special case for FieldMatrix.
template<class Op , class Expr >
static UnaryVectorExpression< Op, Expr >	asExpr (const UnaryVectorExpression< Op, Expr > &arg)
	Expr are expressions. More...
template<class Op , class Expr1 , class Expr2 >
static BinaryVectorExpression< Op, Expr1, Expr2 >	asExpr (const BinaryVectorExpression< Op, Expr1, Expr2 > &arg)
	Expr are expressions. More...
template<class Vector , class Op , class Expr1 , class Expr2 >
static Vector &	operator+= (Vector &v, const BinaryVectorExpression< Op, Expr1, Expr2 > &e)
	Add-assignment to result vector.
template<class Vector , class Op , class Expr >
static Vector &	operator+= (Vector &v, const UnaryVectorExpression< Op, Expr > &e)
	Add-assignment to result vector.
template<class Vector , class Op , class Expr1 , class Expr2 >
static Vector &	operator-= (Vector &v, const BinaryVectorExpression< Op, Expr1, Expr2 > &e)
	Minus-assignment to result vector.
template<class Vector , class Op , class Expr >
static Vector &	operator-= (Vector &v, const UnaryVectorExpression< Op, Expr > &e)
	Minus-assignment to result vector.
template<class GridPart >
static auto	identityGridFunction (const GridPart &gridPart)
	A grid-function which returns the world coordinates of its argument. More...
template<class GridPart , unsigned N>
static auto	coordinateGridFunction (const GridPart &gridPart, const std::integral_constant< unsigned, N > &dummy)
	A grid-function which returns the N-th component of the world coordinates of its argument. More...
template<class GridPart , unsigned N>
static ConstantGridFunction< Fem::FunctionSpace< typename GridPart::ctype, typename GridPart::ctype, GridPart::dimensionworld, GridPart::dimensionworld >, GridPart >	coordinateVectorFunction (const GridPart &gridPart, const std::integral_constant< unsigned, N > &dummy)
	Construct a unit coordinate vector.
template<class GridFunction >
LocalFunctionWrapper< LocalDivergenceAdapter< GridFunction >, typename GridFunction::GridPartType >	divergence (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &f_, const std::string &name="")
	Take the divergence of a given function.
template<class GridFunction >
LocalFunctionWrapper< LocalGradientAdapter< GridFunction >, typename GridFunction::GridPartType >	gradient (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &f_, const std::string &name="")
	Take the gradient of a given function.
template<class CharacteristicFunction , class GridFunction0 , class GridFunction1 >
LocalFunctionWrapper< LocalPiecewiseAdapter< CharacteristicFunction, GridFunction0, GridFunction1 >, typename GridFunction0::GridPartType >	piecewise (const Fem::Function< typename CharacteristicFunction::FunctionSpaceType, CharacteristicFunction > &characteristic, const Fem::Function< typename GridFunction0::FunctionSpaceType, GridFunction0 > &function0, const Fem::Function< typename GridFunction1::FunctionSpaceType, GridFunction1 > &function1, const std::string &name="")
	Form a piecewise defined function where the domain decomposition is defined by the indicator function of one of the sub-domains. More...
template<class CharacteristicFunction , class GridFunction1 >
LocalFunctionWrapper< LocalPiecewiseAdapter< CharacteristicFunction, ConstantGridFunction< typename GridFunction1::FunctionSpaceType, typename GridFunction1::GridPartType >, GridFunction1 >, typename GridFunction1::GridPartType >	piecewise (const Fem::Function< typename CharacteristicFunction::FunctionSpaceType, CharacteristicFunction > &characteristic, const typename GridFunction1::FunctionSpaceType::RangeType value0, const Fem::Function< typename GridFunction1::FunctionSpaceType, GridFunction1 > &function1, const std::string &name="")
	specialization for GridFunction0 of RangeType
template<class CharacteristicFunction , class GridFunction0 >
LocalFunctionWrapper< LocalPiecewiseAdapter< CharacteristicFunction, GridFunction0, ConstantGridFunction< typename GridFunction0::FunctionSpaceType, typename GridFunction0::GridPartType > >, typename GridFunction0::GridPartType >	piecewise (const Fem::Function< typename CharacteristicFunction::FunctionSpaceType, CharacteristicFunction > &characteristic, const Fem::Function< typename GridFunction0::FunctionSpaceType, GridFunction0 > &function0, const typename GridFunction0::FunctionSpaceType::RangeType value1, const std::string &name="")
	specialization for GridFunction1 of RangeType
template<class CharacteristicFunction , class FunctionSpaceType >
LocalFunctionWrapper< LocalPiecewiseAdapter< CharacteristicFunction, ConstantGridFunction< FunctionSpaceType, typename CharacteristicFunction::GridPartType >, ConstantGridFunction< FunctionSpaceType, typename CharacteristicFunction::GridPartType > >, typename CharacteristicFunction::GridPartType >	piecewise (const Fem::Function< typename CharacteristicFunction::FunctionSpaceType, CharacteristicFunction > &characteristic, const typename FunctionSpaceType::RangeType value0, const typename FunctionSpaceType::RangeType value1, const std::string &name="")
	specialization for GridFunction0 and GridFunction1 of RangeType
template<class Function , class Indicator >
static auto	operator- (const BoundarySupportedFunction< Function, Indicator > &f_) -> BoundarySupportedFunction< decltype(-f_.function()), Indicator >
	-Wrapped(f) = Wrapped(-f)
template<class Function , class Indicator >
static auto	operator+ (const BoundarySupportedFunction< Function, Indicator > &f_) -> BoundarySupportedFunction< Function, Indicator >
	+Wrapped(f) = Wrapped(f)
template<class Left , class Right , class LeftInd >
static auto	operator+ (const BoundarySupportedFunction< Left, LeftInd > &f_, const Fem::Function< typename Right::FunctionSpaceType, Right > &g_) -> decltype(asBndryFct(asExprArg(f_)+g_))
	Wrapped(f) + g = Wrapped(f + g)
template<class Left , class Right , class RightInd >
static auto	operator+ (const Fem::Function< typename Left::FunctionSpaceType, Left > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> decltype(asBndryFct(f_+asExprArg(g_)))
	f + Wrapped(g) = Wrapped(f + g)
template<class ZeroExpression , class Left , class LeftInd >
static auto	operator+ (const BoundarySupportedFunction< Left, LeftInd > &f_, const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &g_) -> decltype(asBndryFct(asExprArg(f_)+g_))
	Wrapped(f) + zero = Wrapped(f + zero) More...
template<class ZeroExpression , class Right , class RightInd >
static auto	operator+ (const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> decltype(asBndryFct(f_+asExprArg(g_)))
	zero + Wrapped(g) = Wrapped(zero + g) More...
template<class F , class FC , class Z >
static auto	operator+ (const BoundarySupportedFunction< F, FC > &f_, const BoundarySupportedFunction< Z, EmptyBoundaryIndicatorType > &z_) -> BoundarySupportedFunction< F, FC >
	Wrapped(f) + Empty = Wrapped(f)
template<class F , class FC , class Z >
static auto	operator+ (const BoundarySupportedFunction< Z, EmptyBoundaryIndicatorType > &z_, const BoundarySupportedFunction< F, FC > &f_) -> BoundarySupportedFunction< F, FC >
	Empty + Wrapped(f) = Wrapped(f)
template<class Z1 , class Z2 >
static BoundarySupportedFunction< ZeroGridFunction< typename Z1::FunctionSpaceType, typename Z1::GridPartType >, EmptyBoundaryIndicatorType >	operator+ (const BoundarySupportedFunction< Z1, EmptyBoundaryIndicatorType > &z1_, const BoundarySupportedFunction< Z2, EmptyBoundaryIndicatorType > &z2_)
	Empty + Empty = Empty.
template<class Left , class Right , class LeftInd , class RightInd >
static auto	operator- (const BoundarySupportedFunction< Left, LeftInd > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> decltype(asBndryFct(asExprArg(f_) - asExprArg(g_)))
	Wrapped(f) - Wrapped(g) = Wrapped(f - g)
template<class Left , class Right , class LeftInd >
static auto	operator- (const BoundarySupportedFunction< Left, LeftInd > &f_, const Fem::Function< typename Right::FunctionSpaceType, Right > &g_) -> decltype(asBndryFct(asExprArg(f_) - g_))
	Wrapped(f) - g = Wrapped(f - g)
template<class Left , class Right , class RightInd >
static auto	operator- (const Fem::Function< typename Left::FunctionSpaceType, Left > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> decltype(asBndryFct(f_ - asExprArg(g_)))
	f - Wrapped(g) = Wrapped(f - g)
template<class F , class FC , class Z >
static auto	operator- (const BoundarySupportedFunction< F, FC > &f_, const BoundarySupportedFunction< Z, EmptyBoundaryIndicatorType > &z_) -> BoundarySupportedFunction< F, FC >
	Wrapped(f) - Empty = Wrapped(f)
template<class F , class FC , class Z >
static auto	operator- (const BoundarySupportedFunction< Z, EmptyBoundaryIndicatorType > &z_, const BoundarySupportedFunction< F, FC > &f_) -> decltype(-f_)
	Empty - Wrapped(f) = Wrapped(-f)
template<class Z1 , class Z2 >
static BoundarySupportedFunction< ZeroGridFunction< typename Z1::FunctionSpaceType, typename Z1::GridPartType >, EmptyBoundaryIndicatorType >	operator- (const BoundarySupportedFunction< Z1, EmptyBoundaryIndicatorType > &z1_, const BoundarySupportedFunction< Z2, EmptyBoundaryIndicatorType > &z2_)
	Empty - Empty = Empty.
template<class Function , class Indicator >
static auto	operator* (const typename Function::RangeFieldType &s_, const BoundarySupportedFunction< Function, Indicator > &f_) -> decltype(asBndryFct(asEssBndryFct(s_ *asExprArg(f_))))
	s * Wrapped(f) = Wrapped(s * f)
template<class Function >
static BoundarySupportedFunction< ZeroGridFunction< typename Function::FunctionSpaceType, typename Function::GridPartType >, EmptyBoundaryIndicatorType >	operator* (const typename Function::RangeFieldType &s_, const BoundarySupportedFunction< Function, EmptyBoundaryIndicatorType > &f_)
	s * Wrapped(f, Empty) = Wrapped(zero, Empty)
template<class Function , class Indicator >
static auto	operator* (const BoundarySupportedFunction< Function, Indicator > &f_, const typename Function::RangeFieldType &s_) -> decltype(s_ *f_)
	Wrapped(f) * s = Wrapped(s * f)
template<class Parameter , class Function , class Indicator >
static auto	operator* (const ParameterInterface< Parameter > &p_, const BoundarySupportedFunction< Function, Indicator > &f_) -> decltype(asBndryFct(asEssBndryFct(asImp(p_) *asExprArg(f_))))
	Param * Wrapped(f) = Wrapped(Param * f)
template<class Parameter , class Function >
static BoundarySupportedFunction< ZeroGridFunction< typename Function::FunctionSpaceType, typename Function::GridPartType >, EmptyBoundaryIndicatorType >	operator* (const ParameterInterface< Parameter > &p_, const BoundarySupportedFunction< Function, EmptyBoundaryIndicatorType > &f_)
	Param * Wrapped(f, Empty) = Wrapped(zero, Empty)
template<class Field , class Parameter , class Function , class Indicator >
static auto	operator* (const BinaryParameterExpression< SMultiplyOperation, Field, Parameter > &p_, const BoundarySupportedFunction< Function, Indicator > &f_) -> decltype(p_.left() *(p_.right() *f_))
	Move scalars out of BinaryParameterExpression.
template<class Left , class Right , class LeftInd , class RightInd >
static auto	operator* (const BoundarySupportedFunction< Left, LeftInd > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> decltype(asBndryFct(asEssBndryFct(asExprArg(f_) *asExprArg(g_))))
	Wrapped(f) * Wrapped(g) = Wrapped(f * g)
template<class Zero , class F , class FInd >
static auto	operator* (const BoundarySupportedFunction< Zero, EmptyBoundaryIndicatorType > &z_, const BoundarySupportedFunction< F, FInd > &f_) -> BoundarySupportedFunction< decltype(zeroProduct(z_, f_)), EmptyBoundaryIndicatorType >
	Need to explicitly specialize the zero case, as the the multiplication zero optimiations for grid-function do not take the EmptyBoundaryIndicator into account.
template<class F , class Zero , class FInd >
static auto	operator* (const BoundarySupportedFunction< F, FInd > &f_, const BoundarySupportedFunction< Zero, EmptyBoundaryIndicatorType > &z_) -> BoundarySupportedFunction< decltype(zeroProduct(z_, f_)), EmptyBoundaryIndicatorType >
	Need to explicitly specialize the zero case, as the the multiplication zero optimiations for grid-function do not take the EmptyBoundaryIndicator into account.
template<class Left , class Right >
static auto	operator* (const BoundarySupportedFunction< Left, EmptyBoundaryIndicatorType > &z1_, const BoundarySupportedFunction< Right, EmptyBoundaryIndicatorType > &z2_) -> BoundarySupportedFunction< decltype(zeroProduct(z1_, z2_)), EmptyBoundaryIndicatorType >
	Need to explicitly specialize the zero case, as the the multiplication zero optimiations for grid-function do not take the EmptyBoundaryIndicator into account.
template<class Left , class Right , class RightInd >
static auto	operator* (const Fem::Function< typename Left::FunctionSpaceType, Left > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> BoundarySupportedFunction< typename EssBndryFct< decltype(asImp(f_) *g_.function())>::Type, typename BoundarySupportedFunction< Right, RightInd >::IndicatorType >
	f * Wrapped(g) = Wrapped(f * g)
template<class Left , class Right >
static auto	operator* (const Fem::Function< typename Left::FunctionSpaceType, Left > &f_, const BoundarySupportedFunction< Right, EmptyBoundaryIndicatorType > &g_) -> BoundarySupportedFunction< decltype(zeroProduct(asImp(f_), g_)), EmptyBoundaryIndicatorType >
	Zero specialization.
template<class ZeroExpression , class Function , class Indicator >
static auto	operator* (const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_, const BoundarySupportedFunction< Function, Indicator > &b_) -> BoundarySupportedFunction< decltype(zeroProduct(*z_, b_)), typename BoundarySupportedFunction< Function, Indicator >::IndicatorType >
	zero * Wrapped(g) = Wrapped(zero)
template<class ZeroExpression , class Right >
static auto	operator* (const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &f_, const BoundarySupportedFunction< Right, EmptyBoundaryIndicatorType > &g_) -> BoundarySupportedFunction< decltype(zeroProduct(*f_, g_)), EmptyBoundaryIndicatorType >
	Zero specialization.
template<class Function , class Wrapped , class Indicator >
static auto	operator* (const BoundarySupportedFunction< Wrapped, Indicator > &b_, const Fem::Function< typename Function::FunctionSpaceType, Function > &f_) -> BoundarySupportedFunction< typename EssBndryFct< decltype(b_.function() *asImp(f_))>::Type, typename BoundarySupportedFunction< Wrapped, Indicator >::IndicatorType >
	Wrapped(g) * f = Wrapped(g * f)
template<class Function , class Wrapped >
static auto	operator* (const BoundarySupportedFunction< Wrapped, EmptyBoundaryIndicatorType > &b_, const Fem::Function< typename Function::FunctionSpaceType, Function > &f_) -> BoundarySupportedFunction< decltype(zeroProduct(b_, asImp(f_))), EmptyBoundaryIndicatorType >
	Zero specialization.
template<class ZeroExpression , class Wrapped , class Indicator >
static auto	operator* (const BoundarySupportedFunction< Wrapped, Indicator > &b_, const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_) -> BoundarySupportedFunction< decltype(zeroProduct(b_, *z_)), typename BoundarySupportedFunction< Wrapped, Indicator >::IndicatorType >
	Wrapped(g) * zero = Wrapped(zero)
template<class ZeroExpression , class Wrapped >
static auto	operator* (const BoundarySupportedFunction< Wrapped, EmptyBoundaryIndicatorType > &b_, const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_) -> BoundarySupportedFunction< decltype(zeroProduct(b_, *z_)), EmptyBoundaryIndicatorType >
	Zero specialization.
template<class Function , class Indicator >
static BoundarySupportedFunction< Function, Indicator >	operator* (const decltype(oneFunction(std::declval< Function >()))&one, const BoundarySupportedFunction< Function, Indicator > &f_)
	1 * Wrapped(f) = Wrapped(f)
template<class Function , class Indicator >
static BoundarySupportedFunction< Function, Indicator >	operator* (const BoundarySupportedFunction< Function, Indicator > &f_, const decltype(oneFunction(std::declval< Function >()))&one)
	Wrapped(f) * 1 = Wrapped(f)
template<class Left , class Right , class RightInd >
static auto	operator/ (const Fem::Function< typename Left::FunctionSpaceType, Left > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> decltype(asBndryFct(asEssBndryFct(f_/asExprArg(g_))))
	f / Wrapped(g) = Wrapped(f / g)
template<class Function , class Indicator >
static auto	operator/ (const typename Function::RangeFieldType &s_, const BoundarySupportedFunction< Function, Indicator > &f_) -> decltype(asBndryFct(asEssBndryFct(s_/asExprArg(f_))))
	s / Wrapped(f) = Wrapped(s / f)
template<class Parameter , class Function , class Indicator >
static auto	operator/ (const ParameterInterface< Parameter > &p_, const BoundarySupportedFunction< Function, Indicator > &f_) -> decltype(asBndryFct(asEssBndryFct(asImp(p_)/asExprArg(f_))))
	Param * Wrapped(f) = Wrapped(Param * f)
template<class Indicator , class Function >
static auto	operator* (const BoundaryIndicatorInterface< Indicator > &chi, const Fem::Function< typename Function::FunctionSpaceType, Function > &f) -> decltype(boundarySupportedFunction(f, chi))
	chi * f More...
template<class Indicator , class Function >
static auto	operator* (const Fem::Function< typename Function::FunctionSpaceType, Function > &f, const BoundaryIndicatorInterface< Indicator > &chi) -> decltype(asImp(chi) *asImp(f))
	Multiplication from the right.
template<class Function >
static BoundarySupportedFunction< ZeroGridFunction< typename Function::FunctionSpaceType, typename Function::GridParType >, EmptyBoundaryIndicatorType >	operator* (const EmptyBoundaryIndicatorType &chi, const Fem::Function< typename Function::FunctionSpaceType, Function > &f)
	Empty * Something = Empty.
template<class Function , class Indicator >
static BoundarySupportedFunction< ZeroGridFunction< typename Function::FunctionSpaceType, typename Function::GridParType >, EmptyBoundaryIndicatorType >	operator* (const EmptyBoundaryIndicatorType &chi, const BoundarySupportedFunction< Function, Indicator > &f)
	Empty * Wrapped = Empty.
template<class Function , class Indicator >
static BoundarySupportedFunction< Function, Indicator >	operator* (const EntireBoundaryIndicatorType &chi, const BoundarySupportedFunction< Function, Indicator > &f)
	Entire * Wrapped = Wrapped.
template<class GridFunction , class Indicator = EntireBoundaryIndicatorType>
BoundarySupportedFunction< GridFunction, Indicator >	boundarySupportedFunction (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &f, const BoundaryIndicatorInterface< Indicator > &c=EntireBoundaryIndicatorType())
	Generate a function with partial support on the boundary.
template<class GridFunction , class Indicator >
BoundarySupportedFunction< GridFunction, Indicator >	boundarySupportedFunction (const BoundarySupportedFunction< GridFunction, Indicator > &f, const EntireBoundaryIndicatorType &=EntireBoundaryIndicatorType())
	Avoid re-wrapping.
template<class GridFunction >
static const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &	asExprFunction (const GridFunction &arg)
	Cast to the proper underlying expression class; for the generic case this is just the underlying Fem::Function base-class.
template<class UnOp , class Function >
static const UnaryGridFunctionExpression< UnOp, Function > &	asExprFunction (const UnaryGridFunctionExpression< UnOp, Function > &arg)
	Cast to the proper underlying expression class; this is the identity-specialization for things which actually are* expressions.
template<class BinOp , class LeftFunction , class RightFunction >
static const BinaryGridFunctionExpression< BinOp, LeftFunction, RightFunction > &	asExprFunction (const BinaryGridFunctionExpression< BinOp, LeftFunction, RightFunction > &arg)
	Cast to the proper underlying expression class; this is the identity-specialization for things which actually are* expressions.
template<class F1 , class F2 >
static ZeroGridFunction< typename FunctionMultiplicationResultTraits< typename F1::FunctionSpaceType, typename F2::FunctionSpaceType >::FunctionSpaceType, typename F1::GridPartType >	zeroProduct (const F1 &f1, const F2 &f2)
	Generate the proper zero-functions for products evaluating to zero. More...
template<class GridFunction >
GridFunction::LocalFunctionType	localFunction (const GridFunction &f)
	Generate a local function from any GridFunction.
template<class FunctionSpace , class GridPart >
FractionGridFunction< typename FunctionSpace::FunctionSpaceType::ScalarFunctionSpaceType, GridPart, 1L, 1UL >	oneFunction (const FunctionSpace &space, const GridPart &gridPart)
	Generate a proper constant-one function from the given Fem::FunctionSpace and Fem::GridPart. More...
template<class F >
auto	oneFunction (const F &f) -> decltype(oneFunction(f.space(), f.gridPart()))
	Generate a proper constant-one function from the given function. More...
template<class F >
auto	zeroFunction (const Fem::Function< typename F::FunctionSpaceType, F > &f_) -> ZeroGridFunction< typename F::FunctionSpaceType, typename F::GridPartType >
	Generate a ZeroGridFunction on the same function space.
template<class F >
auto	constantFunction (const Fem::Function< typename F::FunctionSpaceType, F > &f_, const typename F::FunctionSpaceType::RangeType &c) -> ConstantGridFunction< typename F::FunctionSpaceType, typename F::GridPartType >
	Generate a ConstantGridFunction on the same function space.
template<class Function >
static auto	operator* (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_, const typename Function::RangeFieldType &s) -> decltype(s *asImp(f_))
	f * s
template<class Parameter , class Function >
static BinaryGridFunctionExpression< SMultiplyOperation, Parameter, Function >	operator* (const ParameterInterface< Parameter > &s_, const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Param * f.
template<class Parameter , class Function >
static auto	operator* (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_, const ParameterInterface< Parameter > &s_) -> decltype(asImp(s_) *asImp(f_))
	f * Param
template<class LeftFunction , class RightFunction >
auto	operator/ (const Fem::Function< typename LeftFunction::FunctionSpaceType, LeftFunction > &l_, const Fem::Function< typename RightFunction::FunctionSpaceType::ScalarFunctionSpaceType, RightFunction > &r_) -> decltype(asImp(l_) *std::declval< UnaryGridFunctionExpression< InvertOperation, RightFunction > >())
	Divide some function by a scalar function.
template<class RightFunction >
auto	operator/ (const typename RightFunction::RangeFieldType &l_, const Fem::Function< typename RightFunction::FunctionSpaceType::ScalarFunctionSpaceType, RightFunction > &r_) -> decltype(l_ *std::declval< UnaryGridFunctionExpression< InvertOperation, RightFunction > >())
	Divide a field element by a scalar function.
template<class LeftParameter , class RightFunction >
auto	operator/ (const ParameterInterface< LeftParameter > &l_, const Fem::Function< typename RightFunction::FunctionSpaceType::ScalarFunctionSpaceType, RightFunction > &r_) -> decltype(asImp(l_) *std::declval< UnaryGridFunctionExpression< InvertOperation, RightFunction > >())
	Divide a parameter by a scalar function.
template<class Function >
static auto	operator/ (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_, const typename Function::RangeFieldType &s) -> decltype((1.0/s) *asImp(f_))
	Divide a function by a scalar.
template<class Function >
static BinaryGridFunctionExpression< PlusOperation, ConstantGridFunction< typename Function::FunctionSpaceType, typename Function::GridPartType >, Function >	operator+ (const typename Function::RangeType &s, const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Add a constant function to a function. More...
template<class Function >
static auto	operator+ (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_, const typename Function::RangeType &s_) -> decltype(s_+f_)
	Add a constant to a function from the right. More...
template<class Parameter , class Function >
static BinaryGridFunctionExpression< PlusOperation, ParameterGridFunction< Parameter, typename Function::FunctionSpaceType, typename Function::GridPartType >, Function >	operator+ (const ParameterInterface< Parameter > &s_, const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Add a constant parameter to a function. More...
template<class Parameter , class Function >
static auto	operator+ (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_, const ParameterInterface< Parameter > &s_) -> decltype(s_+f_)
	Add a constant parameter to a function from the right. More...
template<class Parameter , class Function >
static BinaryGridFunctionExpression< MinusOperation, ParameterGridFunction< Parameter, typename Function::FunctionSpaceType, typename Function::GridPartType >, Function >	operator- (const ParameterInterface< Parameter > &s_, const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Substract a function from a constant parameter, yielding a grid function as result. More...
template<class Parameter , class Function >
static BinaryGridFunctionExpression< MinusOperation, Function, ParameterGridFunction< Parameter, typename Function::FunctionSpaceType, typename Function::GridPartType > >	operator- (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_, const ParameterInterface< Parameter > &s_)
	Substract a constant parameter from a function. More...
template<class Function >
static UnaryGridFunctionExpression< IdentityOperation, Function >	operator* (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Turn a Fem::Function which must have the Fem::HasLocalFunction property into a GridFunctionExpression.
template<class Function >
static auto	operator+ (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_) -> decltype(*asImp(f_))
	unary + == unary *
template<class Function >
static UnaryGridFunctionExpression< ExpOperation, Function >	exp (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Component-wise exponentiation, exp(f)(x) = [exp(f(x)_0),...,exp(f(x)_N].
template<class Function >
static UnaryGridFunctionExpression< LogOperation, Function >	log (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Component-wise logarithm, log(f)(x) = [log(f(x)_0),...,log(f(x)_N].
template<class Function >
static UnaryGridFunctionExpression< SqrtOperation, Function >	sqrt (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Component-wise square-root, sqrt(f)(x) = [sqrt(f(x)_0),...,sqrt(f(x)_N].
template<class Function >
static UnaryGridFunctionExpression< SquareOperation, Function >	sqr (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Square operation, yielding the square of the Euclidian norm.
template<class Function >
static UnaryGridFunctionExpression< SinOperation, Function >	sin (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Component-wise sine function, sin(f)(x) = [sin(f(x)_0),...,sin(f(x)_N].
template<class Function >
static UnaryGridFunctionExpression< CosOperation, Function >	cos (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Component-wise cosine function, cos(f)(x) = [cos(f(x)_0),...,cos(f(x)_N].
template<class Function >
static UnaryGridFunctionExpression< TanOperation, Function >	tan (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Component-wise tanine function, tan(f)(x) = [tan(f(x)_0),...,tan(f(x)_N].
template<class Function >
static UnaryGridFunctionExpression< AtanOperation, Function >	atan (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Component-wise atan function, atan(f)(x) = [atan(f(x)_0),...,atan(f(x)_N].
template<class Function >
static UnaryGridFunctionExpression< AsinOperation, Function >	asin (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Component-wise asin function, asin(f)(x) = [asin(f(x)_0),...,asin(f(x)_N].
template<class Function >
static UnaryGridFunctionExpression< AcosOperation, Function >	acos (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_)
	Component-wise acos function, acos(f)(x) = [acos(f(x)_0),...,acos(f(x)_N].
template<class FunctionSpace , class Expression >
static Expression	operator* (const GridFunctionExpression< FunctionSpace, Expression > &f_)
	Avoid double wrapping.
template<class FunctionSpace , class GridPart >
static ZeroGridFunction< FunctionSpace, GridPart >	operator* (const ZeroGridFunction< FunctionSpace, GridPart > &f_)
	Avoid double wrapping.
template<class F >
static auto	operator- (const UnaryGridFunctionExpression< MinusOperation, F > &expr) -> decltype(+expr.function())
	-(-f) = f
template<class F1 , class F2 >
static auto	operator- (const BinaryGridFunctionExpression< MinusOperation, F1, F2 > &expr) -> decltype(expr.rightFunction() - expr.leftFunction())
	-(f - g) = g - f
template<class F1 , class F2 >
static auto	operator- (const BinaryGridFunctionExpression< PlusOperation, UnaryGridFunctionExpression< MinusOperation, F1 >, F2 > &expr) -> decltype(expr.leftFunction().function() - expr.rightFunction())
	-(-f + g) = f - g
template<class Field , class Function >
static auto	operator* (const Field &s_, const Fem::Function< typename Function::FunctionSpaceType, BinaryGridFunctionExpression< SMultiplyOperation, Field, Function > > &f_) -> decltype((s_ *asImp(f_).scalar()) *asImp(f_).function())
	Fold s * (s * f) into (s*s) * f.
template<class Field , class Function1 , class Function2 >
static auto	operator* (const Fem::Function< typename Function1::FunctionSpaceType, BinaryGridFunctionExpression< SMultiplyOperation, Field, Function1 > > &f1_, const Fem::Function< typename Function2::FunctionSpaceType, Function2 > &f2_) -> decltype(asImp(f1_).scalar() *(asImp(f1_).function() *asImp(f2_)))
	Fold (s * f1) * f2 into s *(f1 f2)
template<class Field , class Function1 , class Function2 >
static auto	operator* (const Fem::Function< typename Function1::FunctionSpaceType, Function1 > &f1_, const Fem::Function< typename Function2::FunctionSpaceType, BinaryGridFunctionExpression< SMultiplyOperation, Field, Function2 > > &f2_) -> decltype(asImp(f2_).scalar() *(asImp(f1_) *asImp(f2_).function()))
	Fold f1 * (s * f2) into s *(f1 f2)
template<class Field1 , class Field2 , class Function1 , class Function2 >
static auto	operator* (const Fem::Function< typename Function1::FunctionSpaceType, BinaryGridFunctionExpression< SMultiplyOperation, Field1, Function1 > > &f1_, const Fem::Function< typename Function2::FunctionSpaceType, BinaryGridFunctionExpression< SMultiplyOperation, Field2, Function2 > > &f2_) -> decltype((asImp(f1_).scalar() *asImp(f2_).scalar()) *(asImp(f1_).function() *asImp(f2_).function()))
	Fold (s1 * f1) * (s2 * f2) into (s1*s2) *(f1 f2)
template<class Parameter , class Function >
static auto	operator* (const ParameterInterface< Parameter > &p_, const Fem::Function< typename Function::FunctionSpaceType, BinaryGridFunctionExpression< SMultiplyOperation, typename Function::RangeFieldType, Function > > &f_) -> decltype(asImp(f_).scalar() *(asImp(p_) *asImp(f_).function()))
	Move scalars left-most.
template<class Field , class Parameter , class Function >
static auto	operator* (const BinaryParameterExpression< SMultiplyOperation, Field, Parameter > &p_, const Fem::Function< typename Function::FunctionSpaceType, Function > &f_) -> decltype(p_.left() *(p_.right() *asImp(f_)))
	Move scalars out of BinaryParameterExpression.
template<class Parameter , class ZeroExpression >
static ZeroExpression	operator* (const BinaryParameterExpression< SMultiplyOperation, typename ZeroExpression::RangeFieldType, Parameter > &p_, const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_)
	We need to specialize moving scalars out of expressions for ZeroGridFunction, otherwise the optimization results in ambiguous overloads. More...
template<class ZeroExpression >
static ZeroExpression	operator* (const typename ZeroExpression::RangeFieldType &s, const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z)
	s * zero = zero
template<class Parameter , class ZeroExpression >
static ZeroExpression	operator* (const ParameterInterface< Parameter > &s_, const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z)
	Param * zero = zero.
template<class Function , class ZeroExpression >
static auto	operator* (const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_, const Fem::Function< typename Function::FunctionSpaceType, Function > &g_) -> decltype(zeroProduct(*z_, g_))
	Zero * SomeThing = Zero.
template<class Function , class ZeroExpression >
static auto	operator* (const Fem::Function< typename Function::FunctionSpaceType, Function > &g_, const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_) -> decltype(z_ *g_)
	SomeThing * Zero = Zero.
template<class ZeroExpression1 , class ZeroExpression2 >
static auto	operator* (const ZeroGridFunctionExpression< typename ZeroExpression1::FunctionSpaceType, ZeroExpression1 > &z1, const ZeroGridFunctionExpression< typename ZeroExpression2::FunctionSpaceType, ZeroExpression2 > &z2) -> decltype(zeroProduct(*z1, z2))
	Zero * Zero = Zero.
template<class Function , class ZeroExpression >
static auto	operator+ (const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_, const Fem::Function< typename Function::FunctionSpaceType, Function > &f_) -> decltype(*asImp(f_))
	Zero + SomeThing = SomeThing.
template<class Function , class ZeroExpression >
static auto	operator+ (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_, const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_) -> decltype(*asImp(f_))
	SomeThing + Zero = SomeThing.
template<class ZeroExpression1 , class ZeroExpression2 >
static ZeroExpression1	operator+ (const ZeroGridFunctionExpression< typename ZeroExpression1::FunctionSpaceType, ZeroExpression1 > &z1_, const ZeroGridFunctionExpression< typename ZeroExpression2::FunctionSpaceType, ZeroExpression2 > &z2_)
	Zero + Zero has to be specialized in order to avoid ambiguous overloading.
template<class Function , class ZeroExpression >
static auto	operator- (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_, const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_) -> decltype(*asImp(f_))
	SomeThing - Zero = SomeThing.
template<class Function , class ZeroExpression >
static auto	operator- (const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_, const Fem::Function< typename Function::FunctionSpaceType, Function > &f_) -> decltype(-asImp(f_))
	Zero - SomeThing = -SomeThing.
template<class ZeroExpression1 , class ZeroExpression2 >
static ZeroExpression1	operator- (const ZeroGridFunctionExpression< typename ZeroExpression1::FunctionSpaceType, ZeroExpression1 > &z1_, const ZeroGridFunctionExpression< typename ZeroExpression2::FunctionSpaceType, ZeroExpression2 > &z2_)
	Zero - Zero = Zero. More...
template<class ZeroExpression >
static ZeroExpression	operator- (const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_)
	-Zero = Zero
template<class FunctionImp , class GridPart >
static auto	wrapToGridFunction (const std::string &name, const FunctionImp &f, const GridPart &g, unsigned order=111)
	Possibly wrap a function into a GridFunctionWrapper. More...
template<class FunctionImp , class GridPart >
static auto	adaptToGridFunction (const std::string &name, const FunctionImp &f, const GridPart &g, unsigned order=111)
	Possibly enhance a function by encapsulating a reference into a GridFunctionAdapter. More...
template<class Function , class GridPart >
static auto	operator- (const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(-asExprArg(f_)), GridPart >
	-Wrapped(f) = Wrapped(-f)
template<class Function , class GridPart >
static auto	operator+ (const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< Function, GridPart >
	+Wrapped(f) = Wrapped(f)
template<class Left , class Right , class GridPart >
static auto	operator+ (const GridFunctionWrapper< Left, GridPart > &f_, const GridFunctionWrapper< Right, GridPart > &g_) -> GridFunctionWrapper< decltype(asExprArg(f_)+asExprArg(g_)), GridPart >
	Wrapped(f) + Wrapped(g) = Wrapped(f + g)
template<class Left , class Right , class GridPart >
static auto	operator- (const GridFunctionWrapper< Left, GridPart > &f_, const GridFunctionWrapper< Right, GridPart > &g_) -> GridFunctionWrapper< decltype(asExprArg(f_) - asExprArg(g_)), GridPart >
	Wrapped(f) - Wrapped(g) = Wrapped(f - g)
template<class Function , class GridPart >
static auto	operator* (const typename Function::RangeFieldType &s_, const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(s_ *asExprArg(f_)), GridPart >
	s * Wrapped(f) = Wrapped(s * f)
template<class Function , class GridPart >
static auto	operator* (const GridFunctionWrapper< Function, GridPart > &f_, const typename Function::RangeFieldType &s_) -> decltype(s_ *f_)
	Wrapped(f) * s = Wrapped(s * f)
template<class Parameter , class Function , class GridPart >
static auto	operator* (const ParameterInterface< Parameter > &p_, const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(asImp(p_) *asExprArg(f_)), GridPart >
	Param * Wrapped(f) = Wrapped(Param * f)
template<class Parameter , class Function , class GridPart >
static auto	operator* (const GridFunctionWrapper< Function, GridPart > &f_, const ParameterInterface< Parameter > &p_) -> decltype(asImp(p_) *f_)
	Wrapped(f) * Param = Wrapped(Param * f)
template<class Field , class Parameter , class Function , class GridPart >
static auto	operator* (const BinaryParameterExpression< SMultiplyOperation, Field, Parameter > &p_, const GridFunctionWrapper< Function, GridPart > &f_) -> decltype(p_.left() *(p_.right() *f_))
	Move scalars out of BinaryParameterExpression.
template<class Left , class Right , class GridPart >
static auto	operator* (const GridFunctionWrapper< Left, GridPart > &f_, const GridFunctionWrapper< Right, GridPart > &g_) -> GridFunctionWrapper< decltype(asExprArg(f_) *asExprArg(g_)), GridPart >
	Wrapped(f) * Wrapped(g) = Wrapped(f * g)
template<class Left , class Right , class GridPart >
static auto	operator/ (const GridFunctionWrapper< Left, GridPart > &f_, const GridFunctionWrapper< Right, GridPart > &g_) -> GridFunctionWrapper< decltype(asExprArg(f_)/asExprArg(g_)), GridPart >
	Wrapped(f) / Wrapped(scalar g) = Wrapped(f * 1/g)
template<class Function , class GridPart >
static auto	operator/ (const typename Function::RangeFieldType &s_, const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(s_/asExprArg(f_)), GridPart >
	s / Wrapped(g) = Wrapped(s / g)
template<class Parameter , class Function , class GridPart >
static auto	operator/ (const ParameterInterface< Parameter > &p_, const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(asImp(p_)/asExprArg(f_)), GridPart >
	Param / Wrapped(f) = Wrapped(Param / f)
template<class Function , class GridPart >
static auto	exp (const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(exp(asExprArg(f_))), GridPart >
	exp(Wrapped(f)) = Wrapped(exp(f))
template<class Function , class GridPart >
static auto	log (const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(log(asExprArg(f_))), GridPart >
	log(Wrapped(f)) = Wrapped(log(f))
template<class Function , class GridPart >
static auto	sqrt (const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(sqrt(asExprArg(f_))), GridPart >
	sqrt(Wrapped(f)) = Wrapped(sqrt(f))
template<class Function , class GridPart >
static auto	sqr (const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(sqr(asExprArg(f_))), GridPart >
	sqr(Wrapped(f)) = Wrapped(sqr(f))
template<class Function , class GridPart >
static auto	sin (const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(sin(asExprArg(f_))), GridPart >
	sin(Wrapped(f)) = Wrapped(sin(f))
template<class Function , class GridPart >
static auto	cos (const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(cos(asExprArg(f_))), GridPart >
	cos(Wrapped(f)) = Wrapped(cos(f))
template<class Function , class GridPart >
static auto	tan (const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(tan(asExprArg(f_))), GridPart >
	tan(Wrapped(f)) = Wrapped(tan(f))
template<class Function , class GridPart >
static auto	atan (const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(atan(asExprArg(f_))), GridPart >
	atan(Wrapped(f)) = Wrapped(atan(f))
template<class Function , class GridPart >
static auto	asin (const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(asin(asExprArg(f_))), GridPart >
	asin(Wrapped(f)) = Wrapped(asin(f))
template<class Function , class GridPart >
static auto	acos (const GridFunctionWrapper< Function, GridPart > &f_) -> GridFunctionWrapper< decltype(acos(asExprArg(f_))), GridPart >
	acos(Wrapped(f)) = Wrapped(acos(f))
template<class GridFunction1 , class GridFunction2 >
LocalFunctionWrapper< LocalMaxAdapter< GridFunction1, GridFunction2 >, typename GridFunction1::GridPartType >	max (const Fem::Function< typename GridFunction1::FunctionSpaceType, GridFunction1 > &f1, const Fem::Function< typename GridFunction2::FunctionSpaceType, GridFunction2 > &f2, const std::string &name="")
	Pointwise maximum of two given functions.
template<class GridFunction1 >
LocalFunctionWrapper< LocalMaxAdapter< GridFunction1, ConstantGridFunction< typename GridFunction1::FunctionSpaceType, typename GridFunction1::GridPartType > >, typename GridFunction1::GridPartType >	max (const Fem::Function< typename GridFunction1::FunctionSpaceType, GridFunction1 > &f1, const typename GridFunction1::FunctionSpaceType::RangeType value2, const std::string &name="")
	Pointwise maximum of two given functions where one is given by a RangeType value.
template<class GridFunction >
LocalFunctionWrapper< LocalNormAdapter< GridFunction, 2 >, typename GridFunction::GridPartType >	twoNorm (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &f, const std::string &name="")
	Pointwise euclidean norm of a given function.
template<class OperatorParts , class Solution >
LocalFunctionWrapper< LocalRightHandSideAdapter< OperatorParts, Solution >, typename Solution::GridPartType >	rightHandSide (const OperatorPartsInterface< OperatorParts > &operatorParts, const Fem::Function< typename Solution::FunctionSpaceType, Solution > &solution_, const std::string &name="")
	Take any PDE operatorparts and an "exact solutio" and generate a right-hand-side force-density such that the PDE-operatorparts should reproduce the given "solution" – provided that the boundary conditions match also ...
template<class Intersection >
bool	isDomainBoundary (const Intersection &intersection)
	Return true if at the global domain boundary.
template<class Intersection >
bool	isPeriodicBoundary (const Intersection &intersection)
	Return true if at a periodic boundary. More...
template<class Intersection >
bool	isProcessorBoundary (const Intersection &intersection)
	Retrun true if at the border to another computing note. More...
template<class Intersection >
bool	isInterior (const Intersection &intersection)
	Return true if there is a neighbor. More...
template<class Indicator >
BoundaryIndicatorWrapper< Indicator >	operator* (const BoundaryIndicatorInterface< Indicator > &arg)
	Wrap another indicator by making a copy.
template<class Indicator >
auto	operator+ (const BoundaryIndicatorInterface< Indicator > &arg) -> decltype(*asImp(arg))
	Unary plus is like *.
template<class Indicator >
Indicator	operator* (const BoundaryIndicatorExpression< Indicator > &arg)
	Avoid duplicate wrapping and wrapping of expressions.
template<class Indicator >
ComplementBoundaryIndicator< Indicator >	operator! (const BoundaryIndicatorInterface< Indicator > &arg)
	Boolean negation, take the complement.
template<class Indicator >
auto	operator- (const BoundaryIndicatorInterface< Indicator > &arg) -> decltype(!asImp(arg))
	Unary - is like !
template<class Indicator >
auto	operator! (const ComplementBoundaryIndicator< Indicator > &arg) -> decltype(*arg.containedExpression())
	Collapse double !, wrap the original indicator.
template<class One , class Two >
UnionBoundaryIndicator< One, Two >	operator|| (const BoundaryIndicatorInterface< One > &one, const BoundaryIndicatorInterface< Two > &two)
	Union of two indicators.
template<class One , class Two >
auto	operator+ (const BoundaryIndicatorInterface< One > &one, const BoundaryIndicatorInterface< Two > &two) -> decltype(asImp(one)||asImp(two))
	Union of two indicators.
template<class One , class Two >
IntersectionBoundaryIndicator< One, Two >	operator&& (const BoundaryIndicatorInterface< One > &one, const BoundaryIndicatorInterface< Two > &two)
	Intersection of two indicators.
template<class One , class Two >
auto	operator* (const BoundaryIndicatorInterface< One > &one, const BoundaryIndicatorInterface< Two > &two) -> decltype(asImp(one) &&asImp(two))
	Intersection of two indicators.
template<class One , class Two >
auto	operator- (const BoundaryIndicatorInterface< One > &one, const BoundaryIndicatorInterface< Two > &two) -> decltype(asImp(one) &&(!asImp(two)))
	Difference in the sense of \(A \setminus B\).
static EntireBoundaryIndicatorType	operator! (const EmptyBoundaryIndicatorType &arg)
	!Empty = EntireBoundary
static EmptyBoundaryIndicatorType	operator! (const EntireBoundaryIndicatorType &arg)
	!EntireBoundary = Empty
template<class Other >
static auto	operator|| (const EmptyBoundaryIndicatorType &one, const BoundaryIndicatorInterface< Other > &two) -> decltype(*asImp(two))
	Empty || Something = Something.
template<class Other >
static auto	operator|| (const BoundaryIndicatorInterface< Other > &one, const EmptyBoundaryIndicatorType &two) -> decltype(*asImp(one))
	Something || Empty = Something.
static EmptyBoundaryIndicatorType	operator|| (const EmptyBoundaryIndicatorType &one, const EmptyBoundaryIndicatorType &two)
	Empty || Empty = Empty.
template<class Other >
static EntireBoundaryIndicatorType	operator|| (const EntireBoundaryIndicatorType &one, const BoundaryIndicatorInterface< Other > &two)
	All || Something = All.
template<class Other >
static EntireBoundaryIndicatorType	operator|| (const BoundaryIndicatorInterface< Other > &one, const EntireBoundaryIndicatorType &two)
	Something || All = All.
static EntireBoundaryIndicatorType	operator|| (const EntireBoundaryIndicatorType &one, const EntireBoundaryIndicatorType &two)
	All || All = All.
static EntireBoundaryIndicatorType	operator|| (const EntireBoundaryIndicatorType &one, const EmptyBoundaryIndicatorType &two)
	All || Empty = All.
static EntireBoundaryIndicatorType	operator|| (const EmptyBoundaryIndicatorType &one, const EntireBoundaryIndicatorType &two)
	All || Empty = All.
template<class Other >
static EmptyBoundaryIndicatorType	operator&& (const EmptyBoundaryIndicatorType &fixed, const BoundaryIndicatorInterface< Other > &other)
	Empty && Other = Empty.
template<class Other >
auto	operator&& (const BoundaryIndicatorInterface< Other > &other, const EmptyBoundaryIndicatorType &fixed) -> decltype(*fixed)
	Other && Empty = Empty.
template<class Other >
static auto	operator&& (const EntireBoundaryIndicatorType &fixed, const BoundaryIndicatorInterface< Other > &other) -> decltype(*asImp(other))
	All && Other = Other.
template<class Other >
static auto	operator&& (const BoundaryIndicatorInterface< Other > &other, const EntireBoundaryIndicatorType &fixed) -> decltype(*asImp(other))
	Other && All = Other.
static EmptyBoundaryIndicatorType	operator&& (const EmptyBoundaryIndicatorType &one, const EmptyBoundaryIndicatorType &two)
	Empty && Empty = Empty.
static EntireBoundaryIndicatorType	operator&& (const EntireBoundaryIndicatorType &one, const EntireBoundaryIndicatorType &two)
	All && All = All.
static EmptyBoundaryIndicatorType	operator&& (const EmptyBoundaryIndicatorType &one, const EntireBoundaryIndicatorType &two)
	Empty && All = Empty.
static EmptyBoundaryIndicatorType	operator&& (const EntireBoundaryIndicatorType &one, const EmptyBoundaryIndicatorType &two)
	All && Empty = Empty.
template<class LeftModelType , class RightModelType >
BinaryModelExpression< PlusOperation, LeftModelType, RightModelType >	operator+ (const ModelInterface< LeftModelType > &f_, const ModelInterface< RightModelType > &g_)
	Add two models.
template<class LeftModelType , class RightModelType >
BinaryModelExpression< MinusOperation, LeftModelType, RightModelType >	operator- (const ModelInterface< LeftModelType > &f_, const ModelInterface< RightModelType > &g_)
	Subtract two models.
template<class ModelType >
BinaryModelExpression< SMultiplyOperation, typename ModelType::RangeFieldType, ModelType >	operator* (const typename ModelType::RangeFieldType &s_, const ModelInterface< ModelType > &f_)
	Multiplication with scalars from the left.
template<class ModelType >
auto	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 >	operator* (const ParameterInterface< Parameter > &s_, const ModelInterface< ModelType > &f_)
	Multiplication with something satisfying ParameterInterface from the left.
template<class Parameter , class ModelType >
auto	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 >	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 >	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 >	operator- (const ModelInterface< Model > &m_)
	Unary minus.
template<class Model >
class UnaryModelExpression< IdentityOperation, Model >	operator* (const ModelInterface< Model > &m_)
	Identity. More...
template<class Model >
auto	operator+ (const ModelInterface< Model > &m_) -> decltype(*m_)
	Unary plus, acts like operator*(const ModelInterface<Model>&).
template<class Model , class DiscreteFunctionSpace , class Traits >
auto	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	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	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	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...
template<class Expression >
Expression	operator* (const ModelExpression< Expression > &m_)
	Avoid double identity wrapping.
template<class Model >
static auto	operator* (const typename Model::RangeFieldType &s_, const BinaryModelExpression< SMultiplyOperation, typename Model::RangeFieldType, Model > &m_) -> decltype((s_ *m_.scalar()) *m_.model())
	Fold s * (s * m) into (s*s) * m.
template<class Parameter , class Model >
static auto	operator* (const ParameterInterface< Parameter > &p_, const ModelInterface< BinaryModelExpression< SMultiplyOperation, typename Model::RangeFieldType, Model > > &m_) -> decltype(asImp(m_).scalar() *(asImp(p_) *asImp(m_).model()))
	Move sclars left-most.
template<class Field , class Parameter , class Model >
static auto	operator* (const BinaryParameterExpression< SMultiplyOperation, Field, Parameter > &p_, const ModelInterface< Model > &m_) -> decltype(p_.left() *(p_.right() *asImp(m_)))
	Move scalars out of BinaryParameterExpression.
template<class Function , class Field , class Model >
static auto	operator* (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_, const BinaryModelExpression< SMultiplyOperation, Field, Model > &m_) -> decltype(m_.scalar() *(asImp(f_) *m_.model()))
	Move sclars left-most.
template<class Field , class Function , class Model >
static auto	operator* (const BinaryGridFunctionExpression< SMultiplyOperation, Field, Function > &f_, const ModelInterface< Model > &m_) -> decltype(f_.scalar() *(f_.function() *asImp(m_)))
	Move scalars out of BinaryGridFunctionExpression.
template<class Model >
auto	operator- (const UnaryModelExpression< MinusOperation, Model > &m_) -> decltype(*m_.containedExpression())
	-(-Model) = Model More...
template<class Model , class DiscreteFunctionSpace , class GridFunction , template< class > class QuadratureTraits>
auto	operator- (const ModelInterface< Model > &m_, const L2InnerProductFunctional< DiscreteFunctionSpace, GridFunction, QuadratureTraits > &phi_) -> decltype(m_ - phi_.function())
	Avoid adding ordinary L2-functionals as functional.
template<class Model >
auto	operator+ (const ModelInterface< Model > &m, const ZeroModel< typename Model::FunctionSpaceType, typename Model::GridPartType > &z) -> decltype(*asImp(m))
	Model + Zero = Model.
template<class Model >
auto	operator+ (const ZeroModel< typename Model::FunctionSpaceType, typename Model::GridPartType > &z, const ModelInterface< Model > &m) -> decltype(*asImp(m))
	Zero + Model = Model.
template<class FunctionSpace , class GridPart >
auto	operator+ (const ZeroModel< FunctionSpace, GridPart > &z1, const ZeroModel< FunctionSpace, GridPart > &z2) -> decltype(*z1)
	Zero + Zero = Zero.
template<class Model >
auto	operator- (const ModelInterface< Model > &m, const ZeroModel< typename Model::FunctionSpaceType, typename Model::GridPartType > &z) -> decltype(*asImp(m))
	Model - Zero = Model.
template<class Model >
auto	operator- (const ZeroModel< typename Model::FunctionSpaceType, typename Model::GridPartType > &z, const ModelInterface< Model > &m) -> decltype(-m)
	Zero - Model = -Model.
template<class FunctionSpace , class GridPart >
auto	operator- (const ZeroModel< FunctionSpace, GridPart > &z1, const ZeroModel< FunctionSpace, GridPart > &z2) -> decltype(*z1)
	Zero - Zero = Zero.
template<class FunctionSpace , class GridPart >
auto	operator* (const typename FunctionSpace::RangeFieldType &s_, const ZeroModel< FunctionSpace, GridPart > &z) -> decltype(*z)
	s * Zero = Zero
template<class FunctionSpace , class GridPart >
auto	operator* (const ZeroModel< FunctionSpace, GridPart > &z, const typename FunctionSpace::RangeFieldType &s) -> decltype(*z)
	Zero * s = Zero.
template<class Parameter , class FunctionSpace , class GridPart >
auto	operator* (const ParameterInterface< Parameter > &s, const ZeroModel< FunctionSpace, GridPart > &z) -> decltype(*z)
	Parameter * Zero = Zero.
template<class Parameter , class FunctionSpace , class GridPart >
auto	operator* (const ZeroModel< FunctionSpace, GridPart > &z, const ParameterInterface< Parameter > &s) -> decltype(*z)
	Zero * Parameter = Zero.
template<class Function , class ScalarSpace , class FunctionSpace , class GridPart >
auto	operator* (const Fem::Function< ScalarSpace, Function > &f, const ZeroModel< FunctionSpace, GridPart > &z) -> decltype(*z)
	Function * Zero = Zero.
template<class Function , class ScalarSpace , class FunctionSpace , class GridPart >
auto	operator* (const ZeroModel< FunctionSpace, GridPart > &z, const Fem::Function< ScalarSpace, Function > &f) -> decltype(*z)
	Zero * Function = Zero.
template<class Model >
void	printConstituents (const Model &model, std::ostream &os=std::cout)
	Examine the given model and print to the given stream was has been found. More...
template<class GridFunction >
BulkForcesFunctionModel< GridFunction >	bulkForcesModel (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &f, const std::string &name="")
	Generate a BulkForcesFunctionModel for the "right hand side". More...
template<class Object >
static DeformationTensorOperatorParts< typename Object::FunctionSpaceType >	deformationTensorOperatorParts (const Object &object, const std::string &name="")
	Generate a deformation tensor model fitting the specified object. More...
template<class Object >
static OperatorPartsAdapterModel< DeformationTensorOperatorParts< typename Object::FunctionSpaceType >, typename Object::GridPartType >	deformationTensorModel (const Object &object, const std::string &name="")
	Generate a deformation tensor model fitting the specified object. More...
template<class GridFunction , class Indicator = EntireBoundaryIndicatorType>
DirichletBoundaryModel< GridFunction, Indicator >	dirichletBoundaryModel (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &values, const BoundaryIndicatorInterface< Indicator > &where=Indicator())
	Generate a DirichletBoundaryModel from given grid-function and boundary indicator. More...
template<class Object , class Indicator = EntireBoundaryIndicatorType>
DirichletBoundaryModel< ZeroGridFunction< typename Object::FunctionSpaceType, typename Object::GridPartType >, Indicator >	dirichletZeroModel (const Object &object, const BoundaryIndicatorInterface< Indicator > &where=Indicator())
	Generate homogeneous Dirichlet boundary conditions fitting the specified object. More...
template<class GridFunction >
static OperatorPartsAdapterModel< DivergenceOperatorParts< GridFunction >, typename GridFunction::GridPartType >	divergenceModel (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &f, const std::string &name="")
	Generate a Laplacian-model fitting the specified object. More...
template<class Object >
static FluidSelfTransportOperatorParts< typename Object::FunctionSpaceType >	fluidSelfTransportOperatorParts (const Object &object, const std::string &name="")
	Generate a Navier-Stokes non-linearity fitting the given object. More...
template<class Object >
static OperatorPartsAdapterModel< FluidSelfTransportOperatorParts< typename Object::FunctionSpaceType >, typename Object::GridPartType >	fluidSelfTransportModel (const Object &object, const std::string &name="")
	Generate a Navier-Stokes non-linearity fitting the given object. More...
template<class GridFunction >
static GradientOperatorParts< GridFunction >	gradientOperatorParts (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &f, const std::string &name="")
	Generate a Gradient-model fitting the specified object. More...
template<class Object >
static IncompressibleSelfTransportOperatorParts< typename Object::FunctionSpaceType >	incompressibleSelfTransportOpertorParts (const Object &object, const std::string &name="")
	Generate a Navier-Stokes non-linearity fitting the given object. More...
template<class Object >
static OperatorPartsAdapterModel< IncompressibleSelfTransportOperatorParts< typename Object::FunctionSpaceType >, typename Object::GridPartType >	incompressibleSelfTransportModel (const Object &object, const std::string &name="")
	Generate a Navier-Stokes non-linearity fitting the given object. More...
template<class Object , class Velocity >
static IncompressibleTransportOperatorParts< typename Object::FunctionSpaceType, Velocity >	incompressibleTransportOperatorParts (const Object &object, const Fem::Function< typename Velocity::FunctionSpaceType, Velocity > &velocity, const std::string &name="")
	Generate an advection-model object. More...
template<class Object , class Velocity >
static OperatorPartsAdapterModel< IncompressibleTransportOperatorParts< typename Object::FunctionSpaceType, Velocity >, typename Object::GridPartType >	incompressibleTransportModel (const Object &object, const Fem::Function< typename Velocity::FunctionSpaceType, Velocity > &velocity, const std::string &name="")
	Generate an advection-model object. More...
template<class Object >
static LaplacianOperatorParts< typename Object::FunctionSpaceType >	laplacianOperatorParts (const Object &object, const std::string &name="")
	Generate OperatorParts for a (weak, of course) Laplacian. More...
template<class Object >
static OperatorPartsAdapterModel< LaplacianOperatorParts< typename Object::FunctionSpaceType >, typename Object::GridPartType >	laplacianModel (const Object &object, const std::string &name="")
	Generate a Laplacian-model fitting the specified object. More...
template<class Object >
static MassOperatorParts< typename Object::FunctionSpaceType >	massOperatorParts (const Object &object, const std::string &name="")
	Generate OperatorParts for a (weak, of course) Mass. More...
template<class Object >
static OperatorPartsAdapterModel< MassOperatorParts< typename Object::FunctionSpaceType >, typename Object::GridPartType >	massModel (const Object &object, const std::string &name="")
	Generate a mass model fitting the specified object. More...
template<class Object , class Parameter = TrivialParameter<typename Object::FunctionSpaceType::RangeType>>
static MeanCurvatureOperatorParts< typename Object::FunctionSpaceType, Parameter >	meanCurvatureOperatorParts (const Parameter &regularization, const Object &object, const std::string &name="")
	Generate a MeanCurvature-model fitting the specified object. More...
template<class Object , class Parameter = TrivialParameter<typename Object::FunctionSpaceType::RangeType>>
static OperatorPartsAdapterModel< MeanCurvatureOperatorParts< typename Object::FunctionSpaceType, Parameter >, typename Object::GridPartType >	meanCurvatureModel (const Parameter &regularization, const Object &object, const std::string &name="")
	Generate a mean-curvature-model fitting the specified object. More...
template<class GridFunction , class Indicator = EntireBoundaryIndicatorType>
NeumannBoundaryModel< GridFunction, Indicator >	neumannBoundaryModel (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &values, const BoundaryIndicatorInterface< Indicator > &where=Indicator())
	Generate a NeumannBoundaryModel from given grid-function and boundary indicator. More...
template<class Object , class Indicator = EntireBoundaryIndicatorType>
NeumannBoundaryModel< ZeroGridFunction< typename Object::FunctionSpaceType, typename Object::GridPartType >, Indicator >	neumannZeroModel (const Object &object, const BoundaryIndicatorInterface< Indicator > &where=Indicator())
	Generate homogeneous Neumann boundary conditions fitting the specified object. More...
template<class Object >
static P_LaplacianOperatorParts< typename Object::FunctionSpaceType >	p_LaplacianOperatorParts (const typename Object::FunctionSpaceType::RangeFieldType &p, const Object &object, const std::string &name="")
	Generate OperatorParts for a (weak, of course) p-Laplacian. More...
template<class Object >
static OperatorPartsAdapterModel< P_LaplacianOperatorParts< typename Object::FunctionSpaceType >, typename Object::GridPartType >	p_LaplacianModel (const typename Object::FunctionSpaceType::RangeFieldType &p, const Object &object, const std::string &name="")
	Generate a P-laplacian model fitting the specified object. More...
template<class Object >
static P_MassOperatorParts< typename Object::FunctionSpaceType >	p_MassOperatorParts (const typename Object::FunctionSpaceType::RangeFieldType &p, const Object &object, const std::string &name="")
	Generate OperatorParts for a (weak, of course) Mass. More...
template<class Object >
static OperatorPartsAdapterModel< P_MassOperatorParts< typename Object::FunctionSpaceType >, typename Object::GridPartType >	p_MassModel (const typename Object::FunctionSpaceType::RangeFieldType &p, const Object &object, const std::string &name="")
	Generate a P-power mass-model fitting the specified object. More...
template<class Object , class Indicator = EntireBoundaryIndicatorType>
static RobinBoundaryOperatorParts< typename Object::FunctionSpaceType, Indicator >	robinOperatorParts (const Object &object, const BoundaryIndicatorInterface< Indicator > &where=Indicator(), const std::string &name="")
	Generate OperatorParts for (homogeneous) Robin boundary conditions. More...
template<class Object , class Indicator = EntireBoundaryIndicatorType>
OperatorPartsAdapterModel< RobinBoundaryOperatorParts< typename Object::FunctionSpaceType, Indicator >, typename Object::GridPartType >	robinZeroModel (const Object &object, const BoundaryIndicatorInterface< Indicator > &where=Indicator())
	Generate homogeneous Robin boundary conditions fitting the specified object. More...
template<class GridFunction , class Indicator = EntireBoundaryIndicatorType>
auto	robinBoundaryModel (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &values, const BoundaryIndicatorInterface< Indicator > &where=Indicator()) -> decltype(robinZeroModel(asImp(values), where *neumannBoundaryModel(asImp(values), where).neumannIndicator())+neumannBoundaryModel(asImp(values), where))
	Generate a RobinBoundaryModel from given grid-function and boundary indicator. More...
template<class Object , class Velocity >
static TransportOperatorParts< typename Object::FunctionSpaceType, Velocity >	transportOperatorParts (const Object &object, const Fem::Function< typename Velocity::FunctionSpaceType, Velocity > &velocity, const std::string &name="")
	Generate an advection-model object. More...
template<class Object , class Velocity >
static OperatorPartsAdapterModel< TransportOperatorParts< typename Object::FunctionSpaceType, Velocity >, typename Velocity::GridPartType >	transportModel (const Object &object, const Fem::Function< typename Velocity::FunctionSpaceType, Velocity > &velocity, const std::string &name="")
	Generate an advection-model object. More...
template<class GridFunction >
static OperatorPartsAdapterModel< WeakDivergenceOperatorParts< GridFunction >, typename GridFunction::GridPartType >	weakDivergenceModel (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &f, const std::string &name="")
	Generate a weak divergence model fitting the specified object. More...
template<class LeftOperand , class RightOperand >
BinaryOperatorPartsExpression< PlusOperation, LeftOperand, RightOperand >	operator+ (const OperatorPartsInterface< LeftOperand > &f_, const OperatorPartsInterface< RightOperand > &g_)
	Add two operands.
template<class LeftOperand , class RightOperand >
BinaryOperatorPartsExpression< MinusOperation, LeftOperand, RightOperand >	operator- (const OperatorPartsInterface< LeftOperand > &f_, const OperatorPartsInterface< RightOperand > &g_)
	Subtract two operands.
template<class OperandType >
BinaryOperatorPartsExpression< SMultiplyOperation, typename OperandType::RangeFieldType, OperandType >	operator* (const typename OperandType::RangeFieldType &s_, const OperatorPartsInterface< OperandType > &f_)
	Multiplication with scalars from the left.
template<class OperandType >
auto	operator* (const OperatorPartsInterface< OperandType > &op_, const typename OperandType::RangeFieldType &s_) -> decltype(s_ *asImp(op_))
	Multiplication with scalars from the right.
template<class Parameter , class OperandType >
BinaryOperatorPartsExpression< SMultiplyOperation, Parameter, OperandType >	operator* (const ParameterInterface< Parameter > &s_, const OperatorPartsInterface< OperandType > &f_)
	Multiplication with something satisfying ParameterInterface from the left.
template<class Parameter , class OperandType >
auto	operator* (const OperatorPartsInterface< OperandType > &op_, const ParameterInterface< Parameter > &s_) -> decltype(asImp(s_) *asImp(op_))
	Multiplication with something satisfying ParameterInterface from the right.
template<class FactorFunction , class OperandType >
BinaryOperatorPartsExpression< MultiplyOperation, FactorFunction, OperandType >	operator* (const Fem::Function< typename FactorFunction::FunctionSpaceType::ScalarFunctionSpaceType, FactorFunction > &f_, const OperatorPartsInterface< OperandType > &op_)
	Left multiplication by a function.
template<class FactorFunction , class OperandType >
BinaryOperatorPartsExpression< MultiplyOperation, FactorFunction, OperandType >	operator* (const OperatorPartsInterface< OperandType > &op_, const Fem::Function< typename FactorFunction::FunctionSpaceType::ScalarFunctionSpaceType, FactorFunction > &f_)
	Right multiplication by a function.
template<class Operand >
class UnaryOperatorPartsExpression< MinusOperation, Operand >	operator- (const OperatorPartsInterface< Operand > &op_)
	Unary minus.
template<class Operand >
class UnaryOperatorPartsExpression< IdentityOperation, Operand >	operator* (const OperatorPartsInterface< Operand > &op_)
	Identity. More...
template<class Operand >
auto	operator+ (const OperatorPartsInterface< Operand > &op_) -> decltype(*op_)
	Unary plus, acts like operator*(const OperatorPartsInterface<Operand>&).
template<class Expression >
Expression	operator* (const OperatorPartsExpression< Expression > &op_)
	Avoid double identity wrapping.
template<class Operand >
static auto	operator* (const typename Operand::RangeFieldType &s_, const BinaryOperatorPartsExpression< SMultiplyOperation, typename Operand::RangeFieldType, Operand > &op_) -> decltype((s_ *op_.scalar()) *op_.operand())
	Fold s * (s * op) into (s*s) * op.
template<class Parameter , class Operand >
static auto	operator* (const ParameterInterface< Parameter > &p_, const OperatorPartsInterface< BinaryOperatorPartsExpression< SMultiplyOperation, typename Operand::RangeFieldType, Operand > > &op_) -> decltype(asImp(op_).scalar() *(asImp(p_) *asImp(op_).operand()))
	Move sclars left-most.
template<class Field , class Parameter , class Operand >
static auto	operator* (const BinaryParameterExpression< SMultiplyOperation, Field, Parameter > &p_, const OperatorPartsInterface< Operand > &op_) -> decltype(p_.left() *(p_.right() *asImp(op_)))
	Move scalars out of BinaryParameterExpression.
template<class Function , class Field , class Operand >
static auto	operator* (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_, const BinaryOperatorPartsExpression< SMultiplyOperation, Field, Operand > &op_) -> decltype(op_.scalar() *(asImp(f_) *op_.operand()))
	Move sclars left-most.
template<class Field , class Function , class Operand >
static auto	operator* (const BinaryGridFunctionExpression< SMultiplyOperation, Field, Function > &f_, const OperatorPartsInterface< Operand > &op_) -> decltype(f_.scalar() *(f_.function() *asImp(op_)))
	Move scalars out of BinaryGridFunctionExpression.
template<class Operand >
auto	operator- (const UnaryOperatorPartsExpression< MinusOperation, Operand > &op_) -> decltype(*op_.containedExpression())
	-(-Operand) = Operand More...
template<class Operand >
auto	operator+ (const OperatorPartsInterface< Operand > &op, const ZeroOperatorParts< typename Operand::FunctionSpaceType > &z) -> decltype(*asImp(op))
	Operand + Zero = Operand.
template<class Operand >
auto	operator+ (const ZeroOperatorParts< typename Operand::FunctionSpaceType > &z, const OperatorPartsInterface< Operand > &op) -> decltype(*asImp(op))
	Zero + Operand = Operand.
template<class FunctionSpace >
auto	operator+ (const ZeroOperatorParts< FunctionSpace > &z1, const ZeroOperatorParts< FunctionSpace > &z2) -> decltype(*z1)
	Zero + Zero = Zero.
template<class Operand >
auto	operator- (const OperatorPartsInterface< Operand > &op, const ZeroOperatorParts< typename Operand::FunctionSpaceType > &z) -> decltype(*asImp(op))
	Operand - Zero = Operand.
template<class Operand >
auto	operator- (const ZeroOperatorParts< typename Operand::FunctionSpaceType > &z, const OperatorPartsInterface< Operand > &op) -> decltype(-op)
	Zero - Operand = -Operand.
template<class FunctionSpace >
auto	operator- (const ZeroOperatorParts< FunctionSpace > &z1, const ZeroOperatorParts< FunctionSpace > &z2) -> decltype(*z1)
	Zero - Zero = Zero.
template<class FunctionSpace >
auto	operator* (const typename FunctionSpace::RangeFieldType &s_, const ZeroOperatorParts< FunctionSpace > &z) -> decltype(*z)
	s * Zero = Zero
template<class FunctionSpace >
auto	operator* (const ZeroOperatorParts< FunctionSpace > &z, const typename FunctionSpace::RangeFieldType &s) -> decltype(*z)
	Zero * s = Zero.
template<class Parameter , class FunctionSpace >
auto	operator* (const ParameterInterface< Parameter > &s, const ZeroOperatorParts< FunctionSpace > &z) -> decltype(*z)
	Parameter * Zero = Zero.
template<class Parameter , class FunctionSpace >
auto	operator* (const ZeroOperatorParts< FunctionSpace > &z, const ParameterInterface< Parameter > &s) -> decltype(*z)
	Zero * Parameter = Zero.
template<class Function , class ScalarSpace , class FunctionSpace >
auto	operator* (const Fem::Function< ScalarSpace, Function > &f, const ZeroOperatorParts< FunctionSpace > &z) -> decltype(*z)
	Function * Zero = Zero.
template<class Function , class ScalarSpace , class FunctionSpace >
auto	operator* (const ZeroOperatorParts< FunctionSpace > &z, const Fem::Function< ScalarSpace, Function > &f) -> decltype(*z)
	Zero * Function = Zero.
template<class Object >
static ZeroModel< typename Object::FunctionSpaceType, typename Object::GridPartType >	zeroModel (const Object &object, const std::string &name="0")
	Generate a Zero-model fitting the specified object. More...
template<class DiscreteFunction , class GridFunction >
static double	divergenceFunctional (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &u, const Fem::DiscreteFunctionInterface< DiscreteFunction > &p)
	Application of divergence functional.
template<class DiscreteSpaceTraits , class GridFunction >
static DivergenceFunctional< typename DiscreteSpaceTraits::DiscreteFunctionSpaceType, GridFunction >	divergenceFunctional (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &u, const Fem::DiscreteFunctionSpaceInterface< DiscreteSpaceTraits > &space)
	Create a divergence functional, types deduced form arguments.
template<class DiscreteFunctionSpace , class Traits >
UnaryFunctionalExpression< IdentityOperation, typename Traits::GlobalFunctionalType >	operator* (const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &phi_)
	Identity expression, in order to wrap non-expressions into expressions.
template<class DiscreteFunctionSpace , class LeftTraits , class RightTraits >
BinaryFunctionalExpression< PlusOperation, typename LeftTraits::GlobalFunctionalType, typename RightTraits::GlobalFunctionalType >	operator+ (const DiscreteLinearFunctional< DiscreteFunctionSpace, LeftTraits > &left_, const DiscreteLinearFunctional< DiscreteFunctionSpace, RightTraits > &right_)
	Binary plus.
template<class DiscreteFunctionSpace , class LeftTraits , class RightTraits >
BinaryFunctionalExpression< MinusOperation, typename LeftTraits::GlobalFunctionalType, typename RightTraits::GlobalFunctionalType >	operator- (const DiscreteLinearFunctional< DiscreteFunctionSpace, LeftTraits > &left_, const DiscreteLinearFunctional< DiscreteFunctionSpace, RightTraits > &right_)
	Binary minus.
template<class DiscreteFunctionSpace , class LeftTraits , class Functional >
auto	operator- (const DiscreteLinearFunctional< DiscreteFunctionSpace, LeftTraits > &left_, const UnaryFunctionalExpression< MinusOperation, Functional > &right_) -> decltype(asImp(left_)+right_.containedExpression())
	Reduce a - (-b) to a + b.
template<class DiscreteFunctionSpace , class Functional , class RightTraits >
auto	operator+ (const UnaryFunctionalExpression< MinusOperation, Functional > &left_, const DiscreteLinearFunctional< DiscreteFunctionSpace, RightTraits > &right_) -> decltype(asImp(right_) - left_.containedExpression())
	Reduce -a + b to b - a.
template<class DiscreteFunctionSpace , class LeftTraits , class Functional >
auto	operator+ (const DiscreteLinearFunctional< DiscreteFunctionSpace, LeftTraits > &left_, const UnaryFunctionalExpression< MinusOperation, Functional > &right_) -> decltype(asImp(left_) - right_.containedExpression())
	Reduce a + (-b) to a - b.
template<class Left , class Right >
auto	operator+ (const UnaryFunctionalExpression< MinusOperation, Left > &left_, const UnaryFunctionalExpression< MinusOperation, Right > &right_) -> decltype(-(left_.containedExpression()+right_.containedExpression()))
	Reduce -a + (-b) to -(b + a)
template<class DiscreteFunctionSpace , class Traits >
BinaryFunctionalExpression< SMultiplyOperation, const typename DiscreteFunctionSpace::RangeFieldType, typename Traits::GlobalFunctionalType >	operator* (const typename DiscreteFunctionSpace::RangeFieldType &left_, const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &right_)
	S-Multiplication from the left with scalars.
template<class DiscreteFunctionSpace , class Traits >
auto	operator* (const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &left_, const typename DiscreteFunctionSpace::RangeFieldType &right_) -> decltype(right_ *asImp(left_))
	S-Multiplication from the right with scalars.
template<class DiscreteFunctionSpace , class Traits >
auto	operator/ (const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &left_, const typename DiscreteFunctionSpace::RangeFieldType &right_) -> decltype(asImp(left_) *(1.0/right_))
	Division by scalars is S-Multiplication reciprocal scalar.
template<class Parameter , class DiscreteFunctionSpace , class Traits >
BinaryFunctionalExpression< SMultiplyOperation, Parameter, typename Traits::GlobalFunctionalType >	operator* (const ParameterInterface< Parameter > &left_, const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &right_)
	S-Multiplication from the left with parameters.
template<class DiscreteFunctionSpace , class Traits , class Parameter >
auto	operator* (const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &left_, const ParameterInterface< Parameter > &right_) -> decltype(asImp(right_) *asImp(left_))
	S-Multiplication from the right with parameters.
template<class Field , class Functional >
static auto	operator* (const Field &s, const BinaryFunctionalExpression< SMultiplyOperation, const Field, Functional > &psi) -> decltype((s *psi.leftExpression()) *psi.rightExpression())
	Fold s1 * (s2 * psi) into (s1 * s2) * psi.
template<class Parameter , class Field , class Functional >
static auto	operator* (const ParameterInterface< Parameter > &p_, const BinaryFunctionalExpression< SMultiplyOperation, const Field, Functional > &psi) -> decltype(psi.leftExpression() *(asImp(p_) *psi.rightExpression()))
	Move scalars left-most.
template<class Field , class Parameter , class DiscreteFunctionSpace , class Traits >
static auto	operator* (const BinaryParameterExpression< SMultiplyOperation, Field, Parameter > &p_, const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &psi_) -> decltype(p_.left() *(p_.right() *asImp(psi_)))
	Move scalars out of s-mult expression with parameters.
template<class Parameter , class DiscreteFunctionSpace , class ZeroTraits >
static auto	operator* (const BinaryParameterExpression< SMultiplyOperation, typename DiscreteFunctionSpace::RangeFieldType, Parameter > &p, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &phi_) -> decltype(*phi_)
	Avoid ambuigities with zero optimization.
template<class DiscreteFunctionSpace , class Traits >
Traits::GlobalFunctionalType	operator* (const DiscreteLinearFunctionalExpression< DiscreteFunctionSpace, Traits > &phi_)
	Avoid double identity wrapping.
template<class Functional >
auto	operator- (const UnaryFunctionalExpression< MinusOperation, Functional > &phi_) -> decltype(*phi_.containedExpression())
	-(-Phi) = Phi. More...
template<class DiscreteFunctionSpace , class Traits >
auto	operator- (const ZeroFunctionalExpression< DiscreteFunctionSpace, Traits > &phi_) -> decltype(*phi_)
	-ZeroFunctional == ZeroFunctional
template<class DiscreteFunctionSpace , class Traits , class ZeroTraits >
auto	operator+ (const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &phi_, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z_) -> decltype(*asImp(phi_))
	DiscreteLinearFunctional + ZeroFunctional = DiscreteLinearFunctional.
template<class DiscreteFunctionSpace , class Traits , class ZeroTraits >
auto	operator+ (const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z_, const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &phi_) -> decltype(*asImp(phi_))
	ZeroFunctional + DiscreteLinearFunctional = DiscreteLinearFunctional.
template<class DiscreteFunctionSpace , class ZeroTraits1 , class ZeroTraits2 >
ZeroFunctional< DiscreteFunctionSpace >	operator+ (const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits1 > &left_, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits2 > &right_)
	Finally Zero + Zero = Zero.
template<class DiscreteFunctionSpace , class Traits , class ZeroTraits >
auto	operator- (const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &phi_, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z_) -> decltype(*asImp(phi_))
	DiscreteLinearFunctional - ZeroFunctional = DiscreteLinearFunctional.
template<class DiscreteFunctionSpace , class Traits , class ZeroTraits >
auto	operator- (const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z_, const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &phi_) -> decltype(-asImp(phi_))
	ZeroFunctional - DiscreteLinearFunctional = -DiscreteLinearFunctional.
template<class DiscreteFunctionSpace , class ZeroTraits1 , class ZeroTraits2 >
ZeroFunctional< DiscreteFunctionSpace >	operator- (const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits1 > &left_, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits2 > &right_)
	Finally Zero - Zero = Zero.
template<class DiscreteFunctionSpace , class ZeroTraits >
auto	operator* (const typename DiscreteFunctionSpace::RangeFieldType &s, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z) -> decltype(*z)
	s * ZeroFunctional = ZeroFunctional, but we have to wrap it (really?)
template<class DiscreteFunctionSpace , class ZeroTraits >
auto	operator* (const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z, const typename DiscreteFunctionSpace::RangeFieldType &s) -> decltype(*z)
	ZeroFunctional * s = s * ZeroFunctional.
template<class Parameter , class DiscreteFunctionSpace , class ZeroTraits >
auto	operator* (const ParameterInterface< Parameter > &p, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z) -> decltype(*z)
	ParameterInterface * ZeroFunctional = ZeroFunctional, but wrap zero.
template<class Parameter , class DiscreteFunctionSpace , class ZeroTraits >
auto	operator* (const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z, const ParameterInterface< Parameter > &p) -> decltype(*z)
	ZeroFunctional * ParameterInterface = ZeroFunctional.
template<class DiscreteSpaceTraits , class GridFunction >
static L2InnerProductFunctional< typename DiscreteSpaceTraits::DiscreteFunctionSpaceType, GridFunction >	l2InnerProductFunctional (const Fem::Function< typename GridFunction::FunctionSpaceType, GridFunction > &u, const Fem::DiscreteFunctionSpaceInterface< DiscreteSpaceTraits > &space)
	Create an L2 functional, types deduced form arguments.
template<class FunctionSpace , class GridFunction , class DiscreteFunction >
static void	L2Projection (const Fem::Function< FunctionSpace, GridFunction > &fct, DiscreteFunction &result)
	Perform an L2-projection for any GridFunction.
template<class Traits , class DiscreteFunction >
static void	L2Projection (const DiscreteLinearFunctional< typename DiscreteFunction::DiscreteFunctionSpaceType, Traits > &phi, DiscreteFunction &result)
	Perform an L2-projection for any DiscreteLinearFunctional.
template<class DF >
static Fem::RestrictProlongDefault< DF >	makeRestrictProlongDefault (Fem::Function< typename DF::FunctionSpaceType, DF > &df_)
	Endpoint for the makeRestrictProlongDefault recursion. More...
template<class DF1 , class DF2 , class... Rest>
static RestrictProlongDefaultTraits< DF1, DF2, Rest... >::Type	makeRestrictProlongDefault (DF1 &df1, DF2 &df2, Rest &... rest)
	Take arbitrary many discrete functions of potentially different type and generate a suitable RestrictProlong implementation for use with the AdaptationManager.
template<class... Rest>
static RestrictProlongDefaultTraits< Rest... >::Type	makeRestrictProlongDefault (const tuple< Rest &... > &arg)
	Conveniently form a compound RestrictProlong-implementation which conforms to RestrictProlongInterface. More...

Detailed Description

A namespace encapsulating everything defined in our dune-acfem project.

dune-acfem extracts and refines the fem-poisson and fem-heat examples from the dune-fem-school-generator and factors out general functionality. It serves as backend for single-purpose standalone dune-modules. Examples are the ellipt-dot-c and heat-dot-c modules which more or less do the same thing as the ALBERTA examples with the same name.

The major difference to the school code is the idea to factor out commonly needed functionality into a Dune::Fem addon-library instead of copying files around.