Dune::ACFem Namespace Reference

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

Namespaces
namespace	ModelIntrospection
	Deduce methods and call-signatures from an implemented model.
namespace	MPL
	Form a sub-sequence with the values at the positions NOT given in Indices.

Classes
struct	AbsOperation
	abs More...
struct	AcceptAllFunctor
	Functor for TransformSequence: unconditionally accept. More...
struct	AcceptEqualFunctor
	Functor for TransformSequence: accept if result is either equal or different from original value. More...
struct	AcceptInputInRangeFunctor
	Accept if input-value is in range of given bounds. More...
struct	AcceptInputValueFunctor
	Accept if input-value is either equal or unequal to given value. More...
struct	AcceptModuloFunctor
	Accept if input-value MOD P = R. More...
struct	AcoshOperation
	Inverse hyperbolic cosine. More...
struct	AcosOperation
	Taking the arc cosine of an object. More...
class	AdaptiveFemScheme
	Abstract space adaptative FEM scheme. More...
struct	AddBitFunctor
	Add given bit to all masks. More...
struct	AddBitShiftLeftFunctor
	Add a set bit at left-shifted position. More...
struct	AddBitShiftRightFunctor
	Add a set bit at right-shifted position. More...
struct	AndPredicate
	Logical "and" for two perdicates. More...
struct	AsinhOperation
	Inverse hyperbolic sine. More...
struct	AsinOperation
	Taking the arc sine of an object. More...
struct	AssumeOperation
	Assume operations attach a property to the wrapped expression. More...
struct	Atan2Operation
	Taking the arctan of an object. More...
struct	AtanhOperation
	Inverse hyperbolic tangens. More...
struct	AtanOperation
	Taking the arctan of an object. More...
class	BasicFemScheme
	Abstract non-adaptive basic FEM scheme. More...
class	BulkBlockConstraints
	A default implementation for bulk block constraints. More...
struct	CanPromoteTupleTypes
struct	CanPromoteTupleTypes< T, std::enable_if_t< sizeof(TupleScalarPromotionType< T >) >=0 >
	TrueType if the type of the tuple T can be promoted to another type. More...
struct	Case
	Case-structure for multi-conditional switch. More...
struct	CeilOperation
	ceil More...
struct	ConstantExpression
	A constant. More...
class	ContainerTuple
	Create a tuple of values from a tuple of containers. More...
struct	copy_cv_reference
	Export a type copy_cv_reference::type which has the same qualifiers as T and decays to the decay of U. More...
struct	CoshOperation
	Hyperbolic cosine. More...
struct	CosOperation
	Taking the cosine of an object. More...
class	DataOutputParameters
	Potentially overwrite some parameters. More...
struct	DefaultQuadratureTraits
	Helper traits-class, defining likely quadrature types. More...
class	DirichletConstraints< DiscreteFunctionSpace, BoundaryValues, Indicator, std::enable_if_t<(HasEmptySupport< BoundaryValues >::value||IndicatorTraits< Indicator >::emptySupport)> >
	Spezialization of Dirichlet constraints for emptyboundaryindicator. More...
class	DirichletConstraints< DiscreteFunctionSpace, BoundaryValues, Indicator, std::enable_if_t<(IsWrappableByConstLocalFunction< BoundaryValues >::value &&IsBoundaryIndicator< Indicator >::value &&!IndicatorTraits< Indicator >::emptySupport)> >
	Implementation of Dirichlet constraints given a boundary}; supported function. More...
class	DirichletConstraints< DiscreteFunctionSpace, Model, void, std::enable_if_t< true &&IsPDEModel< Model >::value &&!HasEmptySupport< Model >::value > >
	Implementation of Dirichlet constraints given a PDE-model. More...
class	DofMapperTupleDataHandle
	Potential all - all communication for mapped data. More...
struct	DofMapperTupleDataHandleTraits
	Traits for just something indexable. More...
struct	EinsumOperation
	Einstein summation, i.e. More...
class	EllipticEstimator
	An standard residual estimator for elliptic problems. More...
class	EllipticFemScheme
	Adaptive fem-scheme for "elliptic" problems. More...
class	EllipticOperator
	A class defining an elliptic operator. More...
class	EmptyBlockConstraints
	A class modelling do-nothing constraints. More...
struct	EqOperation
	== More...
struct	ErfOperation
	erf More...
struct	ExpOperation
	Exponentiation of an object. More...
struct	ExpressionTraits
	Default expression traits definition is a recursion in order to ease disambiguation. More...
struct	ExpressionTraits< Constant< I, V > >
	Explicit expression traits for integer constants. More...
struct	ExpressionTraits< FractionConstant< Int, N, D > >
	Override ExpressionTraits for FractionConstant. More...
struct	ExpressionTraits< Model, std::enable_if_t< IsPDEModel< Model >::value >, TraitsPriority::Secondary >
	Override default expression traits s.t. More...
struct	ExpressionTraits< T, std::enable_if_t< Expressions::IsClosure< T >::value >, BaseTraitsLevel >
	Use traits of enclosed type for closure expressions. More...
struct	ExpressionTraits< T, std::enable_if_t<!IsDecay< T >::value >, DecayTraitsLevel >
	Forward to the traits class for the decay type. More...
struct	ExpressionTraits< T, std::enable_if_t<!IsExpression< T >::value||IsSelfExpression< T >::value >, BaseTraitsLevel >
	Default expression traits for terminal expressions or non-expressions just look at the tag-classes. More...
struct	ExpressionTraits< T, std::enable_if_t<(IsExpression< T >::value &&!IsSelfExpression< T >::value &&!Expressions::IsClosure< T >::value)>, BaseTraitsLevel >
	Default Expression-traits for any non-terminal expression use the induced traits of the operation while allowing overrides from attached tag-base-classes. More...
struct	ExpressionTraits< T, void, DefaultTraitsLevel >
	A traits class in order to collect properties of expressions. More...
struct	ExpressionTraits< Tensor::AutoDiffPlaceholder< Id, Signature, T, DT > >
struct	ExpressionTraits< TypedValue::NamedConstant< T, Name... > >
	Override ExpressionTraits for NamedConstant. 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	FieldPromotion
	Promote potentially different numeric field types to a "closure" type. More...
struct	FieldTraits
	Helper class for specializing Dune::FieldTraits. More...
struct	FloorOperation
	floor More...
class	GeometryInformation
	Export some hard-to-get-at things for geometries. More...
struct	GeOperation
	>= More...
struct	Get
	Gets the type of the n-th element of a tuple-like or the std::integral_constant corresponding to the n-th element of a sequence. More...
struct	GtOperation
	‍ More...
struct	HasPropertyFunctor
struct	HasResize
struct	HasUnaryMinus
struct	HasUnaryMinus< T, std::enable_if_t<(sizeof(decltype(-std::declval< T >())) >=0)> >
	TrueType if a T allows for the unary minus operator. More...
struct	IdentityFunctor
	Identity functor. More...
struct	IdentityOperation
	Identity, i.e. just wrap the object. More...
struct	IndependentExpression
	An independent expression is an expression which does not depend on external state. More...
struct	IndeterminateOperation
	Indeterminate operation, wrap another object and attach an id. More...
struct	IndexFunctor
	Index functor. More...
class	IntersectionDataHandle
	General intersection - intersection communication which communicates for each intersection a potentially variable number of data-items. More...
struct	InverseMapSequenceFunctor
	Map a value to the index of the value in Values. More...
struct	IsAlwaysFalse
	Assume a predicate is a traits-class and would never evaluate to false unless it is equivalent to AlwaysFalse. More...
struct	IsAlwaysFalse< Predicate, std::enable_if_t<!Predicate<>::value > >
	Assume a predicate is a traits-class and would never evaluate to false unless it is equivalent to AlwaysFalse. More...
struct	IsAlwaysTrue
	Assume a predicate is a traits-class and would never evaluate to true unless it is equivalent to AlwaysTrue. More...
struct	IsAlwaysTrue< Predicate, std::enable_if_t< Predicate<>::value > >
	Assume a predicate is a traits-class and would never evaluate to true unless it is equivalent to AlwaysTrue. More...
struct	IsApplicableTo
	Is TrueType if an F can be invoked with an E. More...
struct	IsArray
struct	IsArray< std::array< T, N > >
	TrueType if T is a std::array. More...
struct	IsArray< T, std::enable_if_t<!IsDecay< T >::value > >
	Forward to decay if T is not a decay type. More...
struct	IsBoolConstant
struct	IsBoolConstant< BoolConstant< V > >
	TrueType for bool constant. More...
struct	IsBoolConstant< T & >
	Forward to decay traits class for non decay types. More...
struct	IsBoolConstant< T && >
	Forward to decay traits class for non decay types. More...
struct	IsDefined
struct	IsDefined< T, std::enable_if_t<(std::is_object< T >::value &&!std::is_pointer< T >::value &&(sizeof(T) >=0))> >
	TrueType if T is an object which is not a pointer. More...
