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

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  declval< T >())) >=0)> >
 TrueType if a T allows for the unary minus operator. 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  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  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  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  value &&(sizeof(T) >=0))> >
 TrueType if T is an object which is not a pointer. More...
 
struct  value >=0)> >
 Evaluate to true if T behaves more or less like a tuple. 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. More...
 
template<class GridPart >
using FaceLumpingQuadratureTraits = MaybeLumpingQuadratureTraits< GridPart, false, true >
 Traits class with lumping quadratures only on the skeleton. More...
 
template<class GridPart >
using QuadratureTraits = DefaultQuadratureTraits< GridPart >
 Traits class with ordinary quadratures in the bulk and on the skeleton. More...
 
template<class Quadrature >
using QuadraturePoint = Fem::QuadraturePointWrapper< Quadrature >
 Shortcut. More...
 
template<class T , T V>
using Constant = integral_constant< T, V >
 Short-cut for any integral constant. More...
 
template<std::size_t V>
using IndexConstant = Constant< std::size_t, V >
 Short-cut for integral constant of type std::size_t. More...
 
template<bool V>
using BoolConstant = Constant< bool, V >
 Short-cut for integral constant of type bool. More...
 
template<std::ptrdiff_t V>
using IntConstant = Constant< std::ptrdiff_t, V >
 Short-for integral constant of type std::p0trdiff_t. More...
 
template<class T , T... V>
using Sequence = std::integer_sequence< T, V... >
 Sequence of any type of integer values. More...
 
template<bool... Decisions>
using BoolSequence = Sequence< bool, Decisions... >
 Sequence of boolean values. More...
 
template<std::size_t... V>
using IndexSequence = Sequence< std::size_t, V... >
 Sequence of std::size_t values. More...
 
template<std::ptrdiff_t... V>
using IntSequence = Sequence< std::ptrdiff_t, V... >
 Sequence of std::ptrdiff_t values. More...
 
template<class Const >
using Incr = Constant< typename Const::value_type, Const::value+1 >
 Increment an integral_constant. More...
 
template<class Const >
using Decr = Constant< typename Const::value_type, Const::value - 1 >
 Decrement an integral_constant. More...
 
template<class T >
using IsDecay = std::is_same< T, std::decay_t< T > >
 true if T is its own decay type. More...
 
template<class T1 , class T2 >
using HasSameDecay = std::is_same< std::decay_t< T1 >, std::decay_t< T2 > >
 true if the decay types match. More...
 
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. More...
 
using FalseType = BoolConstant< false >
 Alias for std::false_type. More...
 
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. More...
 
template<class... T>
using FirstType = typename MakeType< T... >::Type
 Generate the first type of the template argument list. More...
 
template<class... Other>
using VoidType = typename MakeType< void, Other... >::Type
 Generate void regardless of the template argument list. More...
 
template<class... Other>
using AlwaysFalse = typename MakeType< FalseType, Other... >::Type
 Generate FalseType regardless of the template argument list. More...
 
template<class... Other>
using AlwaysTrue = typename MakeType< TrueType, Other... >::Type
 Generate TrueType regardless of the template argument list. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<class Model >
using ModelTraits = ModelIntrospection::Traits< Model >
 Traits class for models. More...
 
template<class Model , std::size_t tag>
using ModelHasMethod = typename ModelTraits< Model >::template HasMethod< ModelIntrospection::CheckMethodTag< tag >::value >
 Check for method. More...
 
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. More...
 
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. More...
 
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. More...
 
using ModelMethodClosureSignatures = ModelIntrospection::MethodSignaturesClosureType
 A sequence with the closure signatures for all methods. More...
 
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. More...
 
template<class Model , std::size_t tag>
using ModelClosureMethod = PDEModel::TaggedModelMethod< Model, tag, ModelIntrospection::MethodSignatureClosure< tag >::value >
 Exports from namespace. More...
 
template<class F , class Model >
using UnaryModelExpression = PDEModel::UnaryModelExpression< F, Model >
 Exports from namespace. More...
 
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. More...
 
template<std::size_t Cnt, class Seq >
using HeadPart = typename GetHeadPartHelper< Cnt, Seq >::Type
 Extract Cnt many consecutive elements from the front of Seq. More...
 
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. More...
 
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. More...
 
template<std::ptrdiff_t V, class Seq >
using PushFront = decltype(pushFront< V >(Seq{}))
 Add value to start of integer-sequence. More...
 
template<std::ptrdiff_t V, class Seq >
using PushBack = decltype(pushBack< V >(Seq{}))
 Add value to end of integer-sequence. More...
 
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. More...
 
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. More...
 
