▼NDune | |
►NACFem | A namespace encapsulating everything defined in our dune-acfem project |
►NBoundaryIndicator | |
CAreProperOperands | |
CBoundaryIdIndicator | Apply to boundary segments which carry the respective id |
CBoundaryIndicator | Boundary indicators need to inherit this tag-class in order to signal that they are boundary indicators |
CComplement | Turn any boundary-indicator into its complement |
CIndicatorTraits | Paraphrase isOne and isZero to indicator function talk |
CIntersectionIndicator | Intersection of two indicators, apply iff both apply |
CIsIndicator | TrueType if T is a BoundaryIndicator |
CUnionIndicator | Union of two indicators, apply to the union of both boundary parts |
►NExpressions | |
►NExamineImpl | |
CDepthFunctor | |
►CFunctorFactory | |
CAccumulate | Just accumulate all values, F must accept the expression as first template parameter |
CRecurse | Feed the accumulated values for the operands back into F |
►Nimpl | |
CEvaluateSubExpression | Operation functor for transform() which evaluates all contained sub-expressions |
►NSums | |
CAddNodesHelper | |
CAddNodesHelper< OptimizeTag, Left, Right, std::enable_if_t< FunctorHas< IsMinusOperation, typename Left::Sign >::value > > | |
CIsExplodeOperand | |
CProcessExplodeHelper | |
CReplaceByMinimum | |
CAreRuntimeEqual | FalseType by default |
CAreRuntimeEqual< T1, T2, std::enable_if_t<(!IsSubExpressionExpression< T1 >::value &&!IsSubExpressionExpression< T2 >::value &&(!IsRuntimeEqual< T2 >::value||!IsRuntimeEqual< T1 >::value))> > | Decide whether to consider object of the given types as equal at runtime, although their actual value may not be constant |
CAreRuntimeEqual< T1, T2, std::enable_if_t<(IsExponentiationExpression< T1 >::value &&IsExponentiationExpression< T2 >::value &&std::is_same< BaseOfPower< T1 >, BaseOfPower< T2 > >::value &&ExponentOfPower< T1 >::value==ExponentOfPower< T2 >::value)> > | Identify the various flavours of drawing powers |
CAreRuntimeEqual< T1, T2, std::enable_if_t<(IsSubExpressionExpression< T1 >::value &&IsSubExpressionExpression< T2 >::value)> > | FalseType by default |
CClosureTraits | Provide the type ExpressionType for non-closure expressions |
CClosureTraits< T, std::enable_if_t< IsClosure< T >::value > > | Provide the type ExpressionType for closure expressions |
CCommonSubExpressionCascade | Wrap tuple of subexpressions with constant references to sub-expressions of lower levels |
CCommonSubExpressionCascade< Traits, std::tuple< std::tuple< SExp... >, PrevSExp, SExpRest... > > | Recurse to less deep subexpressions |
CCommonSubExpressionCascade< Traits, std::tuple< std::tuple<> > > | Terminal in template recursion |
CContainsPlaceholders | Yields std::true_type if the expression E contains placeholders |
CDefaultTerminalPredicate | |
CDenseStorage | A traits class which provides a type suitable to store the values of the given expression T and any expressions of "similar" type |
CDontOperate | Operation functor which does not operate and collapes the entire expression to a dummy return value of int 0 |
CExpressionSign | A class mainting the sign of an expression during operations |
CExtractDataDefaultFunctor | Default pack-data functor |
CInjectionTraits | Traits class in order to inject general object into the expression chain in a controlled manner |
CIsBasicRuntimeEqual< T, std::enable_if_t< IsSubExpressionExpression< T >::value > > | SubExpressionOperation expressions qualify for IsRuntimeEqual if the contained sub-expression qualifies |
CIsBinaryExpression | TrueType if T is an expression of arity 2, otherwise FalseType |
CIsClosure | An expression closure is a wrapper class which wraps an expression in order to interface to other existing interface |
CIsClosure< T, std::enable_if_t<!IsDecay< T >::value > > | Forward references to the real traits class |
CIsClosure< T, std::enable_if_t<(IsDecay< T >::value &&IsPDEModel< T >::value &&IsUnaryExpression< T >::value &&!IsSelfExpression< T >::value)> > | Identify the expression closure |
CIsClosure< Tensor::TensorResult< T > > | Mark TensorResult as a closure expression |
CIsCSECascade | |
CIsCSECascade< CommonSubExpressionCascade< Traits, DepthTuple > > | Identity CommonSubExpressionCascade objects |
CIsCSECascade< T, std::enable_if_t<!IsDecay< T >::value > > | |
CIsExpression< T, VoidType< void, decltype(std::decay_t< T >::arity()) > > | Identify something conforming to the expression interface |
CIsExpressionOfArity | TrueType if T is an expression of arity N, otherwise FalseType |
CIsMatchingSubExpression | |
CIsMatchingSubExpression< T, SExp, std::enable_if_t<(IsSubExpressionExpression< T >::value &&AreRuntimeEqual< Operand< 1, T >, Operand< 1, SExp > >::value)> > | Needed to replace references to sub-expression during copy and move construction of the CommonSubExpressionCascade |
CIsOperand | |
CIsOperand< T, std::enable_if_t<!IsDecay< T >::value > > | |
CIsOperand< T, std::enable_if_t<(IsExpression< T >::value &&IsDecay< T >::value)> > | |
CIsSelfExpression | Identify self-contained terminals, see SelfExpression |
CIsUnaryExpression | TrueType if T is an expression of arity 1, otherwise FalseType |
COperate | Default operation functor for transform |
COperateClone | Operation functor for transform() |
COperateDecay | Operation functor for transform() |
COperationPair | Collect sign, operation and data-types of the operands for a binary operation |
COperationPair< S, F, MPL::TypeTuple< TreeData0... >, TreeData1, OptimizeTag > | An operations pair for collecting tuples of operands subject to the same operation as left operand with a single right operand |
COperationPair< S, F, TreeData0, MPL::TypeTuple< TreeData1... >, OptimizeTag > | An operations pair for collecting tuples of operands subject to the same operation as right operand with a single left operand |
COptimizeTag | Optimization pattern disambiguation struct |
CReplaceByOperand | Replace matching expressions by their operand no |
CReplaceDefaultIgnore | |
CReplaceFunctor | Replace all expression operands of type T where When<T, From> is std::true_type by an instance of To |
CSameOperandFunctors | @interal SFINAE default for examining the functors of operands when we do not know whether T has sufficiently many operands |
CSameOperandFunctors< T, std::enable_if_t< IsUnaryExpression< T >::value > > | |
CSameOperandFunctors< T, std::enable_if_t<(IsBinaryExpression< T >::value &&std::is_same< Functor< Operand< 0, T > >, Functor< Operand< 1, T > > >::value)> > | |
CSameOperandFunctors< T, std::enable_if_t<(IsExpression< T >::value &&Arity< T >::value > 2)> > | |
CSelfExpression | Terminals may derive from this class to express that they are expressions |
CSimpleReplaceFunctor | Variant o ReplaceFunctor where When may be a simple unary IsSomething trait |
CTraitsOfTags | Deduce ExpressionTraits from tag-class overrides |
CTraverseFunctor | |
CTreeData | Collect type, sign and the position in an expression of one operand |
►NGridFunction | |
CBindableTensorFunction | Wrap a tensor into a Fem::BindableGridFunction |
CElementMeasurePlaceholder | A placeholder tensor which evaluates to the measure of the element after binding it |
CHasBind< Placeholder, VoidType< decltype(std::declval< Placeholder >().bind(std::declval< typename std::decay_t< Placeholder >::EntityType >()))> > | |
CHasGridPartMethod | |
CHasGridPartMethod< T, VoidType< decltype(std::declval< T >().gridPart())> > | TrueType if a T has a gridPart() method |
CHasIndeterminateSetValue< Placeholder, VoidType< decltype(std::declval< Placeholder >().setValue(std::declval< typename std::decay_t< Placeholder >::IndeterminateType >()))> > | |
CHasRangeType | |
CHasRangeType< T, VoidType< typename std::decay_t< T >::RangeType > > | TrueType if T provides a RangeType |
CHasRegularity | |
CHasRegularity< BindableTensorFunction< Expr, GridPart, AutoDiffOrder, IndeterminateId >, AtLeastRequestedOrder, AtMostRequestedOrder > | Evaluate to TrueType if the given BindableTensorFunction fufils the regularity requirements given by the "box
constaints" AtLeastRequestedOrder and AtMostRequestedOrder |
CHasSetValue< Placeholder, VoidType< decltype(std::declval< Placeholder >().setValue(std::declval< PlaceholderQuadraturePoint< typename std::decay_t< Placeholder >::DomainType > >())) > > | |
CHasUnbind< Placeholder, VoidType< decltype(std::declval< Placeholder >().unbind())> > | |
CIsConstLocalFunction | |
CIsConstLocalFunction< T, std::enable_if_t<!IsDecay< T >{}> > | |
CIsConstLocalFunction< T, std::enable_if_t<(IsDecay< T >{} &&std::is_same< T, Fem::ConstLocalFunction< typename T::GridFunctionType > >{})> > | TrueType if a T can be wrapped into a Fem::ConstLocalFunction |
CIsConstLocalFunctionOperand | TrueType if T can be passed through constLocalFunction() |
CIsLocalFunction | |
CIsLocalFunction< T, std::enable_if_t<!IsDecay< T >{}> > | @intenal Forward to decay_t<> |
CIsLocalFunction< T, std::enable_if_t<(IsDecay< T >{} &&std::is_same< void, decltype(std::declval< T >().bind(std::declval< typename T::EntityType >()))>{} &&std::is_same< void, decltype(std::declval< T >().evaluate(std::declval< PlaceholderQuadraturePoint< typename T::DomainType > >(), std::declval< typename T::RangeType & >()))>{})> > | Identify a Fem::LocalFunction |
CIsLocalFunctionPlaceholder | Std::true_type if T is a LocalFunctionPlaceholder |
CIsTensorFunction | |
CIsTensorFunction< BindableTensorFunction< Expr, GridPart, AutoDiffOrder, IndeterminateId > > | Identify a BindableTensorFunction |
CIsTensorFunction< T & > | |
CIsTensorFunction< T && > | |
CIsWrappableByConstLocalFunction | |
CIsWrappableByConstLocalFunction< T, std::enable_if_t<!IsDecay< T >{}> > | |
CIsWrappableByConstLocalFunction< T, std::enable_if_t<(IsDecay< T >{} &&std::is_base_of< Fem::HasLocalFunction, T >{})> > | TrueType if a T can be wrapped into a Fem::ConstLocalFunction |
CLocalFunctionPlaceholder | A placeholder tensor which wraps a Dune::Fem LocalFunction |
CModelDirichletValues | An adapter class which takes any ACFem-PDE model and extracts its Dirichlet values as a BoundarySupportedFunction |
CPromoteAllFunctionOperands | |
CPromoteFunctionOperands | |
CPromoteTensorOperands | |
►NLinearFunctional | |
CBinaryLinearFunctionalExpression | The one and only one binary expression |
CDiracDistribution | Dirac-distribution |
CDofStorageFunctional | A functional which inherits from a proper discrete function |
CLinearFunctional | Light-weight base class for all linear functionals |
COperatorFunctional | Convert any operator into a functional by fixing |
CUnaryLinearFunctionalExpression< MinusOperation, T > | The one and only one unary expression |
CZeroFunctional | The zero functional |
►NModelIntrospection | Deduce methods and call-signatures from an implemented model |
CArgumentMask | Integral constant holding an argument mask |
CIsModel< Model, std::enable_if_t<(IsDecay< Model >::value &&std::is_base_of< ModelBase< typename Model::DomainFunctionSpaceType, typename Model::RangeFunctionSpaceType >, Model >::value)> > | Std::true_type if Model is derived from ModelBase |
►CTraits< Model, std::enable_if_t< IsModel< Model >::value &&IsDecay< Model >::value > > | Traits class extracting structural information from a given PDE-model information |
CExistsFunctor | Helper functor for global property |
CIsAffineLinearFunctor | Helper functor for global property |
CIsLinearFunctor | Helper functor for global property |
CIsLoadFunctor | Helper functor for global property |
CIsPiecewiseConstantFunctor | Helper functor for global property |
►NParameter | |
CGeneric | A placeholder tensor which can be initialized in particular by a Fem::Parameter value |
►NPDEModel | |
CApplyOperation | Apply a model to a function |
CBinaryModelExpression< SMultiplyOperation, Left, Right, IndexSequence< tag... >, std::enable_if_t<(IsTensor< Left >::value &&TensorTraits< Left >::rank==0 &&IsPDEModel< Right >::value)> > | Binary model expression for S-multiplication with tensors |
CBinaryModelExpression< SMultiplyOperation, Left, Right, IndexSequence< tag... >, std::enable_if_t<(IsWrappableByConstLocalFunction< Left >::value &&std::decay_t< Left >::FunctionSpaceType::dimRange==1 &&IsPDEModel< Right >::value)> > | Binary model expression for S-multiplication with functions |
CBinaryModelMethods< ApplyOperation< L2LoadFlavour >, Model, Function > | Call the fluxDivergence inside the source() method and do not provide a flux() or fluxDivergence() method |
CBinaryModelMethods< ApplyOperation< RitzLoadFlavour >, Model, Function > | Just provide all methods implemented by the model |
CBulkLoadFunctionModel | Wrap an existing GridFunction into a model which only conatains this ModelConstituent |
CClosureOperation | Augment the call signature of the methods listed in MethodTags by the call-signature indicated by the bit-masks in ClosureCallSignatures |
CCropOperation | Remove all methods which are not listed in MethodTags |
CDeformationTensorModel | Define the a model where the flux-part is formed from the symmetric gradient |
CDirichletIndicator | A wrapper which constructs from the given model a Dirichlet boundary indicator, using Model::classifyBoundary |
CDivergenceLoadModel | For a given grid-function define a model implementing the weak divergence |
CDivergenceModel | A divergence model, for example to implement divergence constraints |
CFluidSelfTransportModel | Define a model for the "Navier-Stokes" non-lineariry |
CGradientLoadModel | For a given grid-function define a model implementing the weak gradient |
CGradientModel | A gradient model, for example to implement gradient constraints |
CIncompressibleSelfTransportModel | Define a model for the "Navier-Stokes" non-lineariry |
CIncompressibleTransportModel | Define a model for an advection term with a divergence-free velocity field |
CLaplacianModel | Define a simple Laplacian-model, given function-space and grid-part |
CMassModel | Define a simple mass-model, given function-space and grid-part |
CMeanCurvatureModel | Define a mean-curvature model for graphs and level-sets |
CModelFacade | A class defining the "closure" type of all supported model-method and method-call-signatures |
CModelMethod | Implement the method specified by tag with the signature defined by OuterArgSeq |
CModelMethod< Model, F, flux, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< flux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, flux, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< flux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, flux, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< flux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, flux, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< flux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, fluxDivergence, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< fluxDivergence >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, fluxDivergence, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< fluxDivergence >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, fluxDivergence, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< fluxDivergence >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, fluxDivergence, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< fluxDivergence >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedDirichlet, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedDirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedDirichlet, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedDirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedDirichlet, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedDirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedDirichlet, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedDirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedFlux, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedFlux, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedFlux, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedFlux, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedRobinFlux, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedRobinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedRobinFlux, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedRobinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedRobinFlux, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedRobinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedRobinFlux, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedRobinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedSingularFlux, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedSingularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedSingularFlux, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedSingularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedSingularFlux, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedSingularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedSingularFlux, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedSingularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedSource, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedSource >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedSource, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedSource >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedSource, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedSource >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, linearizedSource, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedSource >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, ModelIntrospection::dirichlet, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< ModelIntrospection::dirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, ModelIntrospection::dirichlet, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< ModelIntrospection::dirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, ModelIntrospection::dirichlet, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< ModelIntrospection::dirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, ModelIntrospection::dirichlet, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< ModelIntrospection::dirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, robinFlux, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< robinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, robinFlux, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< robinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, robinFlux, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< robinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, robinFlux, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< robinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, singularFlux, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< singularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, singularFlux, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< singularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, singularFlux, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< singularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, singularFlux, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< singularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, source, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< source >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, source, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< source >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, source, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< source >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CModelMethod< Model, F, source, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< source >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
CNeumannBoundaryModel | A Neumann-boundary model |
CNitscheDirichletBoundaryModel | This model constructs from a given other model weak Dirichlet conditions as first introduced by [2] |
CP_LaplacianModel | The p-Laplacian-model |
CP_MassModel | A simplistic non-linear example |
CRangeTensorTraits | TensorTraits for the RangeType of a model, keeping scalar decay of 1d vectors into account |
CRobinBoundaryModel | A (homogeneous) Robin-boundary model |
CRobinIndicator | A wrapper which constructs from the given model a Robin boundary indicator, using Model::classifyBoundary |
CSymmetricModel | Tag structure identifying symmetric models |
CTransportModel | Define a model for an advection term |
CUnaryModelExpression | General unary model expression template |
CUnaryModelExpression< F, Model, IndexSequence< tag... >, Signatures > | Index-pack expansion helper and actual implementation |
CWeakDivergenceLoadModel | For a given grid-function define a model implementing the weak divergence |
CZeroModel | Define a simple zero model to optimize expression templates |
►NTensor | |
►NOptimization | |
►NAssociativity | |
CIsLeftAssociativeProduct | Check for A*(B*C) -> (A*B)*C |
CIsLeftAssociativeProductFinal | Check for A*(B*C) -> (A*B)*C |
CIsRightAssociativeProduct | Check for (A*B)*C -> A*(B*C) |
CLeftAssociatedTypeHelper | TrueType is the operation can be optimized by associating the double product left, i.e |
►NDistributivity | |
►NLeft | |
CCollectOperands | |
CCollectOperands< T, PrevOps, std::enable_if_t<!IsPositiveTreeNodeV< T > > > | |
CFactorOutHelper | |
CFactorOutHelper< MPL::TypeTuple< Scalars... >, MPL::TypeTuple< NonScalars... >, MPL::TypeTuple< Done... > > | |
CFactorOutHelper< MPL::TypeTuple< Todo... >, void, void > | |
CFactorOutHelper< void, MPL::TypeTuple< Todo... >, void > | Variant where we know that Todo does not contain scalar factor tuples |
CFactorOutNonScalar | |
CFactorOutNonScalar< T0, MPL::TypeTuple<>, MinusOperands > | |
CFactorOutScalar | |
CFactorOutScalar< MPL::TypeTuple< OperationPair< MinusFunctor, ScalarEinsumFunctor, Node0, Node1, Tag >, T... >, LeftFactor, PlusOperands, MinusOperands, Rem, std::enable_if_t< MPL::HasMatchingTypeV< LeftFactor, Node0, Einsum::Unequal > > > | |
CFactorOutScalar< MPL::TypeTuple< OperationPair< PlusFunctor, ScalarEinsumFunctor, Node0, Node1, Tag >, T... >, LeftFactor, PlusOperands, MinusOperands, Rem, std::enable_if_t< MPL::HasMatchingTypeV< LeftFactor, Node0, Einsum::Unequal > > > | |
CFactorOutScalar< MPL::TypeTuple< T0, T... >, LeftFactor, PlusOperands, MinusOperands, Rem, std::enable_if_t<!MPL::HasMatchingTypeV< LeftFactor, typename T0::TreeNode0, Einsum::Unequal > > > | |
CFactorOutScalar< MPL::TypeTuple<>, LeftFactor, MPL::TypeTuple<>, MinusOperands, Rem > | |
CFactorOutScalar< MPL::TypeTuple<>, LeftFactor, PlusOperands, MinusOperands, Rem > | |
CFactorSwap | |
CFactorSwap< A, B, std::enable_if_t<(!HasEinsumFunctorV< A > &&HasEinsumFunctorV< B >)> > | |
CFactorSwap< A, B, std::enable_if_t<(HasEinsumFunctorV< A >==HasEinsumFunctorV< B > &&LexCompareProductOperationsV< typename A::FunctorType, typename B::FunctorType > > 0)> > | |
CNonScalarRecursion< OperationPair< Sign, F, TreeData0, MPL::TypeTuple< TreeData1... >, Tag > > | |
CProcessNonScalars< MPL::TypeTuple< T0 >, void > | |
CProcessNonScalars< MPL::TypeTuple< T0, T... >, MPL::TypeWrapper< Factor >, std::enable_if_t< AreMatchingNonScalarsV< Factor, T0 > > > | |
CProcessNonScalars< MPL::TypeTuple< T0, T... >, MPL::TypeWrapper< Factor >, std::enable_if_t<!AreMatchingNonScalarsV< Factor, T0 > > > | |
CProcessNonScalars< MPL::TypeTuple< T0, T1, T... >, std::enable_if_t<!AreMatchingNonScalarsV< T0, T1 > > > | |
CProcessNonScalars< MPL::TypeTuple< T0, T1, T... >, void, std::enable_if_t< AreMatchingNonScalarsV< T0, T1 > > > | |
CProcessNonScalars< MPL::TypeTuple<>, Factor > | |
CProcessScalars | |
CProcessScalars< T, Factor, std::enable_if_t<(Factor::First::value > 1)> > | |
CScalarRecursion< OperationPair< Sign, F, TreeData0, MPL::TypeTuple< TreeData1... >, Tag > > | |
►NRight | |
CCollectOperands | |
CCollectOperands< T, PrevOps, std::enable_if_t<!IsPositiveTreeNodeV< T > > > | |
CFactorOutCandidate | |
CFactorOutCandidate< T0, MPL::TypeTuple<>, MinusOperands > | |
CFactorOutHelper | |
CFactorOutHelper< MPL::TypeTuple< Factorizations... >, MPL::TypeTuple< Done... > > | |
CFactorSwap | |
CFactorSwap< A, B, std::enable_if_t<(!HasEinsumFunctorV< A > &&HasEinsumFunctorV< B >)> > | |
CFactorSwap< A, B, std::enable_if_t<(HasEinsumFunctorV< A >==HasEinsumFunctorV< B > &&LexCompareProductOperationsV< typename A::FunctorType, typename B::FunctorType > > 0)> > | |
CProcessCandidates< MPL::TypeTuple< T0 >, void > | |
CProcessCandidates< MPL::TypeTuple< T0, T... >, MPL::TypeWrapper< Factor >, std::enable_if_t< AreMatchingCandidatesV< Factor, T0 > > > | |
CProcessCandidates< MPL::TypeTuple< T0, T... >, MPL::TypeWrapper< Factor >, std::enable_if_t<!AreMatchingCandidatesV< Factor, T0 > > > | |
CProcessCandidates< MPL::TypeTuple< T0, T1, T... >, void, std::enable_if_t< AreMatchingCandidatesV< T0, T1 > > > | |
CProcessCandidates< MPL::TypeTuple< T0, T1, T... >, void, std::enable_if_t<!AreMatchingCandidatesV< T0, T1 > > > | |
CProcessCandidates< MPL::TypeTuple<>, Factor > | |
CRecursion | |
CRecursion< OperationPair< Sign, F, MPL::TypeTuple< TreeData0... >, TreeData1, Tag > > | |
►NEinsum | |
CIsMiddleScalarNestedEinsum | |
CIsMiddleScalarNestedEinsum< OperationTraits< EinsumOperation< Seq0, Seq1, Dims > >, T0, T1, std::enable_if_t<(IsEinsumExpression< T1 >::value &&(TensorTraits< T0 >::rank > 0) &&(TensorTraits< T1 >::rank > 0) &&TensorTraits< Operand< 0, T1 > >::rank==0)> > | |
►NSums | |
CExplodeProduct | |
CIsDistributiveOperation | True for expressions which can be moved inside or outside of sums |
COperateHelper< Sign, F, Node0, Node1, std::enable_if_t<(IsUndecomposableScalarV< Node0 > &&IsUndecomposableScalarV< Node1 > &&!IsOnesNodeV< Node0 > &&!IsOnesNodeV< Node1 >)> > | ! |
COperateHelper< Sign, F, OperationPair< Sign0, ProdF, MPL::TypeTuple< E00... >, E01, ExplodeTag >, OperationPair< Sign1, ProdF, MPL::TypeTuple< E10... >, E11, ExplodeTag > > | |
COperateHelper< Sign, ScalarEinsumFunctor, MPL::TypeTuple< Node... >, OnesNode< OnesSign > > | Keep ones as placeholder to the right of tuples of scalar factors |
COperateHelper< Sign, ScalarEinsumFunctor, Node, OnesNode< OnesSign > > | |
COperateHelper< Sign, ScalarEinsumFunctor, Node0, Node1, std::enable_if_t<(IsUndecomposableScalarV< Node0 > &&!IsOnesNodeV< Node0 > &&!IsUndecomposableScalarV< Node1 > &&!IsScalarFactorizationV< Node1 >)> > | |
COperateHelper< Sign, ScalarEinsumFunctor, Node0, OperationPair< Sign1, ScalarEinsumFunctor, E10, E11, ExplodeTag >, std::enable_if_t<(IsUndecomposableScalarV< Node0 > &&IsUndecomposableScalarV< E10 >)> > | ! |
COperateHelper< Sign, ScalarEinsumFunctor, OnesNode< OnesSign >, Node > | |
COperateHelper< Sign, ScalarEinsumFunctor, OperationPair< Sign0, ScalarEinsumFunctor, MPL::TypeTuple< E0... >, OnesNode<>, ExplodeTag >, TreeNode1, std::enable_if_t<(TensorTraits< TreeExpression< TreeNode1 > >::rank > 0)> > | |
COperateHelper< Sign, ScalarEinsumFunctor, OperationPair< Sign0, ScalarEinsumFunctor, MPL::TypeTuple< E00... >, E01, ExplodeTag >, OperationPair< Sign1, ScalarEinsumFunctor, E10, E11, ExplodeTag >, std::enable_if_t< IsUndecomposableScalarV< E10 > > > | |
COperateHelper< Sign, ScalarEinsumFunctor, OperationPair< Sign0, ScalarEinsumFunctor, MPL::TypeTuple< E00... >, E01, ExplodeTag >, TreeNode1, std::enable_if_t< IsUndecomposableScalarV< TreeNode1 > > > | |
COperateHelper< Sign, ScalarEinsumFunctor, TreeNode0, OperationPair< Sign1, ScalarEinsumFunctor, MPL::TypeTuple< E1... >, OnesNode<>, ExplodeTag >, std::enable_if_t<(TensorTraits< TreeExpression< TreeNode0 > >::rank > 0)> > | |
COperateHelper< Sign, ScalarEinsumFunctor, TreeNode0, OperationPair< Sign1, ScalarEinsumFunctor, MPL::TypeTuple< E10... >, E11, ExplodeTag >, std::enable_if_t< IsUndecomposableScalarV< TreeNode0 > > > | |
CProcessExplodeHelper | |
CProcessExplodeHelper< F, E, TreePos, Tuple0, Tuple1 > | |
CProcessSumOperands | Hook into the innermost operand tuple of the factor out code |
CReassembleProductHelper< OperationPair< Sign, ScalarEinsumFunctor, MPL::TypeTuple< Left >, OnesNode<>, Tag > > | |
CReassembleProductHelper< OperationPair< Sign, ScalarEinsumFunctor, MPL::TypeTuple< Left >, Right, Tag > > | |
CReassembleProductHelper< OperationPair< Sign, ScalarEinsumFunctor, MPL::TypeTuple< Left0, Left1, Left... >, Right, Tag > > | |
►NTranspose | |
CEinsumCommutationHelper | |
CIsTransposeOfEinsumWithRightEye | |
►NProductOperations | |
CIsLeftAssociative | |
CIsLeftAssociative< OperationTraits< EinsumOperation< Seq0, Seq1, Dims > >, T0, T1 > | TrueType if T can be associated left (i.e |
CIsRightAssociative< OperationTraits< EinsumOperation< Seq0, Seq1, Dims > >, T0, T1 > | TrueType if F(T0, T1) forms a triple-product that can be associated right from (A*B)*C to A*(B*C) |
CTreeFactorOutLeftHelper | Default case: TreeData is already associated to the right and not a simple TreeData |
CTreeFactorOutLeftHelper< OperationPair< Sign, InnerF, TreeData0, TreeData1, OptimizeTag >, std::enable_if_t< IsRightAssociative< InnerF, TreeData0, TreeData1 >::value > > | |
CTreeFactorOutLeftHelper< TreeData< S, E, Pos > > | Blow-up a simple TreeData by adding a scalar one node at the right |
CTreeFactorOutRightHelper | Default case: TreeData is already associated to the left and not a simple TreeData |
CTreeFactorOutRightHelper< OperationPair< Sign, InnerF, TreeData0, TreeData1, OptimizeTag >, std::enable_if_t< IsLeftAssociative< InnerF, TreeData0, TreeData1 >::value > > | |
CTreeFactorOutRightHelper< TreeData< S, E, Pos > > | Blow-up a simple TreeData by adding a scalar one node at the left |
CAreBinaryTensorOperands | |
CAreBinaryTensorOperands< T1, T2, std::enable_if_t<(!(IsClosure< T1 >::value||IsClosure< T2 >::value) &&IsTensorOperand< T1 >::value &&IsTensorOperand< T2 >::value &&(IsTensor< T1 >::value||IsTensor< T2 >::value))> > | |
CAreBinaryTensorOperands< T1, T2, std::enable_if_t<(IsFieldObject< T1 >::value &&IsFieldObject< T2 >::value &&IsUnaryTensorOperand< T1 >::value &&IsUnaryTensorOperand< T2 >::value)> > | Declare that non-trivial field-objects (non-scalars) qualify as binary tensor arguments, even if both operands are not yet wrapped into their tensor cloths |
CAreRuntimeComparable | |
CBlockEye< BlockRank, Seq< Dimensions... >, Field > | "Identity" block tensor formed of BlockRank many copies of BlockSignature multi-indices |
CConstantTensor< Field, Seq< Dimensions... > > | A tensor where all elements evaluate to the same constant value |
CDenseMatrixAssigner | |
CDenseVectorView | |
CDenseVectorView< T, Storage, 0, 0 > | Specialize for scalars and just cast to the field type |
CDenseVectorView< T, Storage, 1, 1 > | Start of the affair |
CDenseVectorView< T, Storage, 1, Rank, std::enable_if_t< Rank !=1 > > | Storage provider, downcast end-point |
CDenseVectorView< T, Storage, N, N, std::enable_if_t< N >=2 > | Start of the affair |
CDenseVectorViewElement | |
CDenseVectorViewElement< T, Storage, 1, Rank > | Recursion endpoint for elements |
CDerivativeTraits< IndeterminateOperation< Id > > | |
CDerivativeTraits< ReciprocalOperation > | Derivative expression for component wise invert operation |
CDerivativeTraits< RestrictionOperation< Positions, Indices > > | Compile-time constant variant |
CDerivativeTraits< RestrictionOperation< Tensor::Seq< Dims... >, Tensor::Seq<> > > | Runtime-dynamic variant |
CEinsteinSummation | Contraction of two tensor over a selection set of indices |
CEvalSExpFAD< OperateFAD< Evaluate, Seq< Id... >, Signature... > > | Functor implementation for evaluateSubExpression() which does forward autodiff |
CEye< Seq< Dimensions... >, Field > | "Identity" tensor: evaluates to 1 if all indices are the same, to 0 else |
CHasSpecializedExpressionTraits | Should be specialized to TrueType if for a specific tensor ExpressionTraits need to be re-implemented |
CIsBlockEye< BlockEye< BlockRank, BlockSignature, Field > > | Identity a non-empty BlockEye |
CIsComponentWiseOperation< T, std::enable_if_t<(IsReshapeOperation< T >::value||IsTransposeOperation< T >::value||IsRestrictionOperation< T >::value||IsProductOperation< T >::value)> > | Products, restrictions and transpositions do not act componentwise |
CIsConstKroneckerDelta< KroneckerDelta< Seq< Pos... >, Seq< Pivot... >, Field > > | Evaluate to a true type if the projection is compile-time constant |
CIsConstRestriction< Restriction< T, Pos, Pivots >, std::enable_if_t< Pos::size()==Pivots::size()> > | Evaluate to a TrueType if the restriction is compile-time constant |
CIsDynamicRestriction< Restriction< T, Seq< P0, PRest... >, Seq<> > > | Evaluate to a TrueType if the restriction is runtime dynamic |
CIsKroneckerDelta | Traits in order to identify a Projection class |
CIsMatchingAutoDiffPlaceholder | Check whehter T is a placeholder which matches the givens indeterminate ids and signature |
CIsRestriction | Traits in order to identify a Restriction class |
CIsSelfTransposed< Perm, ConstantTensor< F, Dims >, std::enable_if_t<(!isSimple(Perm{}) &&isInvariant(Dims{}, Perm{}))> > | Don't transpose constant tensors if their dimenensions are invariant under the permutation |
CIsSelfTransposed< Perm, Eye< Dims, F >, std::enable_if_t<(!isSimple(Perm{}) &&isInvariant(Dims{}, Perm{}))> > | Don't transpose eye tensors if their dimensions are invariant under the permutation |
CIsSelfTransposed< Perm, KroneckerDelta< Dims, Index, Field >, std::enable_if_t<(!isSimple(Perm{}) &&isInvariant(Dims{}, Perm{}) &&isInvariant(Index{}, Perm{}))> > | Don't transpose constant tensors |
CIsSelfTransposed< Perm, T, std::enable_if_t<(IsDecay< Perm >::value &&IsDecay< T >::value &&!isSimple(Perm{}) &&IsBinaryExpression< T >::value &&IsComponentWiseExpression< T >::value &&HasSelfTransposedOperand< Perm, 0, T >::value &&HasSelfTransposedOperand< Perm, 1, T >::value)> > | Sums- and differences of self-transposed tensors remain self-transposed |
CIsSelfTransposed< Perm, T, std::enable_if_t<(IsDecay< Perm >::value &&IsDecay< T >::value &&!isSimple(Perm{}) &&IsEinsumExpression< T >::value &&IsRuntimeEqualExpression< Operand< 0, T > >::value &&IsRuntimeEqualExpression< Operand< 1, T > >::value &&std::is_same< std::decay_t< Operand< 0, T > >, std::decay_t< Operand< 1, T > > >::value &&std::is_same< typename T::LeftIndexPositions, typename T::RightIndexPositions >::value &&std::is_same< Perm, SequenceCat< typename T::RightArgs, typename T::LeftArgs > >::value)> > | Einsum operations over the same set of indices of identical tensors are self-transposed when exchanging the complete index set |
CIsSelfTransposed< Perm, T, std::enable_if_t<(IsDecay< Perm >::value &&IsDecay< T >::value &&!isSimple(Perm{}) &&IsProductExpression< T >::value &&((TensorTraits< Expressions::Operand< 0, T > >::rank==0 &&HasSelfTransposedOperand< Perm, 1, T >::value)||(TensorTraits< Expressions::Operand< 1, T > >::rank==0 &&HasSelfTransposedOperand< Perm, 0, T >::value)))> > | Products of scalars with self-transposed tensors remain self-transposed |
CIsSelfTransposed< Perm, T, std::enable_if_t<(IsDecay< Perm >::value &&IsDecay< T >::value &&!isSimple(Perm{}) &&IsProductExpression< T >::value &&(TensorTraits< Expressions::Operand< 0, T > >::rank > 0 &&TensorTraits< Expressions::Operand< 1, T > >::rank > 0) &&HasSelfTransposedOperand< TranspositionForOperand< 0, Perm, T >, 0, T >::value &&HasSelfTransposedOperand< TranspositionForOperand< 1, Perm, T >, 1, T >::value)> > | Products (ProductTensor, EinsteinSummation) are selftransposed if the permutation respects the product structure and the arguments are self-transposed with respect to the induced permutation |
CIsSelfTransposed< Perm, T, std::enable_if_t<(IsDecay< Perm >::value &&IsDecay< T >::value &&!isSimple(Perm{}) &&IsUnaryExpression< T >::value &&IsComponentWiseExpression< T >::value &&HasSelfTransposedOperand< Perm, 0, T >::value)> > | Unary operations acting componentwise do not alter the self-transposedness |
CIsSelfTransposed< Perm, T, std::enable_if_t<(IsDecay< Perm >::value &&IsDecay< T >::value &&IsTensorOperand< T >::value &&isSimple(Perm{}))> > | Ignore do-nothing permutations |
CIsSelfTransposed< Seq< Perm... >, BlockEye< Rank, Dims, Field >, std::enable_if_t<(!isSimple(Seq< Perm... >{}) &&std::is_same< SequenceProd< Rank, MakeIndexSequence< Dims::size()> >, Seq< Get< Perm, SequenceProd< Rank, MakeIndexSequence< Dims::size()> > >::value... > >::value)> > | Don't transpose constant tensors if their dimenensions are invariant under the permutation |
CIsSubordinateTransposition | |
CIsSubordinateTransposition< Perm, T, std::enable_if_t<(IsDecay< T >::value &&isPermutation(Perm{}) &&Perm::size()==TensorTraits< T >::rank &&IsEinsumExpression< T >::value)> > | Inspect einsum expressions |
CIsSubordinateTransposition< Perm, T, std::enable_if_t<(IsDecay< T >::value &&isPermutation(Perm{}) &&Perm::size()==TensorTraits< T >::rank &&IsTensorProductExpression< T >::value)> > | Inspect product expressions |
CIsSubordinateTransposition< Perm, T, std::enable_if_t<(IsDecay< T >::value &&IsUnaryExpression< T >::value &&IsComponentWiseExpression< T >::value &&isPermutation(Perm{}) &&Perm::size()==TensorTraits< T >::rank)> > | Component-wise unary operations are ok if the permutation operates on the signature |
CIsTensor< T, std::enable_if_t<(IsDecay< T >::value &&T::Signature::size()==T::rank)> > | A tensor is something with a signature and a rank :) |
CIsTensorOperand | |
CIsTensorOperand< T, std::enable_if_t<!IsDecay< T >::value > > | |
CIsTensorOperand< T, std::enable_if_t<(IsTensor< T >::value &&IsDecay< T >::value)> > | |
CIsTensorOperand< TypedValue::FractionConstant< Int, N, D > > | Inject FractionConstant as valid tensor operand |
CIsTensorOperand< TypedValue::NamedConstant< T, Name... > > | Inject NamedConstant as valid tensor operand |
CIsTransposition | Traits in order to identify a TensorView class |
CIsUnaryTensorOperand | We should not inject scalars into unary expressions as this very easily will lead to ambiguities |
CKroneckerDelta< Seq< D0, RestDims... >, Seq<>, Field > | "Kronecker" tensor: evaluates to 1 for exactly one tuple of indices |
CKroneckerDelta< Seq< Dimensions... >, Seq< PivotIndices... >, Field > | "Kronecker" tensor: evaluates to 1 for exactly one tuple of indices |
CLinearStorageTensor | A tensor wrapping an object with an operator[] |
CLinearStorageTensor< Container, Seq< Dimensions... > > | A tensor wrapping an object with an operator[] and a value_type |
COperandRank | Generate the rank of the N-th operand if applicable |
COperandRank< N, T, std::enable_if_t<(N >=Arity< T >::value)> > | Generate ~0UL if T has not so many operands |
COperateFAD< Evaluate, Seq< Id... >, Signature... > | Implement forward AD by transforming an expression to its evaluated AD expression |
CProductTensor | Compute the component-wise product ".[i][j]" over selected indices: |
CReshape< Parent, Seq< Dimensions... > > | Wraps a tensor using the same data but with a different signature |
CRestriction | A meta-tensor restricting a given tensor w.r.t |
CRestriction< Tensor, Seq< IndexPositions... >, Seq< PivotIndices... > > | Restriction to index sub-space with compile-time constant pivot indices |
CRestriction< Tensor, Seq< IndexPositions... >, Seq<> > | Restriction to index sub-space with run-time dynamic pivot indices |
CTensorBase | Base class for all tensors |
CTensorResult | The wrapper class wrapped around each expression result |
CTensorTraits< TypedValue::FractionConstant< Int, N, D > > | Inject FractionConstant as valid tensor operand |
CTensorTraits< TypedValue::NamedConstant< T, Name... > > | Inject NamedConstant as valid tensor operand |
CTerminalDependsOn | |
CTerminalDependsOn< T, IndexConstant< Id >, Signature, std::enable_if_t<(!IndeterminateMatch< T, IndexConstant< Id > >::value &&!IsPlaceholderExpression< T >::value)> > | |
CTransposition< Tensor, Seq< Perm... > > | A class applying a transposition to the given tensor's indices |
CTranspositionForOperandHelper | Construct the induced transposition for operand N if Perm is subordinate to the expression structure of T |
CTranspositionForOperandHelper< N, Perm, T, std::enable_if_t<(IsSubordinateTransposition< Perm, T >::value &&IsTensorProductExpression< T >::value &&(N< Arity< T >::value))> > | |
CTranspositionForOperandHelper< N, PermArg, T, std::enable_if_t<(IsSubordinateTransposition< PermArg, T >::value &&IsEinsumExpression< T >::value &&(N< Arity< T >::value))> > | |
►NTypedValue | |
CFractionConstant | A class implementing compile-time constant fractions of integers |
CIsFractionConstant | |
CIsSign | |
CIsSign< T, std::enable_if_t< IsFractionConstant< T >::value > > | TrueType is T models a sign which means it is a FractionConstant<I, N, D>, D == 1 and N*N <= 1 |
CIsSign< T, std::enable_if_t<!IsFractionConstant< T >::value > > | Only fraction constants can be signs |
CNamedConstant | A named constant wraps a constant of the given type T tagging it with the given character sequence |
CNamedConstant< T, '1', '_', 'P', 'I'> | 1/pi form glibc implementation |
CNamedConstant< T, '2', '_', 'P', 'I'> | 2/pi form glibc implementation |
CNamedConstant< T, '2', '_', 'S', 'Q', 'R', 'T', 'P', 'I'> | 2/sqrt(pi) form glibc implementation |
CNamedConstant< T, 'E'> | E form glibc implementation |
CNamedConstant< T, 'L', 'N', '1', '0'> | Log_e 10 form glibc implementation |
CNamedConstant< T, 'L', 'N', '2'> | Log_e 2 form glibc implementation |
CNamedConstant< T, 'L', 'O', 'G', '1', '0', 'E'> | Log_10 e form glibc implementation |
CNamedConstant< T, 'L', 'O', 'G', '2', 'E'> | Log_2 e form glibc implementation |
CNamedConstant< T, 'P', 'I', '_', '2'> | Pi/2 form glibc implementation |
CNamedConstant< T, 'P', 'I', '_', '4'> | Pi/4 form glibc implementation |
CNamedConstant< T, 'P', 'I'> | Pi form glibc implementation |
CNamedConstant< T, 'S', 'Q', 'R', 'T', '1', '_', '2'> | 1/sqrt(2) form glibc implementation |
CNamedConstant< T, 'S', 'Q', 'R', 'T', '2'> | Sqrt(2) form glibc implementation |
CAbsOperation | Abs |
CAcceptAllFunctor | Functor for TransformSequence: unconditionally accept |
CAcceptEqualFunctor | Functor for TransformSequence: accept if result is either equal or different from original value |
CAcceptInputInRangeFunctor | Accept if input-value is in range of given bounds |
CAcceptInputValueFunctor | Accept if input-value is either equal or unequal to given value |
CAcceptModuloFunctor | Accept if input-value MOD P = R |
CAcoshOperation | Inverse hyperbolic cosine |
CAcosOperation | Taking the arc cosine of an object |
CAdaptiveFemScheme | Abstract space adaptative FEM scheme |
CAddBitFunctor | Add given bit to all masks |
CAddBitShiftLeftFunctor | Add a set bit at left-shifted position |
CAddBitShiftRightFunctor | Add a set bit at right-shifted position |
CAndPredicate | Logical "and" for two perdicates |
CAsinhOperation | Inverse hyperbolic sine |
CAsinOperation | Taking the arc sine of an object |
CAssumeOperation | Assume operations attach a property to the wrapped expression |
CAtan2Operation | Taking the arctan of an object |
CAtanhOperation | Inverse hyperbolic tangens |
CAtanOperation | Taking the arctan of an object |
CBasicFemScheme | Abstract non-adaptive basic FEM scheme |
CBulkBlockConstraints | A default implementation for bulk block constraints |
CCanPromoteTupleTypes | |
CCanPromoteTupleTypes< T, std::enable_if_t< sizeof(TupleScalarPromotionType< T >) >=0 > | TrueType if the type of the tuple T can be promoted to another type |
CCase | Case-structure for multi-conditional switch |
CCeilOperation | Ceil |
CConstantExpression | A constant |
CContainerTuple | Create a tuple of values from a tuple of containers |
Ccopy_cv_reference | Export a type copy_cv_reference::type which has the same qualifiers as T and decays to the decay of U |
CCoshOperation | Hyperbolic cosine |
CCosOperation | Taking the cosine of an object |
CDataOutputParameters | Potentially overwrite some parameters |
CDefaultQuadratureTraits | Helper traits-class, defining likely quadrature types |
CDirichletConstraints< DiscreteFunctionSpace, BoundaryValues, Indicator, std::enable_if_t<(HasEmptySupport< BoundaryValues >::value||IndicatorTraits< Indicator >::emptySupport)> > | Spezialization of Dirichlet constraints for emptyboundaryindicator |
CDirichletConstraints< 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 |
CDirichletConstraints< DiscreteFunctionSpace, Model, void, std::enable_if_t< true &&IsPDEModel< Model >::value &&!HasEmptySupport< Model >::value > > | Implementation of Dirichlet constraints given a PDE-model |
CDofMapperTupleDataHandle | Potential all - all communication for mapped data |
CDofMapperTupleDataHandleTraits | Traits for just something indexable |
CEinsumOperation | Einstein summation, i.e |
CEllipticEstimator | An standard residual estimator for elliptic problems |
CEllipticFemScheme | Adaptive fem-scheme for "elliptic" problems |
CEllipticOperator | A class defining an elliptic operator |
CEmptyBlockConstraints | A class modelling do-nothing constraints |
CEqOperation | == |
CErfOperation | Erf |
CExpOperation | Exponentiation of an object |
CExpressionTraits | Default expression traits definition is a recursion in order to ease disambiguation |
CExpressionTraits< Constant< I, V > > | Explicit expression traits for integer constants |
CExpressionTraits< FractionConstant< Int, N, D > > | Override ExpressionTraits for FractionConstant |
CExpressionTraits< Model, std::enable_if_t< IsPDEModel< Model >::value >, TraitsPriority::Secondary > | Override default expression traits s.t |
CExpressionTraits< T, std::enable_if_t< Expressions::IsClosure< T >::value >, BaseTraitsLevel > | Use traits of enclosed type for closure expressions |
CExpressionTraits< T, std::enable_if_t<!IsDecay< T >::value >, DecayTraitsLevel > | Forward to the traits class for the decay type |
CExpressionTraits< 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 |
CExpressionTraits< 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 |
CExpressionTraits< T, void, DefaultTraitsLevel > | A traits class in order to collect properties of expressions |
CExpressionTraits< Tensor::AutoDiffPlaceholder< Id, Signature, T, DT > > | |
CExpressionTraits< TypedValue::NamedConstant< T, Name... > > | Override ExpressionTraits for NamedConstant |
CExtractFunctor | A functor which extracts values from a global array and copies them to a local array |
CExtractFunctor< T *, GlobalArray > | A functor which extracts values from a global array and copies them to a local array |
CFieldPromotion | Promote potentially different numeric field types to a "closure" type |
CFieldTraits | Helper class for specializing Dune::FieldTraits |
CFloorOperation | Floor |
CGeometryInformation | Export some hard-to-get-at things for geometries |
CGeOperation | >= |
CGet | 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 |
CGtOperation |
|
CHasPropertyFunctor | |
CHasResize | |
CHasUnaryMinus | |
CHasUnaryMinus< T, std::enable_if_t<(sizeof(decltype(-std::declval< T >())) >=0)> > | TrueType if a T allows for the unary minus operator |
CIdentityFunctor | Identity functor |
CIdentityOperation | Identity, i.e. just wrap the object |
CIndependentExpression | An independent expression is an expression which does not depend on external state |
CIndeterminateOperation | Indeterminate operation, wrap another object and attach an id |
CIndexFunctor | Index functor |
CIntersectionDataHandle | General intersection - intersection communication which communicates for each intersection a potentially variable number of data-items |
CInverseMapSequenceFunctor | Map a value to the index of the value in Values |
CIsAlwaysFalse | Assume a predicate is a traits-class and would never evaluate to false unless it is equivalent to AlwaysFalse |
CIsAlwaysFalse< 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 |
CIsAlwaysTrue | Assume a predicate is a traits-class and would never evaluate to true unless it is equivalent to AlwaysTrue |
CIsAlwaysTrue< 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 |
CIsApplicableTo | Is TrueType if an F can be invoked with an E |
CIsArray | |
CIsArray< std::array< T, N > > | TrueType if T is a std::array |
CIsArray< T, std::enable_if_t<!IsDecay< T >::value > > | Forward to decay if T is not a decay type |
CIsBoolConstant | |
CIsBoolConstant< BoolConstant< V > > | TrueType for bool constant |
CIsBoolConstant< T & > | Forward to decay traits class for non decay types |
CIsBoolConstant< T && > | Forward to decay traits class for non decay types |
CIsDefined | |
CIsDefined< 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 |
CIsDistributiveOperation | True for expressions which can be moved inside or outside of sums |
CIsDynamicOperation | Should be overloaded to std::true_type for operations which introduce runtime variable data into the expression as part of the operation |
CIsEvenFunctor | Transform to bool sequence of even indices |
CIsIndexSequence | |
CIsIndexSequence< IndexSequence< Ints... > > | TrueType for integer sequences with value_type std::size_t |
CIsIntegral | TrueType if I is an integral type |
CIsIntegral< TypedValue::FractionConstant< I, N, 1 > > | Some FractionConstants are integral |
CIsIntegralConstant | FalseType by default |
CIsIntegralConstant< Constant< T, V > > | TrueType for integral_constant |
CIsOddFunctor | Transform to bool sequence of even indices |
CIsProductOperation | Evaluate to std::true_type if the operation is product-like |
CIsQuadraturePoint | |
CIsQuadraturePoint< Fem::QuadraturePointWrapper< Quadrature > > | Identify quadrature points |
CIsQuadraturePoint< T, std::enable_if_t<!IsDecay< T >{}> > | |
CIsScalar | Std::true_type if F is an "elementary" scalar |
CIsScalar< 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 |
CIsScalar< TypedValue::FractionConstant< I, N, D > > | FractionConstants are scalars |
CIsScalar< TypedValue::NamedConstant< T, Name... > > | NamedConstants are scalars if the wrapped type is |
CIsSequence | |
CIsSequence< Sequence< T, Ints... > > | Evaluate to TrueType of integer sequences |
CIsTupleLike | |
CIsTupleLike< 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 |
CIsVolatileOperation< IndeterminateOperation< Id > > | Indeterminates are also volatile by design |
CIsVolatileOperation< PlaceholderOperation< Placeholder > > | Placeholder expressions are volatile by design, unless overridden by a RuntimEqualExpression tag |
CLeOperation | <= |
CLGammaOperation | ;gamma |
CLocalObjectFactory | Define a factory for a "local object" which has a constructor which accepts a single argument, a "global object" |
CLocalObjectStack | Local object stack which (hopefully) efficiently caches local objects |
CLogicalAndOperation | Logical And |
CLogicalNotOperation | Logical Not |
CLogicalOrOperation | Logical Or |
CLogOperation | Taking the logarithm of an object |
CLtOperation | < |
CMakeType | |
CMapSequenceFunctor | Map sequence values to values specified by other sequence, e.g |
CMapSequenceFunctor< Sequence< I > > | Per convention just use the identiy for the empty value sequence |
CMaxOperation | Max |
CMaybeLumpingQuadratureTraits | Helper traits-class, defining likely quadrature types for mass-lumping |
CMinOperation | Min |
CMinusEqOperation | A -= B |
CMinusOneExpression | 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) |
CMinusOperation | Subtraction of two objects and unary minus |
CModelBase | A structure defining some basic default types and methods |
CMultiplyOffsetFunctor | Multiply-offset functor |
CMutableExpression | Something which may be change between different evaluations of an expression |
CMutableLocalObjectStorageProvider | Provide a writable object stack for technical reasons |
CMutableNoStorageProvider | Provide a writable pseudo object stack which is only a reference to the global object |
CNegativeExpression | An expression which is known to be negative |
CNeOperation | != |
CNonZeroExpression | Complementary to ZeroExpression for use in std::conditional, for example, otherwise unused |
COneExpression | 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) |
COperationTraits< EinsumOperation< Pos1, Pos2, Dims > > | Einstein summation, i.e |
COperationTraits< ReshapeOperation< Sig > > | Reshape a tensor to another signature |
COperationTraits< TensorProductOperation< Pos1, Pos2, Dims > > | Component-wise product over given index-set |
COperationTraits< TransposeOperation< Perm > > | Permutation of index positions of tensors |
COperatorTypeSelector | |
COrPredicate | Logical "or" for two perdicates |
CPairFunctor | Generate a compound functor out of two functors |
CParabolicEulerEstimator | Residual estimator for the heat equation |
CParabolicFemScheme | Basic parabolic fem-scheme class |
CPieceWiseConstantExpression | Something constant on a given entity |
CPlaceholderOperation | Placeholder operation wraps another object and attaches an id to it |
CPlusEqOperation | A += B |
CPlusOperation | Addition of two objects |
CPointWrapperQuadrature | A wrapper class which allows to "simulate" a Dune::Fem::QuadraturePointWrapper |
CPositiveExpression | An expression which is known to be positive |
CPowOperation | Taking something to the power of something |
►CPredicateProxy | Wrap the given predicate class F into another one with spcial requirements |
CForwardFirst | Discard any but the first template parameter, instantiate F with T and Rest |
CUnary | Generate a one-parameter template to support template-template arguments with a single argument |
CPredicateWrapper | Wrap a predicate into a class which can be passed on as argument |
CReciprocalOperation | Inversion of a scalar object |
CRegularZeroExpression | Non-singular, but somehow zero, whatever that means |
Cremove_const | Export a type trough remove_const::type as follows: |
CReshapeOperation | Signature of index positions of tensors |
CRestrictionOperation | AutoDiff operation |
CRoundOperation | Round |
CRuntimeEqualExpression | 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 |
CSameDecay | TrueType if T1 and T2 have the same decay types, otherwise FalseType |
CScopedRedirect | A class to redirect streams |
CSemiNegativeExpression | Less equal 0 expression |
CSemiPositiveExpression | Greater equal 0 expression |
CSinhOperation | Hyperbolic sine |
CSinOperation | Taking the sine of an object |
CSMultiplyEqOperation | A *= s |
CSMultiplyOperation | Multiplication by scalars from the left |
CSolverSelector | Select one appropriate (linear) solver depending on whether the model is symmetric and/or semidefinite |
CSqrtOperation | Taking the square root of an object |
CSquareOperation | Taking the square of an object |
CSubExpressionOperation | Kind of placeholder |
CSwitch | Recursion for a multi-conditional switch |
CSwitch< 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 |
CSwitch< T > | Recursion endpoint: If the terminating template parameter to SwitchType is not a Case template, then export T as Switch<T>::Type |
CTanhOperation | Hyperbolic tangens |
CTanOperation | Taking the tangens of an object |
CTensorProductOperation | Component-wise product over given index-set |
CTerminalExpression | A terminal expression is an "expression end-point", i.e |
CTernaryOperation | IfOperation |
CTGammaOperation | Tgamma |
CTimeProviderTraits | Type of time and time-step values |
CTimeView | Generate a view on the current time-step |
CTransformAtIndexFunctor | Applies another functor only to the elements at the specified positions given by the Index parameter pack |
CTransposeOperation | Permutation of index positions of tensors |
CTrueErrorEstimator | "estimator" which return the "true" error with respect to some given function in some standard norm |
CTupleFunctor | Generate a compound functor out of a tuple of functors |
CTypedValueExpression | A tag structure signalling that this expression carries its value in its type |
CTypeString | A class constructing the name of another type |
CUnaryFilterFunctor | Filter-proxy for TransformSequence template alias |
CUnaryKeepAtFunctor | Alternative: avoid bit-masks and use ContainsValue<> template |
CUnaryNotFunctor | Negate a given unary functor |
CUniqueExpression | A tag for use with assume() to generate a unique type which is assumed to be "runtime equal" by inheriting from RuntimeEqualExpression |
CVolatileExpression | A volatile expression will not be replaced by its value except for RuntimeEqual optimizations |
CZeroExpression | A tag structure which can be attached as base class to zero-expressions like the ZeroGridFunction, the ZeroModel, the ZeroFunctional |
CZeroExpressionTraits | ExpressionTraits for any zero-expression |
CFieldTraits< ACFem::GridFunction::ElementMeasurePlaceholder< GridPart > > | Specialize Dune::FieldTraits |
CFieldTraits< ACFem::GridFunction::LocalFunctionHessianPlaceholder< LocalFunction, IndeterminateId > > | Specialize Dune::FieldTraits |
CFieldTraits< ACFem::GridFunction::LocalFunctionJacobianPlaceholder< LocalFunction, IndeterminateId > > | Specialize Dune::FieldTraits |
CFieldTraits< ACFem::GridFunction::LocalFunctionPlaceholder< LocalFunction, IndeterminateId > > | Specialize Dune::FieldTraits |
▼Nstd | STL namespace |
Cis_convertible< Dune::ACFem::Tensor::TensorResult< T >, Dune::FieldVector< Field, 1 > > | |
Cis_same< Dune::FieldVector< Field, 1 >, Dune::DenseVector< T > > | |