struct	IsDistributiveOperation
	True for expressions which can be moved inside or outside of sums. More...
struct	IsDynamicOperation
	Should be overloaded to std::true_type for operations which introduce runtime variable data into the expression as part of the operation. More...
struct	IsEvenFunctor
	Transform to bool sequence of even indices. More...
struct	IsIndexSequence
struct	IsIndexSequence< IndexSequence< Ints... > >
	TrueType for integer sequences with value_type std::size_t. More...
struct	IsIntegral
	TrueType if I is an integral type. More...
struct	IsIntegral< TypedValue::FractionConstant< I, N, 1 > >
	Some FractionConstants are integral. More...
struct	IsIntegralConstant
	FalseType by default. More...
struct	IsIntegralConstant< Constant< T, V > >
	TrueType for integral_constant. More...
struct	IsOddFunctor
	Transform to bool sequence of even indices. More...
struct	IsProductOperation
	Evaluate to std::true_type if the operation is product-like. More...
struct	IsQuadraturePoint
struct	IsQuadraturePoint< Fem::QuadraturePointWrapper< Quadrature > >
	Identify quadrature points. More...
struct	IsQuadraturePoint< T, std::enable_if_t<!IsDecay< T >{}> >
struct	IsScalar
	std::true_type if F is an "elementary" scalar. More...
struct	IsScalar< F, std::enable_if_t<(std::is_convertible< F *, typename FieldTraits< F >::field_type * >::value &&(std::numeric_limits< typename FieldTraits< F >::real_type >::is_iec559||std::numeric_limits< typename FieldTraits< F >::real_type >::is_integer))> >
	Standard floating point types and integral types are scalars, also FieldVectors of dimension 1 convertible to standard floating point types. More...
struct	IsScalar< TypedValue::FractionConstant< I, N, D > >
	FractionConstants are scalars. More...
struct	IsScalar< TypedValue::NamedConstant< T, Name... > >
	NamedConstants are scalars if the wrapped type is. More...
struct	IsSequence
struct	IsSequence< Sequence< T, Ints... > >
	Evaluate to TrueType of integer sequences. More...
struct	IsTupleLike
struct	IsTupleLike< T, std::enable_if_t<(std::tuple_size< std::decay_t< T > >::value >=0)> >
	Evaluate to true if T behaves more or less like a tuple. More...
struct	IsVolatileOperation< IndeterminateOperation< Id > >
	Indeterminates are also volatile by design. More...
struct	IsVolatileOperation< PlaceholderOperation< Placeholder > >
	Placeholder expressions are volatile by design, unless overridden by a RuntimEqualExpression tag. More...
struct	LeOperation
	<= More...
struct	LGammaOperation
	;gamma 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	LogicalAndOperation
	Logical And. More...
struct	LogicalNotOperation
	Logical Not. More...
struct	LogicalOrOperation
	Logical Or. More...
struct	LogOperation
	Taking the logarithm of an object. More...
struct	LtOperation
	< More...
struct	MakeType
struct	MapSequenceFunctor
	Map sequence values to values specified by other sequence, e.g. More...
struct	MapSequenceFunctor< Sequence< I > >
	Per convention just use the identiy for the empty value sequence. More...
struct	MaxOperation
	max More...
struct	MaybeLumpingQuadratureTraits
	Helper traits-class, defining likely quadrature types for mass-lumping. More...
struct	MinOperation
	min More...
struct	MinusEqOperation
	A -= B. More...
struct	MinusOneExpression
	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	MinusOperation
	Subtraction of two objects and unary minus. More...
struct	ModelBase
	A structure defining some basic default types and methods. More...
struct	MultiplyOffsetFunctor
	Multiply-offset functor. More...
struct	MutableExpression
	Something which may be change between different evaluations of an expression. 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	NegativeExpression
	An expression which is known to be negative. More...
struct	NeOperation
	!= 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	OperationTraits< EinsumOperation< Pos1, Pos2, Dims > >
	Einstein summation, i.e. More...
struct	OperationTraits< ReshapeOperation< Sig > >
	Reshape a tensor to another signature. More...
struct	OperationTraits< TensorProductOperation< Pos1, Pos2, Dims > >
	Component-wise product over given index-set. More...
struct	OperationTraits< TransposeOperation< Perm > >
	Permutation of index positions of tensors. More...
struct	OperatorTypeSelector
struct	OrPredicate
	Logical "or" for two perdicates. More...
struct	PairFunctor
	Generate a compound functor out of two functors. More...
class	ParabolicEulerEstimator
	Residual estimator for the heat equation. More...
class	ParabolicFemScheme
	Basic parabolic fem-scheme class. More...
struct	PieceWiseConstantExpression
	Something constant on a given entity. More...
struct	PlaceholderOperation
	Placeholder operation wraps another object and attaches an id to it. More...
struct	PlusEqOperation
	A += B. More...
struct	PlusOperation
	Addition of two objects. More...
class	PointWrapperQuadrature
	A wrapper class which allows to "simulate" a Dune::Fem::QuadraturePointWrapper. More...
struct	PositiveExpression
	An expression which is known to be positive. More...
struct	PowOperation
	Taking something to the power of something. More...
struct	PredicateProxy
	Wrap the given predicate class F into another one with spcial requirements. More...
struct	PredicateWrapper
	Wrap a predicate into a class which can be passed on as argument. More...
struct	ReciprocalOperation
	Inversion of a scalar object. More...
struct	RegularZeroExpression
	Non-singular, but somehow zero, whatever that means. More...
struct	remove_const
	Export a type trough remove_const::type as follows: More...
struct	ReshapeOperation
	Signature of index positions of tensors. More...
struct	RestrictionOperation
	AutoDiff operation. More...
struct	RoundOperation
	round More...
struct	RuntimeEqualExpression
	A tag structure signalling that objects of this type can be considered to yield the same values at runtime, if encountered in the same expression. More...
struct	SameDecay
	TrueType if T1 and T2 have the same decay types, otherwise FalseType. More...
class	ScopedRedirect
	A class to redirect streams. More...
struct	SemiNegativeExpression
	Less equal 0 expression. More...
struct	SemiPositiveExpression
	Greater equal 0 expression. More...
struct	SinhOperation
	Hyperbolic sine. More...
struct	SinOperation
	Taking the sine of an object. More...
struct	SMultiplyEqOperation
	A *= s. More...
struct	SMultiplyOperation
	Multiplication by scalars from the left. More...
struct	SolverSelector
	Select one appropriate (linear) solver depending on whether the model is symmetric and/or semidefinite. More...
struct	SqrtOperation
	Taking the square root of an object. More...
struct	SquareOperation
	Taking the square of an object. More...
struct	SubExpressionOperation
	Kind of placeholder. More...
struct	Switch
	Recursion for a multi-conditional switch. More...
struct	Switch< Case< C, T > >
	Recursion end-point: if the last template parameter to SwitchType is a case then export T as SwitchCase<C,T>::Type if C is true. More...
struct	Switch< T >
	Recursion endpoint: If the terminating template parameter to SwitchType is not a Case template, then export T as Switch<T>::Type. More...
struct	TanhOperation
	Hyperbolic tangens. More...
struct	TanOperation
	Taking the tangens of an object. More...
struct	TensorProductOperation
	Component-wise product over given index-set. More...
struct	TerminalExpression
	A terminal expression is an "expression end-point", i.e. More...
struct	TernaryOperation
	IfOperation. More...
struct	TGammaOperation
	tgamma More...
struct	TimeProviderTraits
	Type of time and time-step values. More...
class	TimeView
	Generate a view on the current time-step. More...
struct	TransformAtIndexFunctor
	Applies another functor only to the elements at the specified positions given by the Index parameter pack. More...
struct	TransposeOperation
	Permutation of index positions of tensors. More...
class	TrueErrorEstimator
	"estimator" which return the "true" error with respect to some given function in some standard norm. More...
struct	TupleFunctor
	Generate a compound functor out of a tuple of functors. More...
struct	TypedValueExpression
	A tag structure signalling that this expression carries its value in its type. More...
class	TypeString
	A class constructing the name of another type. More...
struct	UnaryFilterFunctor
	Filter-proxy for TransformSequence template alias. More...
struct	UnaryKeepAtFunctor
	Alternative: avoid bit-masks and use ContainsValue<> template. More...
struct	UnaryNotFunctor
	Negate a given unary functor. More...
struct	UniqueExpression
	A tag for use with assume() to generate a unique type which is assumed to be "runtime equal" by inheriting from RuntimeEqualExpression. More...
struct	VolatileExpression
	A volatile expression will not be replaced by its value except for RuntimeEqual optimizations. 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	ZeroExpressionTraits
	ExpressionTraits for any zero-expression. More...