template<class T >
using IsIntegralTuple = decltype(isIntegralTuple(std::declval< T >()))
 Decide whether the given tuple contains only integral types. More...
 
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. More...
 
template<template< class... > class Predicate, class... T>
using AnyIs = BoolConstant<(...||Predicate< T >::value)>
 TrueType if any type matches the predicate. More...
 
template<template< class... > class Predicate, class... T>
using AllAre = BoolConstant<(... &&Predicate< T >::value)>
 TrueType if all types match the predicate. More...
 
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... More...
 
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. More...
 
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. More...
 
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. More...
 
template<std::size_t... I>
using SequenceMask = IndexConstant< SequenceMaskHelper< I... >::value >
 Generate a bit-mask from the given index-sequence. More...
 
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. More...
 
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. More...
 
template<class Permutation >
using InversePermutation = typename SortSequence< Permutation >::Permutation
 Compute the inverse of the given permutation. More...
 
template<class Permutation , std::size_t N>
using ResizedPermutation = typename ResizedPermutationHelper< Permutation, N >::Type
 Pad or truncate the permuation at the given size. More...
 
template<class Sequence , class Perm >
using PermuteSequenceValues = typename PermuteSequenceValuesHelper< Perm, Sequence >::Type
 Apply the given permutation to the values of the given sequence. More...
 
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. More...
 
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. More...
 
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. More...
 
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(). More...
 
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. More...
 
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. More...
 
template<class Tuple >
using TupleScalarPromotionType = typename ScalarTupleTypePromotionHelper< Tuple, MakeSequenceFor< Tuple > >::Type
 Generate the type resulting from summing up all tuple elements. More...
 
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. More...
 
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. More...
 
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  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>
decltype(auto) constexpr 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 >
decltype(auto) constexpr 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. More...
 
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. More...
 
template<bool I0, bool... I>
std::ostream & operator<< (std::ostream &out, BoolSequence< I0, I... >)
 Print bool-sequence. More...
 
template<class Quadrature >
decltype(auto) operator* (const QuadraturePoint< Quadrature > &qp)
 Forward Fem::QuadraturePointWrapper as is. More...
 
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. More...
 
constexpr auto falseType ()
 Generate a FalseType. More...
 
template<bool Cond>
constexpr auto boolType (BoolConstant< Cond > arg=BoolConstant< Cond >{})
 Generate a BoolConstant. More...
 
template<class T0 , class T1 >
constexpr auto forwardAsPair (T0 &&t0, T1 &&t1)
 Forward as pair capturing lvalue references. More...
 
template<class T >
constexpr T forwardReturnValue (std::remove_reference_t< T > &t)
 Forward lvalue-references as references. More...
 
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>
decltype(auto) constexpr floatingPointClosure (T &&t)
 Forward floating point arguments as is. More...
 
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>
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>
decltype(auto) constexpr get (T &&t, IndexConstant< I >=IndexConstant< I >{})
 Access to the i-the element. More...
 
template<std::size_t I, class T , std::size_t N, std::enable_if_t< std::is_integral< T >::value, int > = 0>
decltype(auto) constexpr get (const T(&t)[N], IndexConstant< I >=IndexConstant< I >{})
 Access to the i-the element. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<class T , std::size_t N>
constexpr auto isIntegralTuple (const std::array< T, N > &)
 Decide whether the given tuple contains only integral types. More...
 
template<class T1 , class T2 >
constexpr auto isIntegralTuple (const std::pair< T1, T2 > &)
 Decide whether the given tuple contains only integral types. More...
 
template<class... T>
constexpr auto isIntegralTuple (const std::tuple< T... > &)
 Decide whether the given tuple contains only integral types. More...
 
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. More...
 
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. More...
 
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. More...
 
template<std::size_t... I>
constexpr auto sequenceMask (const IndexSequence< I... > &)
 Generate a bit-mask from the given index-sequence. More...
 
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. More...
 
template<std::size_t... Indices, std::size_t... Dims>
constexpr auto flattenMultiIndex (IndexSequence< Dims... >, IndexSequence< Indices... >=IndexSequence< Indices... >{})
 Compile-time constant flatten routine. More...
 
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. More...
 
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. More...
 
template<std::size_t... Ps, class T , std::enable_if_t< IsTupleLike< T >::value &&isSimple(IndexSequence< Ps... >{}), int > = 0>
decltype(auto) constexpr permute (T &&t, IndexSequence< Ps... >=IndexSequence< Ps... >{})
 Permute the given tuple like. More...
 
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. 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, IndexSequence< Pos... >, BoolConstant< AssumeSorted >=BoolConstant< AssumeSorted >{})
 Insert-at variant with indices given by index-sequence argument. 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, IndexConstant< Where >, BoolConstant< AssumeSorted >=BoolConstant< AssumeSorted >{})
 Insert-at variant with indices given by index-constant argument. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<class T >
