DUNE-ACFEM (unstable)
A namespace encapsulating everything defined in our dune-acfem project. More...
Namespaces | |
ModelIntrospection | |
Deduce methods and call-signatures from an implemented model. | |
MPL | |
Form a sub-sequence with the values at the positions NOT given in Indices. | |
Classes | |
class | EllipticFemScheme |
Adaptive fem-scheme for "elliptic" problems. More... | |
class | BasicFemScheme |
Abstract non-adaptive basic FEM scheme. More... | |
class | AdaptiveFemScheme |
Abstract space adaptative FEM scheme. More... | |
struct | OperatorTypeSelector |
class | ParabolicFemScheme |
Basic parabolic fem-scheme class. More... | |
class | ContainerTuple |
Create a tuple of values from a tuple of containers. More... | |
class | DataOutputParameters |
Potentially overwrite some parameters. More... | |
struct | DofMapperTupleDataHandleTraits |
Traits for just something indexable. More... | |
class | DofMapperTupleDataHandle |
Potential all - all communication for mapped data. 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 | GeometryInformation |
Export some hard-to-get-at things for geometries. 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 | MaybeLumpingQuadratureTraits |
Helper traits-class, defining likely quadrature types for mass-lumping. More... | |
struct | IsQuadraturePoint |
struct | IsQuadraturePoint< T, std::enable_if_t<!IsDecay< T >{}> > |
struct | IsQuadraturePoint< Fem::QuadraturePointWrapper< Quadrature > > |
Identify quadrature points. More... | |
class | PointWrapperQuadrature |
A wrapper class which allows to "simulate" a Dune::Fem::QuadraturePointWrapper. More... | |
class | ScopedRedirect |
A class to redirect streams. More... | |
struct | SolverSelector |
Select one appropriate (linear) solver depending on whether the model is symmetric and/or semidefinite. More... | |
struct | TimeProviderTraits |
Type of time and time-step values. More... | |
class | TimeView |
Generate a view on the current time-step. More... | |
struct | MakeType |
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 | 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 | AndPredicate |
Logical "and" for two perdicates. More... | |
struct | OrPredicate |
Logical "or" for two perdicates. 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 | IsSequence |
struct | IsSequence< Sequence< T, Ints... > > |
Evaluate to TrueType of integer sequences. More... | |
struct | IsIndexSequence |
struct | IsIndexSequence< IndexSequence< Ints... > > |
TrueType for integer sequences with value_type std::size_t. More... | |
struct | IsIntegralConstant |
FalseType by default. More... | |
struct | IsIntegralConstant< Constant< T, V > > |
TrueType for integral_constant. More... | |
struct | IsBoolConstant |
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 | IsBoolConstant< BoolConstant< V > > |
TrueType for bool constant. 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 | 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 | IsArray |
struct | IsArray< T, std::enable_if_t<!IsDecay< T >::value > > |
Forward to decay if T is not a decay type. More... | |
struct | IsArray< std::array< T, N > > |
TrueType if T is a std::array. More... | |
struct | HasResize |
struct | SameDecay |
TrueType if T1 and T2 have the same decay types, otherwise FalseType. More... | |
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 | Case |
Case-structure for multi-conditional switch. More... | |
struct | Switch |
Recursion for a multi-conditional switch. 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 | 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 | 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 | remove_const |
Export a type trough remove_const::type as follows: More... | |
class | TypeString |
A class constructing the name of another type. More... | |
struct | IsApplicableTo |
Is TrueType if an F can be invoked with an E. 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 | 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 | IsIntegral< TypedValue::FractionConstant< I, N, 1 > > |
Some FractionConstants are integral. More... | |
struct | ExpressionTraits< FractionConstant< Int, N, D > > |
Override ExpressionTraits for FractionConstant. More... | |
struct | ExpressionTraits< TypedValue::NamedConstant< T, Name... > > |
Override ExpressionTraits for NamedConstant. More... | |
struct | PlusOperation |
Addition of two objects. More... | |
struct | PlusEqOperation |
A += B. More... | |
struct | MinusOperation |
Subtraction of two objects and unary minus. More... | |
struct | MinusEqOperation |
A -= B. More... | |
struct | LogicalNotOperation |
Logical Not. More... | |
struct | LogicalAndOperation |
Logical And. More... | |
struct | LogicalOrOperation |
Logical Or. More... | |
struct | EqOperation |
== More... | |
struct | NeOperation |
!= More... | |
struct | GtOperation |
More... | |
struct | GeOperation |
>= More... | |
struct | LtOperation |
< More... | |
struct | LeOperation |
<= More... | |
struct | SMultiplyOperation |
Multiplication by scalars from the left. More... | |
struct | SMultiplyEqOperation |
A *= s. More... | |
struct | IdentityOperation |
Identity, i.e. just wrap the object. More... | |
struct | AssumeOperation |
Assume operations attach a property to the wrapped expression. More... | |
struct | IndeterminateOperation |
Indeterminate operation, wrap another object and attach an id. More... | |
struct | PlaceholderOperation |
Placeholder operation wraps another object and attaches an id to it. More... | |
struct | SubExpressionOperation |
Kind of placeholder. More... | |
struct | ReciprocalOperation |
Inversion of a scalar object. More... | |
struct | SqrtOperation |
Taking the square root of an object. More... | |
struct | SquareOperation |
Taking the square of an object. More... | |
struct | PowOperation |
Taking something to the power of something. More... | |
struct | ExpOperation |
Exponentiation of an object. More... | |
struct | LogOperation |
Taking the logarithm of an object. More... | |
struct | CoshOperation |
Hyperbolic cosine. More... | |
struct | SinhOperation |
Hyperbolic sine. More... | |
struct | TanhOperation |
Hyperbolic tangens. More... | |
struct | AcoshOperation |
Inverse hyperbolic cosine. More... | |
struct | AsinhOperation |
Inverse hyperbolic sine. More... | |
struct | AtanhOperation |
Inverse hyperbolic tangens. More... | |
struct | SinOperation |
Taking the sine of an object. More... | |
struct | CosOperation |
Taking the cosine of an object. More... | |
struct | TanOperation |
Taking the tangens of an object. More... | |
struct | AsinOperation |
Taking the arc sine of an object. More... | |
struct | AcosOperation |
Taking the arc cosine of an object. More... | |
struct | AtanOperation |
Taking the arctan of an object. More... | |
struct | Atan2Operation |
Taking the arctan of an object. More... | |
struct | ErfOperation |
erf More... | |
struct | TGammaOperation |
tgamma More... | |
struct | LGammaOperation |
;gamma More... | |
struct | CeilOperation |
ceil More... | |
struct | FloorOperation |
floor More... | |
struct | RoundOperation |
round More... | |
struct | AbsOperation |
abs More... | |
struct | MinOperation |
min More... | |
struct | MaxOperation |
max More... | |
struct | TernaryOperation |
IfOperation. More... | |
struct | ExpressionTraits |
Default expression traits definition is a recursion in order to ease disambiguation. More... | |
struct | ExpressionTraits< T, void, DefaultTraitsLevel > |
A traits class in order to collect properties of expressions. More... | |
struct | ExpressionTraits< T, std::enable_if_t<!IsDecay< T >::value >, DecayTraitsLevel > |
Forward to the traits class for the decay type. More... | |
struct | ZeroExpressionTraits |
ExpressionTraits for any zero-expression. More... | |
struct | FieldPromotion |
Promote potentially different numeric field types to a "closure" type. More... | |
struct | IsProductOperation |
Evaluate to std::true_type if the operation is product-like. More... | |
struct | IsDistributiveOperation |
True for expressions which can be moved inside or outside of sums. More... | |
struct | IsVolatileOperation< PlaceholderOperation< Placeholder > > |
Placeholder expressions are volatile by design, unless overridden by a RuntimEqualExpression tag. More... | |
struct | IsVolatileOperation< IndeterminateOperation< Id > > |
Indeterminates are also volatile by design. 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 | TerminalExpression |
A terminal expression is an "expression end-point", i.e. More... | |
struct | VolatileExpression |
A volatile expression will not be replaced by its value except for RuntimeEqual optimizations. 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 | 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 | IndependentExpression |
An independent expression is an expression which does not depend on external state. More... | |
struct | PieceWiseConstantExpression |
Something constant on a given entity. More... | |
struct | ConstantExpression |
A constant. More... | |
struct | TypedValueExpression |
A tag structure signalling that this expression carries its value in its type. More... | |
struct | MutableExpression |
Something which may be change between different evaluations of an expression. More... | |
struct | SemiPositiveExpression |
Greater equal 0 expression. More... | |
struct | SemiNegativeExpression |
Less equal 0 expression. More... | |
struct | NonZeroExpression |
Complementary to ZeroExpression for use in std::conditional, for example, otherwise unused. More... | |
struct | RegularZeroExpression |
Non-singular, but somehow zero, whatever that means. 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 | PositiveExpression |
An expression which is known to be positive. More... | |
struct | NegativeExpression |
An expression which is known to be negative. 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 | 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 | 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, 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<!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< Constant< I, V > > |
Explicit expression traits for integer constants. More... | |
struct | IsIntegral |
TrueType if I is an integral type. More... | |
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 | FieldTraits |
Helper class for specializing Dune::FieldTraits. More... | |
struct | ExpressionTraits< Model, std::enable_if_t< IsPDEModel< Model >::value >, TraitsPriority::Secondary > |
Override default expression traits s.t. More... | |
struct | ModelBase |
A structure defining some basic default types and methods. 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 | UnaryFilterFunctor |
Filter-proxy for TransformSequence template alias. More... | |
struct | UnaryNotFunctor |
Negate a given unary functor. More... | |
struct | UnaryKeepAtFunctor |
Alternative: avoid bit-masks and use ContainsValue<> template. More... | |
struct | HasPropertyFunctor |
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 | TransformAtIndexFunctor |
Applies another functor only to the elements at the specified positions given by the Index parameter pack. More... | |
struct | AcceptEqualFunctor |
Functor for TransformSequence: accept if result is either equal or different from original value. More... | |
struct | IdentityFunctor |
Identity functor. More... | |
struct | MultiplyOffsetFunctor |
Multiply-offset functor. More... | |
struct | IndexFunctor |
Index functor. More... | |
struct | IsEvenFunctor |
Transform to bool sequence of even indices. More... | |
struct | IsOddFunctor |
Transform to bool sequence of even indices. More... | |
struct | AddBitFunctor |
Add given bit to all masks. More... | |
struct | AddBitShiftRightFunctor |
Add a set bit at right-shifted position. More... | |
struct | AddBitShiftLeftFunctor |
Add a set bit at left-shifted position. More... | |
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 | InverseMapSequenceFunctor |
Map a value to the index of the value in Values. More... | |
struct | AcceptAllFunctor |
Functor for TransformSequence: unconditionally accept. More... | |
struct | AcceptInputValueFunctor |
Accept if input-value is either equal or unequal to given value. More... | |
struct | AcceptInputInRangeFunctor |
Accept if input-value is in range of given bounds. More... | |
struct | AcceptModuloFunctor |
Accept if input-value MOD P = R. More... | |
class | BulkBlockConstraints |
A default implementation for bulk block constraints. 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 | 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, BoundaryValues, Indicator, std::enable_if_t<(HasEmptySupport< BoundaryValues >::value||IndicatorTraits< Indicator >::emptySupport)> > |
Spezialization of Dirichlet constraints for emptyboundaryindicator. More... | |
class | EmptyBlockConstraints |
A class modelling do-nothing constraints. More... | |
class | EllipticOperator |
A class defining an elliptic operator. More... | |
struct | RestrictionOperation |
AutoDiff operation. More... | |
struct | TransposeOperation |
Permutation of index positions of tensors. More... | |
struct | ReshapeOperation |
Signature of index positions of tensors. More... | |
struct | EinsumOperation |
Einstein summation, i.e. More... | |
struct | TensorProductOperation |
Component-wise product over given index-set. More... | |
struct | ExpressionTraits< Tensor::AutoDiffPlaceholder< Id, Signature, T, DT > > |
struct | OperationTraits< TransposeOperation< Perm > > |
Permutation of index positions of tensors. More... | |
struct | OperationTraits< ReshapeOperation< Sig > > |
Reshape a tensor to another signature. More... | |
struct | OperationTraits< EinsumOperation< Pos1, Pos2, Dims > > |
Einstein summation, i.e. More... | |
struct | OperationTraits< TensorProductOperation< Pos1, Pos2, Dims > > |
Component-wise product over given index-set. 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 |
template<class T > | |
using | remove_const_t = typename remove_const< T >::type |
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 > |
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, ... More... | |
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... >) |
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 constexpr std::size_t | 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 > &&) |
template<std::size_t... I> | |
constexpr auto | submaskSequence (IndexSequence< I... > &&) |
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 | |
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 | |
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
using Dune::ACFem::AreRuntimeSameExpressions = typedef Expressions::AreRuntimeEqual<T1, T2> |
◆ BaseExpressionTraits
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
using Dune::ACFem::IsRuntimeEqualExpression = typedef Expressions::IsRuntimeEqual<T> |
◆ LoadModel
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
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
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()
|
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]
|
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]
|
constexpr |
Runtime-dynamic version.
Runtime-dynamic version.