Typedefs
template<std::size_t mask>
using	FindMostSignificantBit = IndexConstant< FindMostSignificantBitHelper< std::size_t, mask >::value >
	Template-algorithm which defines the index of the most significant bit as a std::index_constant.
template<std::size_t mask>
using	FindLeastSignificantBit = IndexConstant< FindLeastSignificantBitHelper< std::size_t, mask >::value >
	Template-algorithm which defines the index of the least significant bit as a std::index_constant.
template<std::size_t mask>
using	FindFirstZeroBit = IndexConstant< FindLeastSignificantBitHelper< std::size_t, ~mask >::value >
	Template-algorithm which defines the index of the first 0-bit as a std::index_constant.
template<class GridPart >
using	LumpingQuadratureTraits = MaybeLumpingQuadratureTraits< GridPart, true, true >
	Traits class with lumping quadratures in the bulk and on the skeleton. More...
template<class GridPart >
using	BulkLumpingQuadratureTraits = MaybeLumpingQuadratureTraits< GridPart, true, false >
	Traits class with lumping quadratures in the bulk but not on the skeleton.
template<class GridPart >
using	FaceLumpingQuadratureTraits = MaybeLumpingQuadratureTraits< GridPart, false, true >
	Traits class with lumping quadratures only on the skeleton.
template<class GridPart >
using	QuadratureTraits = DefaultQuadratureTraits< GridPart >
	Traits class with ordinary quadratures in the bulk and on the skeleton.
template<class Quadrature >
using	QuadraturePoint = Fem::QuadraturePointWrapper< Quadrature >
	Shortcut.
template<class T , T V>
using	Constant = integral_constant< T, V >
	Short-cut for any integral constant.
template<std::size_t V>
using	IndexConstant = Constant< std::size_t, V >
	Short-cut for integral constant of type std::size_t.
template<bool V>
using	BoolConstant = Constant< bool, V >
	Short-cut for integral constant of type bool.
template<std::ptrdiff_t V>
using	IntConstant = Constant< std::ptrdiff_t, V >
	Short-for integral constant of type std::p0trdiff_t.
template<class T , T... V>
using	Sequence = std::integer_sequence< T, V... >
	Sequence of any type of integer values.
template<bool... Decisions>
using	BoolSequence = Sequence< bool, Decisions... >
	Sequence of boolean values.
template<std::size_t... V>
using	IndexSequence = Sequence< std::size_t, V... >
	Sequence of std::size_t values.
template<std::ptrdiff_t... V>
using	IntSequence = Sequence< std::ptrdiff_t, V... >
	Sequence of std::ptrdiff_t values.
template<class Const >
using	Incr = Constant< typename Const::value_type, Const::value+1 >
	Increment an integral_constant.
template<class Const >
using	Decr = Constant< typename Const::value_type, Const::value - 1 >
	Decrement an integral_constant.
template<class T >
using	IsDecay = std::is_same< T, std::decay_t< T > >
	true if T is its own decay type.
template<class T1 , class T2 >
using	HasSameDecay = std::is_same< std::decay_t< T1 >, std::decay_t< T2 > >
	true if the decay types match.
template<class Base , class Derived >
using	IsBaseOfDecay = std::is_base_of< std::decay_t< Base >, std::decay_t< Derived > >
	TrueType if the decay type of Base is a base of the DecayType of Derived.
using	TrueType = BoolConstant< true >
	Alias for std::true_type.
using	FalseType = BoolConstant< false >
	Alias for std::false_type.
template<class T >
using	RefersConst = BoolConstant<(std::is_const< T >::value||std::is_const< std::remove_reference_t< T > >::value)>
	TrueType if const or a reference to a const.
template<class... T>
using	FirstType = typename MakeType< T... >::Type
	Generate the first type of the template argument list.
template<class... Other>
using	VoidType = typename MakeType< void, Other... >::Type
	Generate void regardless of the template argument list.
template<class... Other>
using	AlwaysFalse = typename MakeType< FalseType, Other... >::Type
	Generate FalseType regardless of the template argument list.
template<class... Other>
using	AlwaysTrue = typename MakeType< TrueType, Other... >::Type
	Generate TrueType regardless of the template argument list.
template<class CaseType >
using	CaseNot = Case<!CaseType::value, typename CaseType::Type >
	Generate the negation of the given Case, i.e. More...
template<class A , class B = A>
using	CaseVoid = Case< std::is_same< A, void >::value, B >
	If A is void then CaseVoid::value is true and CaseVoid::Type is B. More...
template<class A , class B = A>
using	CaseNotVoid = CaseNot< CaseVoid< A, B > >
	If A is not void then CaseNotVoid::value is true and CaseNotVoid::Type is B. More...
template<class A , class B , class C = A>
using	CaseSame = Case< std::is_same< A, B >::value, C >
	If A equals B export C as CaseSame::Type. More...
template<class A , class B , class C = A>
using	CaseNotSame = CaseNot< CaseSame< A, B, C > >
	Negation of CaseSame, if A is not B then export C as CaseNotSame::Type. More...
template<class A , class B , class C = A>
using	CaseBase = Case< std::is_base_of< A, B >::value, C >
	If A is a base of B then export C as CaseBase::Type. More...
template<class A , class B , class C = A>
using	CaseNotBase = CaseNot< CaseBase< A, B, C > >
	Negation of CaseBase, if A is not a base of B, then export C as CaseNotBase::Type. More...
template<class... Cases>
using	SwitchType = typename Switch< Cases... >::Type
	Multiple conditions. More...
template<bool C, class Yes , class No = void>
using	IfElseType = SwitchType< Case< C, Yes >, No >
	Type Yes if C is true, otherwise type No which default to void.
template<class... A>
using	OrType = SwitchType< CaseNotVoid< A >... >
	First non-void type in list.
template<class A , class B , class Default = void>
using	AndType = SwitchType< CaseSame< A, B >, Default >
	A if A and B have same type, otherwise Default.
template<class From , class To >
using	copy_cv_reference_t = typename copy_cv_reference< From, To >::type
	Export a type copy_cv_reference::type which has the same qualifiers as T and decays to the decay of U. More...
template<class T >
using	remove_const_t = typename remove_const< T >::type
	Export a type trough remove_const::type as follows: More...
template<class T >
using	RemoveRValueReferenceType = typename RemoveRValueReference< T >::Type
	If T is an rvalue reference then yield the dereferenced type. More...
template<class T , bool Exclusive = true>
using	IsFractionOperand = BoolConstant<(IsScalar< T >::value &&!(Exclusive &&IsFractionConstant< T >::value) &&!IsIntegralConstant< T >::value &&!IsExpression< T >::value)>
	Allow scalars to mate with FractionConstants, but do not interfere with std::integral_constant and expression types.
template<class T >
using	IsTypedValue = BoolConstant< ExpressionTraits< T >::isTypedValue >
	Compile-time true if T is a "typed value", e.g. a std::integral_constant.
template<class T >
using	IsTypedValueReference = BoolConstant< std::is_reference< T >::value &&IsTypedValue< T >::value >
	Compile-time true if T is a reference to a "typed value".
template<class T >
using	FloatingPointClosure = typename FloatingPointClosureHelper< T >::Type
	Template alias.
template<class T >
using	IsProductExpression = IsProductOperation< Expressions::Operation< T > >
	std::true_type for product like expressions. More...
template<class T >
using	IsRuntimeEqualExpression = Expressions::IsRuntimeEqual< T >
template<class T1 , class T2 >
using	AreRuntimeSameExpressions = Expressions::AreRuntimeEqual< T1, T2 >
	FalseType by default. More...
using	UnknownExpressionSign = ExpressionSign< false, false, false >
	Sign traits structure with names matching the expression tag structs.
template<class T >
using	BaseExpressionTraits = ExpressionTraits< T, void, BaseTraitsLevel >
	This is the default implementation if not overriden at higher level. More...
template<class Model , class GridFunction >
using	LoadModel = PDEModel::BinaryModelExpression< PDEModel::ApplyOperation< PDEModel::L2LoadFlavour >, Model, GridFunction >
	This will become a "load"-model which applies "Model" to "Function" and generates the necessary load-vectors s.t. More...
template<class Model , class GridFunction >
using	RitzLoadModel = PDEModel::BinaryModelExpression< PDEModel::ApplyOperation< PDEModel::RitzLoadFlavour >, Model, GridFunction >
	copydoc LoadModel
using	EmptyBoundaryIndicator = BoundaryIndicator::Constant< false >
	A boundary indicator applying to no part of the boundary.
using	EntireBoundaryIndicator = BoundaryIndicator::Constant< true >
	A boundary indicator applying to all parts of the boundary.
template<class T >
using	IsBoundaryIndicator = BoundaryIndicator::IsIndicator< T >
	Identify a boundary indicator.
template<class T >
using	IsProperBoundaryIndicator = BoundaryIndicator::IsProperOperand< T >
	Indentify a boundary indicator after type-normalization.