constexpr std::size_t size ()
 Gives the number of elements in tuple-likes and std::integer_sequence. More...
 
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>

◆ 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.

◆ BulkLumpingQuadratureTraits

template<class GridPart >
using Dune::ACFem::BulkLumpingQuadratureTraits = typedef MaybeLumpingQuadratureTraits<GridPart, true, false>

Traits class with lumping quadratures in the bulk but not on the skeleton.

◆ FaceLumpingQuadratureTraits

template<class GridPart >
using Dune::ACFem::FaceLumpingQuadratureTraits = typedef MaybeLumpingQuadratureTraits<GridPart, false, true>

Traits class with lumping quadratures only on the skeleton.

◆ FlattenMultiIndex

template<class Indices , class Dims >
using Dune::ACFem::FlattenMultiIndex = typedef IndexConstant<flattenMultiIndex(Dims{}, Indices{})>

Compute the index of the given multi-index in the tuple of all indices.

◆ IsPDEModel

template<class Model >
using Dune::ACFem::IsPDEModel = typedef ModelIntrospection::template IsModel<Model>

std::true_type if Model is derived from ModelBase.

◆ 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.

◆ ModelAdmissibleMethods

A sequence with the tags of all possible model-methods.

◆ ModelHasMethod

template<class Model , std::size_t tag>
using Dune::ACFem::ModelHasMethod = typedef typename ModelTraits<Model>::template HasMethod<ModelIntrospection::CheckMethodTag<tag>::value>

Check for method.

◆ ModelMethodClosureSignatures

A sequence with the closure signatures for all methods.

◆ ModelMethodExists

template<class Model , std::size_t tag>
using Dune::ACFem::ModelMethodExists = typedef typename ModelTraits<Model>::template Exists<ModelIntrospection::CheckMethodTag<tag>::value>

Check for either non-linear or linearized method.

◆ ModelMethodSignature

template<class Model , std::size_t tag>
using Dune::ACFem::ModelMethodSignature = typedef typename ModelTraits<Model>::template CallSignature<ModelIntrospection::CheckMethodTag<tag>::value>

Call signature for given model and method.

◆ ModelTraits

template<class Model >
using Dune::ACFem::ModelTraits = typedef ModelIntrospection::Traits<Model>

Traits class for models.

◆ 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.

◆ QuadraturePoint

template<class Quadrature >
using Dune::ACFem::QuadraturePoint = typedef Fem::QuadraturePointWrapper<Quadrature>

Shortcut.

◆ QuadratureTraits

template<class GridPart >
using Dune::ACFem::QuadratureTraits = typedef DefaultQuadratureTraits<GridPart>

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

◆ UnknownExpressionSign

using Dune::ACFem::UnknownExpressionSign = typedef ExpressionSign<false, false, false>

Sign traits structure with names matching the expression tag structs.

Function Documentation

◆ flattenMultiIndex() [1/2]

template<class Dims , std::size_t N, std::enable_if_t< Dims::size()==N, int > = 0>
constexpr std::size_t Dune::ACFem::flattenMultiIndex ( Dims  ,
const std::array< std::size_t, N > &  indices 
)

◆ flattenMultiIndex() [2/2]

template<std::size_t... Indices, std::size_t... Dims>
constexpr auto Dune::ACFem::flattenMultiIndex ( IndexSequence< Dims... >  ,
IndexSequence< Indices... >  = IndexSequence<Indices...>{} 
)

Compile-time constant flatten routine.

◆ floatingPointClosure()

template<class T , std::enable_if_t< std::is_same< FloatingPointClosure< std::decay_t< T > >, std::decay_t< T > >::value, int > = 0>
decltype(auto) constexpr Dune::ACFem::floatingPointClosure ( T &&  t)

Forward floating point arguments as is.

◆ multiDim()

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

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>{} 
)

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::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... >   
)

Runtime-dynamic version.

Runtime-dynamic version.

◆ operator*()

template<class Quadrature >
decltype(auto) Dune::ACFem::operator* ( const QuadraturePoint< Quadrature > &  qp)

Forward Fem::QuadraturePointWrapper as is.

◆ permute()

template<std::size_t... Ps, class T , std::enable_if_t< IsTupleLike< T >::value &&isSimple(IndexSequence< Ps... >{}), int > = 0>
decltype(auto) constexpr Dune::ACFem::permute ( T &&  t,
IndexSequence< Ps... >  = IndexSequence<Ps...>{} 
)

Permute the given tuple like.

Creative Commons License   |  Legal Statements / Impressum  |  generated with Hugo v0.55.6 (Oct 15, 22:23, 2019)