template<class Model >
using	IsPDEModel = ModelIntrospection::template IsModel< Model >
	std::true_type if Model is derived from ModelBase.
template<class Model >
using	ModelTraits = ModelIntrospection::Traits< Model >
	Traits class for models.
template<class Model , std::size_t tag>
using	ModelHasMethod = typename ModelTraits< Model >::template HasMethod< ModelIntrospection::CheckMethodTag< tag >::value >
	Check for method.
template<class Model , std::size_t tag>
using	ModelMethodExists = typename ModelTraits< Model >::template Exists< ModelIntrospection::CheckMethodTag< tag >::value >
	Check for either non-linear or linearized method.
template<class Model , std::size_t tag>
using	ModelMethodSignature = typename ModelTraits< Model >::template CallSignature< ModelIntrospection::CheckMethodTag< tag >::value >
	Call signature for given model and method.
template<class Model , std::size_t tag>
using	ModelMethodSignatureClosure = typename ModelTraits< Model >::template CallSignatureClosure< ModelIntrospection::CheckMethodTag< tag >::value >
	Compute the closure call-signature for the given model for a call to the method designated by tag, taking into account that non-linear methods are default implemented by the linearized methods.
using	ModelAdmissibleMethods = ModelIntrospection::AllMethodTags
	A sequence with the tags of all possible model-methods.
using	ModelMethodClosureSignatures = ModelIntrospection::MethodSignaturesClosureType
	A sequence with the closure signatures for all methods.
template<class Model , std::size_t tag, std::size_t signature = Get<tag, typename ModelTraits<Model>::MethodCallSignatures>::value>
using	ModelMethod = PDEModel::TaggedModelMethod< Model, tag, signature >
	Exports from namespace.
template<class Model , std::size_t tag>
using	ModelClosureMethod = PDEModel::TaggedModelMethod< Model, tag, ModelIntrospection::MethodSignatureClosure< tag >::value >
	Exports from namespace.
template<class F , class Model >
using	UnaryModelExpression = PDEModel::UnaryModelExpression< F, Model >
	Exports from namespace.
template<std::size_t N, class TupleLike >
using	TupleElement = std::tuple_element_t< N, std::decay_t< TupleLike > >
	Forward to std::tuple_element<N, std::decay_t<T> >
template<std::size_t Skip, std::size_t Cnt, class Seq >
using	GetPart = typename GetHeadPartHelper< Cnt, typename GetTailPartHelper< Skip, Seq >::Type >::Type
	Extract Cnt many consecutive elements from Seq starting at position N.
template<std::size_t Cnt, class Seq >
using	HeadPart = typename GetHeadPartHelper< Cnt, Seq >::Type
	Extract Cnt many consecutive elements from the front of Seq.
template<std::size_t Cnt, class Seq >
using	TailPart = typename GetTailPartHelper< Seq::size() -Cnt, Seq >::Type
	Extract Cnt many consecutive elements from the end of Seq.
template<class Seq , typename Seq::value_type V>
using	IndexIn = IndexConstant< IndexInHelper< 0, typename Seq::value_type, V, Seq >::value >
	Find the index of a given value in a sequence.
template<std::ptrdiff_t V, class Seq >
using	PushFront = decltype(pushFront< V >(Seq{}))
	Add value to start of integer-sequence.
template<std::ptrdiff_t V, class Seq >
using	PushBack = decltype(pushBack< V >(Seq{}))
	Add value to end of integer-sequence.
template<std::size_t V, std::size_t N, class Input >
using	Put = typename PutHelper< V, N, IndexSequence<>, Input >::Type
	Replace value at position N with V.
template<class F , class Seq >
using	AccumulateSequence = Constant< typename Seq::value_type, AccumulateSequenceHelper< Seq, F >::value >
	Accumulate the values of the sequence according to the supplied functor. More...
template<class... T>
using	IsIntegralPack = decltype(isIntegralPack(std::declval< T >()...))
	Decide whether the given parameter pack contains only integral types.
template<class T >
using	IsIntegralTuple = decltype(isIntegralTuple(std::declval< T >()))
	Decide whether the given tuple contains only integral types.
template<class Tuple , template< class... > class Predicate, class... Rest>
using	PredicateMatch = PredicateMatchHelper< std::decay_t< Tuple >, PredicateProxy< Predicate, Rest... >::template ForwardFirst >
	Apply the predicate to each tuple type in turn. More...
template<template< class... > class Predicate, class... T>
using	IndexOfMatching = IndexConstant< PredicateMatch< std::tuple< T... >, Predicate >::index_ >
	Obtain the index of the first matching tuple type.
template<template< class... > class Predicate, class... T>
using	AnyIs = BoolConstant<(...||Predicate< T >::value)>
	TrueType if any type matches the predicate.
template<template< class... > class Predicate, class... T>
using	AllAre = BoolConstant<(... &&Predicate< T >::value)>
	TrueType if all types match the predicate.
template<std::size_t N, template< class... > class Predicate, class... T>
using	NthIs = Predicate< TypePackElement< N, T... > >
	Instantiates to Predicate applied to the N-th element of T...
template<class F , class Seq >
using	FilteredSequence = TransformSequence< Seq, Sequence< typename Seq::value_type >, IdentityFunctor, UnaryFilterFunctor< F, typename Seq::value_type > >
	Create a new sequence by filtering out certain elements. More...
template<class Seq1 , class Seq2 >
using	CommonHead = IndexConstant< CommonHeadHelper< 0UL, Seq1, Seq2 >::value >
	Compute the number of identical indices at the head of the sequence.
template<std::size_t N, std::ptrdiff_t Offset = 0, std::ptrdiff_t Stride = 1L, std::size_t Repeat = 1>
using	MakeIndexSequence = MakeSequence< std::size_t, N, Offset, Stride, Repeat >
	Make a sequence of std::size_t elements. More...
template<class T >
using	MakeSequenceFor = MakeIndexSequence< size< T >()>
	Make a simple index sequence of the size of the argument, which may be anything for which size<T>() evaluates to a constant non-negative integer.
template<std::size_t N, std::size_t Value>
using	MakeConstantSequence = MakeIndexSequence< N, Value, 0 >
	Generate a constant index sequence of the given size.
template<std::size_t N, std::ptrdiff_t Offset = 0, std::size_t Repeat = 1>
using	MakeReverseSequence = MakeIndexSequence< N,(ptrdiff_t) N-1+Offset, -1, Repeat >
	Generate a simple reverse sequence.
template<class Input , class Inject , class Pos , bool AssumeSorted = true>
using	InsertAt = typename InsertAtHelper< Sequence< typename Input::value_type >, Input, Inject, Pos, AssumeSorted >::Type
	Insert Inject into the sequence Input at the position specified by Pos. More...
template<class T , T N, std::ptrdiff_t Offset = 0, std::ptrdiff_t Stride = 1L, std::size_t Repeat = 1>
using	MakeSequence = typename BuildSequence< T, N, Offset, Stride, Repeat >::Type
	Make an index sequence with an optional offset. More...
template<std::size_t mask>
using	MaskSequence = typename MaskSequenceHelper< mask, 0 >::type
	Generate the index-sequence type of set bits from a bit-mask.
template<std::size_t... I>
using	SequenceMask = IndexConstant< SequenceMaskHelper< I... >::value >
	Generate a bit-mask from the given index-sequence.
template<std::size_t Mask, std::size_t Bit>
using	HasBit = BoolConstant<(Mask &SequenceMask< Bit >::value) !=0UL >
	std::true_type if Mask has Bit set.
template<std::size_t Super, std::size_t Sub>
using	CondensedMask = IndexConstant< CondenseMaskHelper< IndexConstant< Super >, IndexConstant< Sub > >::value >
	Transform the bit-mask given in Sub be removing all bit-positions of zeros in Super. More...
template<std::size_t I, class DimSeq >
using	MultiIndex = std::decay_t< decltype(multiIndex< I >(DimSeq{}))>
	Generate the multi-index corresponding to the flattened index I where the multiindex varies between the 0 and the given dimensions. More...
template<class Indices , class Dims >
using	FlattenMultiIndex = IndexConstant< flattenMultiIndex(Dims{}, Indices{})>
	Compute the index of the given multi-index in the tuple of all indices.
template<class Permutation >
using	InversePermutation = typename SortSequence< Permutation >::Permutation
	Compute the inverse of the given permutation.
template<class Permutation , std::size_t N>
using	ResizedPermutation = typename ResizedPermutationHelper< Permutation, N >::Type
	Pad or truncate the permuation at the given size.
template<class Sequence , class Perm >
using	PermuteSequenceValues = typename PermuteSequenceValuesHelper< Perm, Sequence >::Type
	Apply the given permutation to the values of the given sequence.
template<class Sequence , class Perm >
using	PermuteSequence = std::decay_t< decltype(permute(Sequence{}, Perm{}))>
	Apply the given permutation to the positions of the given sequence.
template<std::size_t I0, std::size_t I1, std::size_t N = I1 + 1>
using	Transposition = typename TranspositionHelper< I0, I1, N >::Type
	Generate the transposition of I0 and I1 as permutation. More...
template<class Seq0 , class Seq1 , std::size_t N = Head<Seq1>::value+Seq1::size()>
using	BlockTransposition = typename BlockTranspositionHelper< Seq0, Seq1, N >::Type
	Generate the block-transposition of the I0 and the I1-block as permutation. More...
template<std::size_t Mask, std::size_t RequiredMask = 0UL>
using	SubMaskSequence = typename SubMaskSequenceHelper< IndexSequence<>, MaskSequence< Mask >, MaskSequence< RequiredMask > >::type
	Generate a sequence of pair-wise distinct sub-bitmasks starting from a given bit-mask. More...
template<class T , std::size_t... I>
using	SubTuple = decltype(subTuple< I... >(std::declval< T >()))
	Define the type of a sub-tuple given by an index-pack.
template<std::size_t mask, class T >
using	MaskTuple = decltype(maskTuple< mask >(std::declval< T >()))
	Define the type a sub-tuple generated by the give bit-mask.
template<template< class T, class... > class F, class Tuple >
using	FilteredTuple = std::decay_t< decltype(filteredTuple< F >(std::declval< Tuple >()))>
	Generate the type of the return value of filteredTuple().
template<class T , class Tuple >
using	AddFrontTuple = std::decay_t< decltype(addFront(std::declval< T >(), std::declval< Tuple >()))>
	Type of the tuple where a T is added at the front.
template<class T , class Tuple >
using	PushBackTuple = std::decay_t< decltype(pushBack(std::declval< T >(), std::declval< Tuple >()))>
	Type of the tuple where a T is added to the end.
template<class Tuple >
using	TupleScalarPromotionType = typename ScalarTupleTypePromotionHelper< Tuple, MakeSequenceFor< Tuple > >::Type
	Generate the type resulting from summing up all tuple elements.
template<class SeqIn , class SeqOut = Sequence<typename SeqIn::value_type>, class TransformFunctor = IdentityFunctor, class AcceptFunctor = AcceptAllFunctor>
using	TransformSequence = typename TransformSequenceHelper< SeqIn, SeqOut, TransformFunctor, AcceptFunctor >::Type
	General sequence transformation alias. More...
template<class Seq1 , class Seq2 >
using	CatSequence = TransformSequence< Seq1, Seq2 >
	Concatenate the given sequences to <Seq2, Seq1>
template<class... S>
using	SequenceCat = typename SequenceCatHelper2< S... >::Type
	Concatenate the given sequences, in order, to <S0, S1, ... >.
template<std::size_t N, class Seq >
using	SequenceProd = typename SequenceProdHelper< N, Seq, Sequence< typename Seq::value_type > >::Type
	Compute the "product" multi index of N identical copies.
template<std::size_t count, class Seq >
using	SequenceSplice = typename SequenceSpliceHelper< count, Seq >::Type
	Splice the sequence by repeating each value the given amount of times.
template<class F , class Seq , class Tout = typename F::template Apply<typename Seq::value_type, 0, 0>::value_type>
using	TransformedSequence = TransformSequence< Seq, Sequence< Tout >, F >
	Transform given sequence. More...
template<class F , class Seq >
using	CatTransformedSequence = TransformSequence< Seq, Seq, F >
	Transform only the element at the given position of the given sequence. More...
template<class F , class Seq >
using	TransformUnique = TransformSequence< Seq, Sequence< typename Seq::value_type >, F, AcceptEqualFunctor< false > >
	Apply the functor F::template value_type<I>::value to each element in Seq; add to the output/sequence if the result differs from I.
template<class F , class Seq >
using	CatTransformUnique = TransformSequence< Seq, Seq, F, AcceptEqualFunctor< false > >
	Concat the result of TransformUnique with the original sequence.
template<class F , class Seq , std::size_t... Index>
using	TransformOnly = TransformSequence< Seq, Sequence< typename Seq::value_type >, TransformAtIndexFunctor< F, Index... >, AcceptAllFunctor >
	Transform only those elements specified by the parameter pack Index. More...
template<std::ptrdiff_t Offset>
using	OffsetFunctor = MultiplyOffsetFunctor< 1, Offset >
	Offset functor. More...
template<std::size_t Stride>
using	MultiplyFunctor = MultiplyOffsetFunctor< Stride, 0 >
	Multiply functor. More...
TagUtilities
@
template<class A , class Tag >
using	HasTag = std::is_base_of< Tag, std::decay_t< A > >
	Evaluate to std::true_type if std::decay_t<A> is derived from Tag, otherwise to std::false_type.

Enumerations
enum	DGFlavour
enum class	SolverType
	Define some symbolic constants for SolverSelector and "parse" some preprocessort defines.

Functions
template<class DiscreteFunction , class Model , class InitialGuess , class RHSFunctional , std::enable_if_t<(IsWrappableByConstLocalFunction< InitialGuess >::value &&IsLinearFunctional< RHSFunctional >::value), int > = 0>
auto	ellipticFemScheme (DiscreteFunction &solution, const Model &model, const InitialGuess &initialGuess, const RHSFunctional &rhsFunctional, const std::string name="acfem.schemes.elliptic")
	Adaptive fem-scheme for "elliptic" problems. More...
template<class DiscreteFunction , class Model , class InitialGuess , std::enable_if_t< IsWrappableByConstLocalFunction< InitialGuess >::value, int > = 0>
auto	ellipticFemScheme (DiscreteFunction &solution, const Model &model, const InitialGuess &initialGuess, const std::string name="acfem.schemes.elliptic")
	Adaptive fem-scheme for "elliptic" problems. More...
template<class DiscreteFunction , class Model , class RHSFunctional , std::enable_if_t< IsLinearFunctional< RHSFunctional >::value, int > = 0>
auto	ellipticFemScheme (DiscreteFunction &solution, const Model &model, const RHSFunctional &rhsFunctional, const std::string name="acfem.schemes.elliptic")
	Adaptive fem-scheme for "elliptic" problems. More...
template<class DiscreteFunction , class Model >
auto	ellipticFemScheme (DiscreteFunction &solution, const Model &model, const std::string name="acfem.schemes.elliptic")
	Adaptive fem-scheme for "elliptic" problems. More...
template<class DiscreteFunction , class TimeProvider , class ImplicitModel , class ExplicitModel , class InitialValue , class RHSFunctional , template< class > class QuadratureTraits>
std::enable_if_t< IsLinearFunctional< RHSFunctional >::value, ParabolicFemScheme< DiscreteFunction, TimeProvider, ImplicitModel, ExplicitModel, InitialValue, RHSFunctional, QuadratureTraits > >	parabolicFemScheme (DiscreteFunction &solution, const TimeProvider &timeProvider, const ImplicitModel &implicitModel, const ExplicitModel &explicitModel, const InitialValue &initialValue, const RHSFunctional &rhsFunctional, const QuadratureTraits< typename DiscreteFunction::DiscreteFunctionSpaceType::GridPartType > &quadTraits, const std::string &name="acfem.schemes.parabolic")
	Basic parabolic fem-scheme class. More...
template<class DiscreteFunction , class TimeProvider , class ImplicitModel , class ExplicitModel , class InitialValue , template< class > class QuadratureTraits>
auto	parabolicFemScheme (DiscreteFunction &solution, const TimeProvider &timeProvider, const ImplicitModel &implicitModel, const ExplicitModel &explicitModel, const InitialValue &initialValue, const QuadratureTraits< typename DiscreteFunction::DiscreteFunctionSpaceType::GridPartType > &quadTraits, const std::string &name="acfem.schemes.parabolic")
	Basic parabolic fem-scheme class. More...
template<class DiscreteFunction , class TimeProvider , class ImplicitModel , class ExplicitModel , class InitialValue , class RHSFunctional >
std::enable_if_t< IsLinearFunctional< RHSFunctional >::value, ParabolicFemScheme< DiscreteFunction, TimeProvider, ImplicitModel, ExplicitModel, InitialValue, RHSFunctional, DefaultQuadratureTraits > >	parabolicFemScheme (DiscreteFunction &solution, const TimeProvider &timeProvider, const ImplicitModel &implicitModel, const ExplicitModel &explicitModel, const InitialValue &initialValue, const RHSFunctional &rhsFunctional, const std::string &name="acfem.schemes.parabolic")
	Basic parabolic fem-scheme class. More...
template<class DiscreteFunction , class TimeProvider , class ImplicitModel , class ExplicitModel , class InitialValue >
auto	parabolicFemScheme (DiscreteFunction &solution, const TimeProvider &timeProvider, const ImplicitModel &implicitModel, const ExplicitModel &explicitModel, const InitialValue &initialValue, const std::string &name="acfem.schemes.parabolic")
	Basic parabolic fem-scheme class. More...
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 T , T V>
constexpr std::size_t	findMostSignificantBit (Constant< T, V > &&)
	Template-algorithm which returns the the index of the most significant bit in an integer-constant. More...
template<class T , T V>
constexpr std::size_t	findLeastSignificantBit (Constant< T, V > &&)
	Template-algorithm which returns the the index of the least significant bit in an integer-constant. More...
template<class T , T V>
constexpr std::size_t	findFirstZeroBit (Constant< T, V > &&)
	Template-algorithm which returns the the index of the first 0-bit in an integer-constant. More...
template<class F , class O , class Tuple , std::size_t... I>
constexpr decltype(auto)	applyMethod (F &&f, O &&o, Tuple &&t, std::index_sequence< I... >)
	Apply a method through a member function pointer. More...
template<class F , class O , class Tuple >
constexpr decltype(auto)	applyMethod (F &&f, O &&o, Tuple &&t)
	Apply a method through a member function pointer. 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<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 T >
std::ostream &	operator<< (std::ostream &out, TypeString< T > &&t)
	Output operator for TypePrint tag-structure.
template<class T >
void	prettyPrint (T &&arg, std::ostream &out=std::cout, const bool newLine=true)
	Print something which shows the type that was passed to the function. More...
template<class Int , Int I0, Int... I>
std::ostream &	operator<< (std::ostream &out, Sequence< Int, I0, I... >)
	Print sequence.
template<bool I0, bool... I>
std::ostream &	operator<< (std::ostream &out, BoolSequence< I0, I... >)
	Print bool-sequence.
template<class Quadrature >
decltype(auto)	operator* (const QuadraturePoint< Quadrature > &qp)
	Forward Fem::QuadraturePointWrapper as is.
template<typename T >
std::string	objectToString (const T &something)
	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...
constexpr auto	trueType ()
	Generate a TrueType.
constexpr auto	falseType ()
	Generate a FalseType.
template<bool Cond>
constexpr auto	boolType (BoolConstant< Cond > arg=BoolConstant< Cond >{})
	Generate a BoolConstant.
template<class T0 , class T1 >
constexpr auto	forwardAsPair (T0 &&t0, T1 &&t1)
	Forward as pair capturing lvalue references.
template<class T >
constexpr T	forwardReturnValue (std::remove_reference_t< T > &t)
	Forward lvalue-references as references.
template<class T >
constexpr T	forwardReturnValue (std::remove_reference_t< T > &&t)
	Force copy for rvalue-references in order to guard against leaking references to local variables in return statements.
template<class T >
auto	typeString (T &&t, bool stripNameSpaces=true)
	Generator for TypeString. More...
template<class T , std::enable_if_t< IsFractionOperand< T, false >::value, int > = 0>
constexpr auto	zero (T &&t)
	Use the zero fraction as canonical zero element for scalars.
template<class T , std::enable_if_t< IsFractionOperand< T, false >::value, int > = 0>
constexpr auto	one (T &&t)
	Use the one fraction as canonical zero element for scalars.
template<class T , std::enable_if_t<!std::is_same< FloatingPointClosure< std::decay_t< T > >, std::decay_t< T > >::value, int > = 0>
constexpr auto	floatingPointClosure (T &&t)
	Convert in particular integer types to a decent floating point type.
template<class T , std::enable_if_t< std::is_same< FloatingPointClosure< std::decay_t< T > >, std::decay_t< T > >::value, int > = 0>
constexpr decltype(auto)	floatingPointClosure (T &&t)
	Forward floating point arguments as is.
template<class F >
std::string	operationName (F &&f, const std::string &arg)
	Verbose print of an operation, helper function to produce noise.
template<class F >
std::string	operationName (F &&f, const std::string &left, const std::string &right)
	Verbose print of a binary operation, helper function to produce noise.
template<class F , class... Strings, std::enable_if_t<(sizeof...(Strings) > 2), int > = 0>
std::string	operationName (F &&f, Strings &&... strings)
	Verbose print of an n-ary operation.
template<std::size_t I, class T , std::enable_if_t< IsTupleLike< T >::value, int > = 0>
constexpr decltype(auto)	get (T &&t, IndexConstant< I >=IndexConstant< I >{})
	Access to the i-the element.
template<std::size_t I, class T , std::size_t N, std::enable_if_t< std::is_integral< T >::value, int > = 0>
constexpr decltype(auto)	get (const T(&t)[N], IndexConstant< I >=IndexConstant< I >{})
	Access to the i-the element.
template<std::size_t I, class T , T... V>
constexpr auto	get (Sequence< T, V... >, IndexConstant< I >=IndexConstant< I >{})
	Access to the i-the element.
template<std::size_t I, class T , T V>
constexpr auto	get (Constant< T, V >, IndexConstant< I >=IndexConstant< I >{})
	Access to the i-the element.
template<std::ptrdiff_t V, class T , T... I>
constexpr auto	pushFront (Sequence< T, I... >, IntConstant< V >=IntConstant< V >{})
	Add V at the front of the sequence.
template<std::ptrdiff_t V, class T , T... I>
constexpr auto	pushBack (Sequence< T, I... >, IntConstant< V >=IntConstant< V >{})
	Add V at the end of the sequece.
template<class T1 , class T2 , std::enable_if_t<(IsTupleLike< T1 >::value &&IsTupleLike< T2 >::value &&size< T1 >()==size< T2 >()), int > = 0>
auto &	assign (T1 &t1, T2 &&t2)
	Assign one tuple-alike to another by looping over the elements.
template<class T , T T0, T... Ts>
constexpr bool	isConstant (Sequence< T, T0, Ts... >)
template<class T >
constexpr bool	isConstant (Sequence< T >)
	Mark one element and empty sequences as pairwise equal.
template<class T , T I, T... Rest>
constexpr bool	isConsecutive (Sequence< T, I, Rest... > seq)
template<class T >
constexpr bool	isConsecutive (Sequence< T >)
template<template< std::size_t, std::size_t > class DoSwap, class T , T... Ts>
constexpr bool	isSorted (Sequence< T, Ts... >)
template<class T , T... Ts>
constexpr bool	isSorted (Sequence< T, Ts... > seq)
template<class T , T... V>
constexpr bool	isSimple (Sequence< T, V... > seq)
template<std::size_t Align, class T , T V0, T... V>
constexpr bool	isAlignedBlock (Sequence< T, V0, V... >, IndexConstant< Align >=IndexConstant< Align >{})
template<std::size_t... Ind>
constexpr bool	isPermutation (IndexSequence< Ind... >=IndexSequence< Ind... >{})
template<class... T>
constexpr auto	isIntegralPack (T &&...)
	Decide whether the given parameter pack contains only integral types.
template<class T , std::size_t N>
constexpr auto	isIntegralTuple (const std::array< T, N > &)
	Decide whether the given tuple contains only integral types.
template<class T1 , class T2 >
constexpr auto	isIntegralTuple (const std::pair< T1, T2 > &)
	Decide whether the given tuple contains only integral types.
template<class... T>
constexpr auto	isIntegralTuple (const std::tuple< T... > &)
	Decide whether the given tuple contains only integral types.
template<class Tuple , std::enable_if_t< IsTupleLike< Tuple >::value, int > = 0>
constexpr bool	isConstant (Tuple &&t)
	true if all elements of the tuple compare equal.
template<typename Int , Int... I0, Int... I1>
constexpr auto	sequenceCat (Sequence< Int, I0... >, Sequence< Int, I1... >)
template<typename Int , Int... I0, Int... I1, class Seq , class... RestSeq>
constexpr auto	sequenceCat (Sequence< Int, I0... >, Sequence< Int, I1... >, Seq, RestSeq...)
template<class Seq >
constexpr auto	sequenceCat (Seq)
template<std::size_t... I, class F >
constexpr bool	forEachWhile (F &&f, IndexSequence< I... >=IndexSequence< I... >{})
	Repeat until F returns false. More...
template<std::size_t... I, class F >
constexpr bool	forEachWhile (IndexSequence< I... >, F &&f)
	Repeat until F returns false. More...
template<std::size_t... I, class F , class T >
constexpr auto	addEach (T &&init, F &&f, IndexSequence< I... >=IndexSequence< I... >{})
	Invoke the given functor sizeof...(I) times and sum up the result, where init gives the initial value of the sum.
template<std::size_t... I, class F , class T >
constexpr auto	addEach (IndexSequence< I... >, T &&init, F &&f)
	Invoke the given functor sizeof...(I) times and sum up the result, where init gives the initial value of the sum.
template<std::size_t N, class F , class T >
constexpr auto	addLoop (F &&f, T &&init, IndexConstant< N >=IndexConstant< N >{})
	Version with just a plain number as argument.
template<std::size_t... I, class F , class T >
constexpr auto	multiplyEach (T &&init, F &&f, IndexSequence< I... >=IndexSequence< I... >{})
	Invoke the given functor sizeof...(I) times and multiply the result, where init gives the initial value of the sum.
template<std::size_t... I, class F , class T >
constexpr auto	multiplyEach (IndexSequence< I... >, T &&init, F &&f)
	Invoke the given functor sizeof...(I) times and multiply the result, where init gives the initial value of the sum.
template<std::size_t N, class F , class T >
constexpr auto	multiplyLoop (T &&init, F &&f, IndexConstant< N >=IndexConstant< N >{})
	Version with just a plain number as argument.
template<std::size_t... I>
constexpr auto	sequenceMask (const IndexSequence< I... > &)
	Generate a bit-mask from the given index-sequence.
constexpr bool	hasBit (const std::size_t &mask, const std::size_t &bit)
	std::true_type if Mask has Bit set. More...
template<std::size_t I, std::size_t... Dims>
constexpr auto	multiIndex (IndexSequence< Dims... >, IndexConstant< I >=IndexConstant< I >{})
	Generate the multi-index corresponding to the flattened index I where the multiindex varies between the 0 and the given dimensions. More...
template<std::size_t... Dims>
constexpr auto	multiIndex (std::size_t index, IndexSequence< Dims... >)
	Generate the multi-index corresponding to the flattened index I where the multiindex varies between the 0 and the given dimensions. Runtime-dynamic version. More...
template<class Dims , std::size_t N, std::enable_if_t< Dims::size()==N, int > = 0>
constexpr std::size_t	flattenMultiIndex (Dims, const std::array< std::size_t, N > &indices)
	Flatten run-time variable std::array.
template<std::size_t... Indices, std::size_t... Dims>
constexpr auto	flattenMultiIndex (IndexSequence< Dims... >, IndexSequence< Indices... >=IndexSequence< Indices... >{})
	Compile-time constant flatten routine.
template<std::size_t... IndexPositions, std::size_t... Dimensions>
static std::size_t constexpr	multiDim (IndexSequence< Dimensions... >, IndexSequence< IndexPositions... >=IndexSequence< IndexPositions... >{})
	Compute the "dimension" corresponding to the given signature, i.e. More...
template<std::size_t... Ps, class Seq , std::enable_if_t< IsSequence< Seq >::value, int > = 0>
constexpr auto	permute (Seq, IndexSequence< Ps... >=IndexSequence< Ps... >{})
	Permute the given sequence.
template<std::size_t... Ps, class T , std::enable_if_t< IsTupleLike< T >::value &&!isSimple(IndexSequence< Ps... >{}), int > = 0>
constexpr auto	permute (T &&t, IndexSequence< Ps... >=IndexSequence< Ps... >{})
	Permute the given tuple like.
template<std::size_t... Ps, class T , std::enable_if_t< IsTupleLike< T >::value &&isSimple(IndexSequence< Ps... >{}), int > = 0>
constexpr decltype(auto)	permute (T &&t, IndexSequence< Ps... >=IndexSequence< Ps... >{})
	Permute the given tuple like.
template<class T , T... I, std::size_t... P, std::enable_if_t< sizeof...(I)==sizeof...(P), int > = 0>
constexpr auto	isInvariant (Sequence< T, I... >, IndexSequence< P... >)
	Return true if applying the given permutation to the value positions leaves the sequence invariant.
template<std::size_t mask>
constexpr auto	submaskSequence (IndexConstant< mask > &&)
	Generate a sequence of pair-wise distinct sub-bitmasks starting from a given bit-mask. More...
template<std::size_t... I>
constexpr auto	submaskSequence (IndexSequence< I... > &&)
	Generate a sequence of pair-wise distinct sub-bitmasks starting from a given bit-mask. More...
template<std::size_t... Pos, class SrcTuple , class DataTuple , bool AssumeSorted = true, std::enable_if_t< AllowsGet< SrcTuple >::value &&AllowsGet< DataTuple >::value, int > = 0>
auto	insertAt (SrcTuple &&src, DataTuple &&data, BoolConstant< AssumeSorted >=BoolConstant< AssumeSorted >{})
	Insert the elements of data at positions given by pos into src in turn. More...
template<std::size_t Where, class SrcTuple , class Data , bool AssumeSorted = true, std::enable_if_t< AllowsGet< SrcTuple >::value &&!AllowsGet< Data >::value, int > = 0>
auto	insertAt (SrcTuple &&src, Data &&data, BoolConstant< AssumeSorted >=BoolConstant< AssumeSorted >{})
	Like the tuple variant, but with single non-tuple value.
template<std::size_t... Pos, class SrcTuple , class DataTuple , bool AssumeSorted = true, std::enable_if_t< AllowsGet< SrcTuple >::value &&AllowsGet< DataTuple >::value, int > = 0>
auto	insertAt (SrcTuple &&src, DataTuple &&data, IndexSequence< Pos... >, BoolConstant< AssumeSorted >=BoolConstant< AssumeSorted >{})
	Insert-at variant with indices given by index-sequence argument.
template<std::size_t Where, class SrcTuple , class Data , bool AssumeSorted = true, std::enable_if_t< AllowsGet< SrcTuple >::value &&!AllowsGet< Data >::value, int > = 0>
auto	insertAt (SrcTuple &&src, Data &&data, IndexConstant< Where >, BoolConstant< AssumeSorted >=BoolConstant< AssumeSorted >{})
	Insert-at variant with indices given by index-constant argument.
template<std::size_t... I, class TupleLike , std::enable_if_t< IsTupleLike< TupleLike >::value, int > = 0>
auto	subTuple (const TupleLike &t, IndexSequence< I... >=IndexSequence< I... >{})
	Extract a sub-tuple by explicit indexing. More...
template<std::size_t... I, class TupleLike , std::enable_if_t< IsTupleLike< TupleLike >::value, int > = 0>
auto	forwardSubTuple (const TupleLike &t, IndexSequence< I... >=IndexSequence< I... >{})
	Like subTuble() but forward the arguments, possibly in order to be expanded as parameters to another function.
template<std::size_t mask, typename... T>
auto	maskTuple (const std::tuple< T... > &t, IndexConstant< mask >=IndexConstant< mask >{})
	Generate a sub-tuple with the elements at the positions where a bit in a bit-mask is set. More...
template<template< class T, class... > class F, class Tuple >
auto	filteredTuple (Tuple &&t)
	Generate a sub-tuple of the elements where F<TupleElement<N, Tuple> > is derived from std::true_type, where N is the index of the respective type in the tuple. More...
template<class T , class Tuple , std::enable_if_t< IsTupleLike< Tuple >::value, int > = 0>
constexpr auto	addFront (T &&t, Tuple &&tuple)
	Add an element to the front.
template<class T , class Tuple , std::enable_if_t< IsTupleLike< Tuple >::value, int > = 0>
constexpr auto	pushBack (T &&t, Tuple &&tuple)
	Add an element to the end.
template<class T , T... Ind>
auto	toArray (Sequence< T, Ind... >)
	Convert a compile-time constant integer sequence to a rutime-object with the same values.
template<class T , class Tuple , std::enable_if_t< IsTupleLike< Tuple >::value, int > = 0>
auto	toArray (Tuple &&t)
	Convert tuples and pairs to arrays.
template<class Tuple , std::enable_if_t<(IsTupleLike< Tuple >::value &&CanPromoteTupleTypes< Tuple >::value), int > = 0>
auto	toArray (Tuple &&t)
	Convert tuples and pairs to arrays.
template<class T , T I0>
auto	toString (Sequence< T, I0 >)
	Generate a compact string representation as a comma separated list of the values, without spaces.
template<class T , T I0, T I1, T... Rest>
auto	toString (Sequence< T, I0, I1, Rest... >)
	Generate a compact string representation as a comma separated list of the values, without spaces.
template<class T >
auto	toString (Sequence< T >)
template<std::ptrdiff_t Offset, class T , T... Ts>
constexpr auto	offsetSequence (Sequence< T, Ts... >=Sequence< T, Ts... >{}, IntConstant< Offset >=IntConstant< Offset >{})
	Simple offset operation without the overhead of TransformSequence.
template<class Functional , class DiscreteFunction , std::enable_if_t<(IsLinearFunctional< Functional >::value &&IsDiscreteFunction< DiscreteFunction >::value), int > = 0>
void	l2Projection (const Functional &phi, DiscreteFunction &result)
	Compute the L2-projection of the given functional to a discrete space. More...
template<class GridFunction , class DiscreteFunction , std::enable_if_t<(IsWrappableByConstLocalFunction< GridFunction >::value &&IsDiscreteFunction< DiscreteFunction >::value), int > = 0>
void	l2Projection (GridFunction &&fct, DiscreteFunction &result)
	Perform an L2-projection for any GridFunction.
SignComparisons
Some constexpr operators to support symbolic notations.
template<class Expression , class Int , Int I>
constexpr std::enable_if_t< OwnsExpressionTraits< Expression >::value, bool >	operator<= (const Expression &, Constant< Int, I >)
template<class Expression , class Int , Int I>
constexpr std::enable_if_t< OwnsExpressionTraits< Expression >::value, bool >	operator>= (const Expression &, Constant< Int, I >)
template<class Expression , class Int , Int I>
constexpr std::enable_if_t< OwnsExpressionTraits< Expression >::value, bool >	operator< (const Expression &, Constant< Int, I >)
template<class Expression , class Int , Int I>
constexpr std::enable_if_t< OwnsExpressionTraits< Expression >::value, bool >	operator> (const Expression &, Constant< Int, I >)
template<class Expression , class Int , Int I>
constexpr std::enable_if_t< OwnsExpressionTraits< Expression >::value, bool >	operator== (const Expression &, Constant< Int, I >)
template<class Expression , class Int , Int I>
constexpr std::enable_if_t< OwnsExpressionTraits< Expression >::value, bool >	operator!= (const Expression &, Constant< Int, I >)
template<class T >
constexpr auto	expressionTraits ()
template<class T >
constexpr auto	expressionTraits (T &&)

Variables
template<class Seq , class Perm >
constexpr bool	HasInvariantValuesV = std::is_same<Seq, PermuteSequenceValues<Seq, Perm> >::value
	Evaluate to true if applying the permutation Perm to the values of Seq leaves the values invariant.

AccumulateFoldExpressions
Accumulate Sequences with fold expressions.
template<class Seq >
using	LogicalAnd = BoolConstant< logicalAnd(Seq{})>
template<class Seq >
using	LogicalOr = BoolConstant< logicalOr(Seq{})>
template<class Seq >
using	BitwiseAnd = Constant< typename Seq::value_type, bitwiseAnd(Seq{})>
template<class Seq >
using	BitwiseOr = Constant< typename Seq::value_type, bitwiseOr(Seq{})>
template<class Seq >
using	Sum = Constant< typename Seq::value_type, sum(Seq{})>
template<class Seq >
using	Prod = Constant< typename Seq::value_type, prod(Seq{})>
template<class Seq >
using	Min = Constant< typename Seq::value_type, min(Seq{})>
template<class Seq >
using	Max = Constant< typename Seq::value_type, max(Seq{})>
template<class T , T... Ts>
constexpr bool	logicalAnd (Sequence< T, Ts... >)
template<class T , T... Ts>
constexpr bool	logicalOr (Sequence< T, Ts... >)
template<class T , T... Ts>
constexpr T	bitwiseAnd (Sequence< T, Ts... >)
template<class T , T... Ts>
constexpr T	bitwiseOr (Sequence< T, Ts... >)
template<class T , T... Ts>
constexpr T	sum (Sequence< T, Ts... >)
template<class T , T... Ts>
constexpr T	prod (Sequence< T, Ts... >)
template<class T , T... Ts>
constexpr T	max (Sequence< T, Ts... >)
template<class T , T... Ts>
constexpr T	min (Sequence< T, Ts... >)

ListSize
Getting the size of sequences and tuple-likes.
template<class T >
using	Size = IndexConstant< SizeV< std::decay_t< T > > >
	Gives the number of elements in tuple-likes and std::integer_sequence.
template<class T >
constexpr std::size_t	SizeV = std::numeric_limits<std::size_t>::max()
	Gives the number of elements in tuple-likes and std::integer_sequence.
template<class T , T V>
constexpr std::size_t	SizeV< Constant< T, V > > = 1UL
	Gives the number of elements in tuple-likes and std::integer_sequence.
template<class T , T... V>
constexpr std::size_t	SizeV< Sequence< T, V... > > = sizeof...(V)
	Gives the number of elements in tuple-likes and std::integer_sequence.
template<class T >
constexpr std::size_t	SizeV< T && > = SizeV<std::decay_t<T> >
	Gives the number of elements in tuple-likes and std::integer_sequence.
template<class T >
constexpr std::size_t	SizeV< T & > = SizeV<std::decay_t<T> >
	Gives the number of elements in tuple-likes and std::integer_sequence.
template<class T >
constexpr std::size_t	size ()
	Gives the number of elements in tuple-likes and std::integer_sequence.
template<class T , std::enable_if_t<(SizeV< T > !=SizeV< void >), int > = 0>
constexpr std::size_t	size (T &&t)
	Gives the number of elements in tuple-likes and std::integer_sequence. 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.

Typedef Documentation

AreRuntimeSameExpressions

template<class T1 , class T2 >

using Dune::ACFem::AreRuntimeSameExpressions = typedef Expressions::AreRuntimeEqual<T1, T2>

FalseType by default.

BaseExpressionTraits

template<class T >

using Dune::ACFem::BaseExpressionTraits = typedef ExpressionTraits<T, void, BaseTraitsLevel>

This is the default implementation if not overriden at higher level.

Higher level may also opt to inherit from this one and specialize as appropriate.

IsRuntimeEqualExpression

template<class T >

using Dune::ACFem::IsRuntimeEqualExpression = typedef Expressions::IsRuntimeEqual<T>

LoadModel

template<class Model , class GridFunction >

using Dune::ACFem::LoadModel = typedef PDEModel::BinaryModelExpression<PDEModel::ApplyOperation<PDEModel::L2LoadFlavour>, Model, GridFunction>

This will become a "load"-model which applies "Model" to "Function" and generates the necessary load-vectors s.t.

Function will be approximated by the respective FEM-discretization.

There will be two flavours:

• L2-style load-vector model for rapid proto-typing which adds the fluxDivergence() to the source() contribution closes the model with the appropriate boundary values.
• Ritz-projection model which simply applies the model to the function as is. This can be used to compute a Ritz-projection in order to obtain better initial values for time-dependent problems.

Note

You have to substract the load-model from a given model in order to form the "equation" which leads to a FEM-approximation of the given function. The LoadModel simply applies the model to the given function, but does not "move it to the right hand side".

LumpingQuadratureTraits

template<class GridPart >

using Dune::ACFem::LumpingQuadratureTraits = typedef MaybeLumpingQuadratureTraits<GridPart, true, true>

Traits class with lumping quadratures in the bulk and on the skeleton.

Note

Defining this as a using-template-alias somehow does not work; gcc complains about the template-parameter list when using quadrature traits as template-template parameters.

MultiIndex

template<std::size_t I, class DimSeq >

using Dune::ACFem::MultiIndex = typedef std::decay_t<decltype(multiIndex<I>(DimSeq{}))>

Generate the multi-index corresponding to the flattened index I where the multiindex varies between the 0 and the given dimensions.

The enumeration is such that the last index is incremented first as if the generated index would correspond to a digit representation of some number. E.g. for Dims... = 2,2,2:

<0,0,0> <0,0,1> <0,1,0> <0,1,1> etc.

Function Documentation

multiDim()

template<std::size_t... IndexPositions, std::size_t... Dimensions>

static std::size_t constexpr Dune::ACFem::multiDim ( IndexSequence< Dimensions... >  , IndexSequence< IndexPositions... >  = IndexSequence<IndexPositions...>{}  )

staticconstexpr

Compute the "dimension" corresponding to the given signature, i.e.

to total number of the multi-indices for the given dimensions.

Referenced by Dune::ACFem::Tensor::EinsteinSummation< LeftTensor, LeftIndices, RightTensor, RightIndices, IdenticalOperands >::operator()().

multiIndex() [1/2]

template<std::size_t I, std::size_t... Dims>

constexpr auto Dune::ACFem::multiIndex ( IndexSequence< Dims... >  , IndexConstant< I >  = IndexConstant<I>{}  )

constexpr

Generate the multi-index corresponding to the flattened index I where the multiindex varies between the 0 and the given dimensions.

The enumeration is such that the last index is incremented first as if the generated index would correspond to a digit representation of some number. E.g. for Dims... = 2,2,2:

<0,0,0> <0,0,1> <0,1,0> <0,1,1> etc.

Referenced by Dune::ACFem::Tensor::Reshape< Parent, Seq< Dimensions... > >::operator()(), and Dune::ACFem::Tensor::LinearStorageTensor< Container, Seq< Dimensions... > >::operator=().

multiIndex() [2/2]

template<std::size_t... Dims>

constexpr auto Dune::ACFem::multiIndex ( std::size_t  index, IndexSequence< Dims... >    )

constexpr

Generate the multi-index corresponding to the flattened index I where the multiindex varies between the 0 and the given dimensions. Runtime-dynamic version.

The enumeration is such that the last index is incremented first as if the generated index would correspond to a digit representation of some number. E.g. for Dims... = 2,2,2:

<0,0,0> <0,0,1> <0,1,0> <0,1,1> etc. Runtime-dynamic version.