DUNE-ACFEM (2.5.1)
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 1234]
| ▼NDune | |
| ►NACFem | A namespace encapsulating everything defined in our dune-acfem project |
| CAcosOperation | Taking the cosine of an object |
| CAdaptiveFemScheme | Abstract space adaptative FEM scheme |
| CAsinOperation | Taking the cosine of an object |
| CAtanOperation | Taking the cosine of an object |
| CBasicFemScheme | Abstract non-adaptive basic FEM scheme |
| CBinaryExpressionTraits | The default result type is void in order to trigger compilation errors |
| CBinaryFunctionalExpression | Binary functional expression |
| CBinaryFunctionalExpressionTraits | "No-storage", traits, stuff lives on the stack |
| CBinaryFunctionExpression | Unary expressions |
| CBinaryFunctionExpression< SMultiplyOperation, FactorType, FunctionType > | S-multiplication with RangeFieldType scalars |
| CBinaryFunctionExpressionOperation< MultiplyOperation > | S-multiplication with scalar functions and scalar products |
| CBinaryFunctionExpressionOperation< SMultiplyOperation > | Multiplication from the left by a scalar constant |
| CBinaryFunctionExpressionTraits | Traits of BinaryFunctionExpression |
| CBinaryFunctionExpressionTraits< MinusOperation, LeftFunction, RightFunction > | Substraction |
| CBinaryFunctionExpressionTraits< PlusOperation, LeftFunction, RightFunction > | Simple addition |
| CBinaryFunctionExpressionTraits< SMultiplyOperation, Factor, Function > | S-multiplication with RangeFieldType scalars |
| ►CBinaryGridFunctionExpression | BinaryGridFunctionExpression implements point-wise vector-space operations for GridFunction-types |
| CLocalFunction | General local function object for binary grid-function expressions |
| CBinaryGridFunctionExpression< SMultiplyOperation, Factor, Function > | S-multiplication with RangeFieldType scalars |
| CBinaryGridFunctionExpressionTraits | Traits of BinaryGridFunctionExpression |
| CBinaryGridFunctionExpressionTraits< SMultiplyOperation, Factor, Function > | S-multiplication with RangeFieldType scalars |
| CBinaryLocalFunctionalExpression< SMultiplyOperation, LeftArg, RightArg > | Implement S-multiplication by scalars and parameters from the left, multiplication from the right will be redirected to this class |
| CBinaryModelExpression | Template for binary operations |
| CBinaryModelExpression< MultiplyOperation, FactorFunction, ModelType > | Multiplication with grid-functions |
| CBinaryModelExpression< SMultiplyOperation, Factor, ModelType > | S-multiplication with numbers (see below for S-multiplication with grid-functions) |
| CBinaryOperatorPartsExpression | Template for binary operations |
| CBinaryOperatorPartsExpression< MultiplyOperation, FactorFunction, OperandType > | Multiplication with grid-functions |
| CBinaryOperatorPartsExpression< SMultiplyOperation, Factor, OperandType > | S-multiplication with numbers (see below for S-multiplication with grid-functions) |
| CBinaryVectorExpression | Binary vector expressions |
| CBinaryVectorExpression< SMultiplyOperation, Scalar, Vector > | Special case for S-multiplication |
| CBlockConstraintsDefaultStorageTraits | Default traits for BlockConstraints which LocalObjectStack usage |
| CBlockConstraintsDefaultTraits | We need the type of the implementation and the local operator type |
| CBlockConstraintsOperatorInterface | Interface class for a block-constraints-operator |
| CBoundaryFunctionTraits | Helper traits in order to treat function w/o dedicated boundary support in the same way, mostly for the sake of ExpressionTemplates |
| CBoundaryFunctionTraits< F, false > | |
| CBoundaryFunctionTraits< F, true > | |
| CBoundaryIdIndicator | Apply to boundary segments which carry the respective id |
| CBoundaryIndicatorExpression | Expression tag-class for boundary indicators |
| CBoundaryIndicatorInterface | A simple interface class for a boundary-indicator |
| CBoundaryIndicatorWrapper | Wrap another boundary indicator |
| ►CBoundarySupportedFunction | A function with potentially partial support on the boundary |
| CLocalFunction | LocalFunction object which takes the value of a indicator into account |
| CBulkBlockConstraints | A default implementation for bulk block constraints |
| CBulkForcesFunctionModel | Wrap an existing GridFunction into a model which only conatains this ModelConstituent |
| CBulkForcesFunctionModel< ZeroGridFunction< FunctionSpace, GridPart > > | Special case for the ZeroGridFunction |
| CComplementBoundaryIndicator | Turn any boundary-indicator into its complement |
| CConstantFunction | A class describing a constant function |
| CConstantGridFunction | ConstantGridFunction implements a constant function |
| CCoordinateFunction | Coordinate function returns a specific component of the world point, x_N, so to say |
| CCosOperation | Taking the cosine of an object |
| CDataOutputParameters | Potentially overwrite some parameters |
| CDefaultBoundaryIndicator | Default boundary indicator: like EntireBoundaryIndicator<false> |
| CDefaultExpressionTraits | Default expressions traits |
| ►CDefaultModel | Default model implementation |
| CForcesFunctionalTraits | |
| ►CDefaultModelTraits | A structure defining some trivial default values for the template structure ModelTraits<ModelType>, given the function-space the beast maps to, and the grid part |
| CForcesFunctionalTraits | Helper structure to define an optional functional as part of the "right hand side" |
| CDefaultOperatorParts | Default model implementation |
| CDefaultOperatorPartsTraits | A structure defining some trivial default values for the template structure OperatorPartsTraits<PartsImpl>, given the function-space the beast maps to, and the grid part |
| CDefaultParameter | Just for completeness, there is no default implementation |
| CDefaultQuadratureTraits | Helper traits-class, defining likely quadrature types |
| CDeformationTensorOperatorParts | Define the a model where the flux-part is formed from the symmetric gradient |
| CDifferentiableBlockConstraintsOperatorInterface | Interface class for a differentiable block-constraints-operator |
| CDifferentiableEmptyBlockConstraints | A class modelling differentiable do-nothing constraints |
| CDiracDistribution | Dirac-distribution |
| CDirichletBlockConstraintsTraits< JacobianOperator, BoundaryValues, EmptyBoundaryIndicatorType > | Spezialization of Dirichlet constraints for emptyboundaryindicator |
| CDirichletBoundaryModel | A Dirichlet model |
| CDirichletBoundaryModel< GridFunction, EmptyBoundaryIndicatorType > | Special case for the EmptyBoundaryIndicatorType |
| CDirichletConstraints | Implementation of Dirichlet constraints |
| CDiscontinuousGalerkinLeafFunctionSelector | Helper class which defines likey discrete function types |
| CDiscontinuousLagrangeLeafFunctionSelector | Helper class which defines likey discrete function types |
| CDiscreteLinearFunctional | Interface class for a discrete linear functional |
| CDiscreteLinearFunctionalDefault | Default implementation for linear functionals |
| CDivergenceOperatorParts | For a given grid-function define a model implementing the weak divergence |
| CEllipticEstimator | An standard residual estimator for elliptic problems |
| CEllipticFemScheme | Constructor for the elliptic fem-scheme. |
| CEllipticFemScheme< DiscreteFunction, Model, ZeroGridFunction< typename Model::FunctionSpaceType, typename Model::GridPartType > > | Constructor for the elliptic fem-scheme. |
| CEllipticFemSchemeBase | Adaptive fem-scheme for "elliptic" problems |
| CEllipticModel | A model for a second order elliptic operator |
| CEllipticOperator | A class defining an elliptic operator |
| CEmptyBlockConstraints | A class modelling do-nothing constraints |
| CExpOperation | Exponentiation of an object |
| CExpressionCopyStorage | Store things as copy, serves as default implementation for the ExpressionStorage class |
| CExpressionReferenceStorage | Store things as reference, serves as default implementation for the ExpressionStorage class |
| CExpressionResult | Automatically deduce the type by applying the respective operation |
| CExpressionStorage | An ExpressionStorage object stores either a copy or a reference of an object |
| CExpressionTemplate | Provide up-cast functionality for expression templates |
| CExpressionTraits | A traits class in order to collect properties of expressions |
| 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 |
| CFixedForcesFunctionalTraits | Utiliy class to aid in the definition of ModelInterface::ForcesFunctionalTraits |
| CFluidSelfTransportOperatorParts | Define a model for the "Navier-Stokes" non-lineariry |
| CForcesFunctionalModel | Wrap an existing DiscreteLinearFunctional into a model which only conatains this ModelConstituent |
| CForcesFunctionalModel< ZeroFunctional< DiscreteFunctionSpace > > | Special case for the ZeroFunctional |
| CFractionGridFunction | A grid-function which is constant with a scalar fractional value |
| CFractionGridFunctionTraits | A grid-function which is constant with a fractional value |
| CFunctionExpression | Underlying tag-structure |
| CGradientOperatorParts | For a given grid-function define a model implementing the weak gradient |
| CGridFunctionAdapter | GridFunctionAdapter provides local functions for a Function |
| CGridFunctionAdapterTraits | Traits of GridFunctionAdapter |
| CGridFunctionConverter | Helper class for wrapToGridFunction() and adaptToGridFunction() |
| CGridFunctionExpression | A class providing some basic functionality common to all expressions |
| CGridFunctionWrapper | A special version of Fem::GridFunctionAdapter which stores a copy to the function, not a reference |
| CHasBoundarySupport | Tag-structure to indicate additional functionality |
| CHasNoBoundarySupport | Negative tag-structure for use with std::conditional, complementary to HasBoundarySupport |
| CIdentityFunction | A function which returns its argument |
| CIdentityOperation | Identity, i.e. just wrap the object |
| CIncompressibleSelfTransportOperatorParts | Define a model for the "Navier-Stokes" non-lineariry |
| CIncompressibleTransportOperatorParts | Define a model for an advection term with a divergence-free velocity field |
| CIntersectionBoundaryIndicator | Intersection of two indicators, apply iff both apply |
| CIntersectionDataHandle | General intersection - intersection communication which communicates for each intersection a potentially variable number of data-items |
| CInverseTimeStepParameter | A Parameter-class which gives access to the inverse of the current time-step size of an underlying Dune::Fem::TimeProvider |
| CInvertOperation | Inversion of an object |
| CIsNotPieceWiseConstant | Negation of IsPieceWiseConstant, in order to have something to branch to with std::conditional |
| CIsPieceWiseConstant | Tag type, consequences are zero Jacobian and Hessian |
| CL2ProjectionOperator | Compute the L2-projection of the given functional to a discrete space |
| CLagrangeLeafFunctionSelector | Helper class which defines likey discrete function types |
| CLaplacianOperatorParts | Define a simple Laplacian-model, given function-space and grid-part |
| CLinearFunctionalTraitsDefault | Default traits were the local objects are not cached, but created on the fly |
| CLocalDivergenceAdapter | An adapter class to compute the divergence of a GridFunction |
| CLocalFunctionWrapper | LocalFunctionWrapper wraps a class with a local evaluate method into a grid function |
| CLocalFunctionWrapperTraits | Traits of DiscreteFunctionAdapter |
| CLocalGradientAdapter | An adapter class to compute the gradient of a scalar GridFunction |
| CLocalLinearFunctional | Interface or better: factory for local functionals |
| CLocalLinearFunctionalDefault | Default implementation for LocalLinearFunctional |
| CLocalMaxAdapter | An adapter class to compute the (pointwise) maximum of two scalar GridFunctions |
| CLocalNormAdapter< GridFunction, 2 > | An adapter class to represent the pointwise euclidean norm of a (usually vector-valued) GridFunction |
| 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 |
| CLocalPiecewiseAdapter | An adapter class to form a piecewise defined function where the domain decomposition is given by the characteristic function of one of the sub-domains |
| CLocalRightHandSideAdapter | An adapter class which takes any ACFem-PDE model and computes from its bulk contributions and any given GridFunction a bulk forces density field (AKA "right hand side") such that the discrete solution of the PDE model should approximate the underlying "exact solution" |
| CLogOperation | Taking the logarithm of an object |
| CLumpingQuadratureTraits | Helper traits-class, defining likely quadrature types for mass-lumping |
| CMassOperatorParts | Define a simple mass-model, given function-space and grid-part |
| CMeanCurvatureOperatorParts | Define a mean-curvature model for graphs and level-sets |
| CMinusOperation | Subtraction of two objects and unary minus |
| CModelConstituents | A helper class which identifies which components are provided by the given model |
| CModelConstituents< ModelInterface< Model > > | Redirect to the real ModelConstituents from the interface class |
| ►CModelInterface | Interface class for second order elliptic models |
| CForcesFunctionalTraits | Helper structure to define an optional functional as part of the "right hand side". |
| CModelTraits | Traits-template which has to be specialized for each individual model |
| ►CModelTraits< BinaryModelExpression< BinOp, LeftModel, RightModel > > | ModelExpression type traits |
| CForcesFunctionalTraits | |
| CMultiplyOperation | Multiplication of two objects |
| 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 |
| CMutableSMultiplyOperation | Multiplication by mutable scalars from the left |
| CNeumannBoundaryModel | A Neumann-boundary model |
| CNeumannBoundaryModel< GridFunction, EmptyBoundaryIndicatorType > | Special case for the EmptyBoundaryIndicatorType |
| CNonZeroExpression | Complementary to ZeroExpression for use in std::conditional, for example, otherwise unused |
| CNonZeroFunctional | Just a place-holder to aid in automatic type-deduction |
| 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) |
| COperatorPartsInterface | Interface class for second order elliptic models |
| COperatorPartsTraits | Traits-template which has to be specialized for each individual model |
| COperatorPartsTraits< BinaryOperatorPartsExpression< BinOp, LeftOperand, RightOperand > > | OperatorPartsExpression type traits |
| CP_LaplacianOperatorParts | The p-Laplacian-model |
| CP_MassOperatorParts | A simplistic non-linear example |
| CPairFunctor | Generate a compound functor out of two functors |
| CParabolicEulerEstimator | Residual estimator for the heat equation |
| CParabolicFemScheme | Basic parabolic fem-scheme class |
| CParameterFunction | A class describing a constant function |
| CParameterGridFunction | ParameterGridFunction implements a constant function where the value is defined by something which fulfills the ParameterInterface |
| CParameterInterface | Parameters are quasi-constant quantities, like the time-step size in one time-step when solving transient problems with finite element methods |
| CParameterSpace | A model for the vector space a parameter value lives in |
| CParameterSpaceTraits | The default template definition for this struct constructs a 1-dimensional parameter-value space (i.e |
| CParameterSpaceTraits< FieldVector< Field, dim > > | The default template definition for this struct constructs a 1-dimensional parameter-value space (i.e. |
| CPlusOperation | Addition of two objects |
| CProblemInterface | Problem interface which describes a second order elliptic boundary problem: |
| CRestrictProlongDefaultTraits | A helper class which defines the proper RestrictProlong compound data-type for tuples of Fem::DiscreteFunction implementations |
| CRestrictProlongDefaultTraits< DiscreteFunction > | A helper class which defines the proper RestrictProlong compound data-type for tuples of Fem::DiscreteFunction implementations. |
| CRestrictProlongDefaultTupleHelper | AFAIK, C++11 is not capable of expanding tuples into parameter packs, so this recursive helper function is used to unpack a tuple and perform the necessary constructions in order to finally have a compound RestrictProlong type |
| CRestrictProlongDefaultTupleHelper< Tuple, std::integral_constant< size_t, std::tuple_size< Tuple >::value-1 > > | Recursion end-point to access the last argument of the tuple |
| CRestrictProlongPair | Chain two RestrictProlong implementations together |
| CRobinBoundaryOperatorParts | A (homogeneous) Robin-boundary model |
| CRobinBoundaryOperatorParts< FunctionSpace, EmptyBoundaryIndicatorType > | Special case for the EmptyBoundaryIndicatorType |
| CSinOperation | Taking the sine of an object |
| CSMultiplyOperation | Multiplication by scalars from the left |
| CSolverFamily | Define some symbolic constants for SolverSelector and "parse" some preprocessort defines |
| CSolverSelector | Select one appropriate (linear) solver depending on whether the model is symmetric and/or semidefinite |
| CSplittingFemScheme | Constructor. |
| CSplittingFemScheme< DiscreteFunction, ImplicitModel, ExplicitDataFunction, ExplicitModel, ZeroGridFunction< typename ImplicitModel::FunctionSpaceType, typename ImplicitModel::GridPartType > > | Constructor. |
| CSplittingFemScheme< DiscreteFunction, ImplicitModel, ZeroGridFunction< typename ImplicitModel::FunctionSpaceType, typename ImplicitModel::GridPartType >, ZeroModel< typename ImplicitModel::FunctionSpaceType, typename ImplicitModel::GridPartType >, InitialGuess > | Constructor. |
| CSplittingFemScheme< DiscreteFunction, ImplicitModel, ZeroGridFunction< typename ImplicitModel::FunctionSpaceType, typename ImplicitModel::GridPartType >, ZeroModel< typename ImplicitModel::FunctionSpaceType, typename ImplicitModel::GridPartType >, ZeroGridFunction< typename ImplicitModel::FunctionSpaceType, typename ImplicitModel::GridPartType > > | Constructor. |
| CSplittingFemSchemeBase | Basic fem-scheme class |
| CSqrtOperation | Taking the square root of an object |
| CSquareOperation | Taking the square of an object |
| CTanOperation | Taking the cosine of an object |
| CTimeStepParameter | A Parameter-class which gives access to the current time-step size of an underlying Dune::Fem::TimeProvider |
| CTimeView | Generate a view on the current time-step |
| CTimeViewParameter | A Parameter-class which returns the absolute time corresponding to a fixed fraction of the current time-step |
| CTransientProblemInterface | Problem interface class for time dependent problem descriptions, i.e |
| CTransportOperatorParts | Define a model for an advection term |
| CTrivialParameter | A simple wrapper: a really constant parameter |
| 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 |
| CUnaryExpressionTraits | The default result type is void in order to trigger compilation errors |
| CUnaryFunctionalExpressionTraits | "No-storage", traits, stuff lives on the stack |
| CUnaryFunctionExpression | Binary expressions |
| CUnaryFunctionExpression< IdentityOperation, FunctionType > | Specialize for the identity wrapper operation |
| CUnaryFunctionExpressionTraits | Traits of UnaryFunctionExpression |
| CUnaryGridFunctionExpression | UnaryGridFunctionExpression implements point-wise unary operations for GridFunction-types |
| CUnaryGridFunctionExpression< IdentityOperation, FunctionType > | Specialize for the identity wrapper operation |
| CUnaryGridFunctionExpression< InvertOperation, FunctionType > | For the sake of BoundarySupportedFunction we need to specialize the InvertOperation |
| CUnaryGridFunctionExpressionTraits | Traits of UnaryGridFunctionExpression |
| CUnaryModelExpression | Template for unary operations |
| CUnaryModelExpression< IdentityOperation, Model > | Unary identity operation which simply wraps the underlying model |
| CUnaryModelExpression< MinusOperation, Model > | Unary minus |
| CUnaryOperatorPartsExpression | Template for unary operations |
| CUnaryOperatorPartsExpression< IdentityOperation, Operand > | Unary identity operation which simply wraps the underlying stuff |
| CUnaryOperatorPartsExpression< MinusOperation, Operand > | Unary minus |
| CUnaryParameterOperation< AcosOperation > | Componentwise acos |
| CUnaryParameterOperation< AsinOperation > | Componentwise asin |
| CUnaryParameterOperation< AtanOperation > | Componentwise atan |
| CUnaryParameterOperation< CosOperation > | Componentwise cos |
| CUnaryParameterOperation< ExpOperation > | Componentwise exp |
| CUnaryParameterOperation< SinOperation > | Componentwise sin |
| CUnaryParameterOperation< SqrtOperation > | Componentwise square root |
| CUnaryParameterOperation< SquareOperation > | Componentwise square |
| CUnaryParameterOperation< TanOperation > | Componentwise tan |
| CUnaryVectorExpression | Unary vector expressions |
| CUnaryVectorExpression< IdentityOperation, FieldMatrix< Field, rows, cols > > | Wrap a FieldMatrix into an IdentityOperation |
| CUnaryVectorExpression< IdentityOperation, Vector > | This is the only allowed starting point for vector-expressions: here we allow vectors to be wrapped inside the Identity-operation in order to be valid ExpressionTemplates for further operation |
| CUnionBoundaryIndicator | Union of two indicators, apply to the union of both boundary parts |
| CVectorExpression | Tag structure, flag all these as ExpressionTemplates |
| CWeakDivergenceOperatorParts | For a given grid-function define a model implementing the weak divergence |
| CX | Used as "tag" for coordinateGridFunction() and coordinateVectorFunction() |
| CZeroExpression | A tag structure which can be attached as base class to zero-expressions like the ZeroGridFunction, the ZeroModel, the ZeroFunctional |
| CZeroFunctional | This is the famous "do-nothing" functional |
| CZeroGridFunction | A grid-function always returning 0 |
| CZeroGridFunctionExpression | A base class for zero function expression |
| CZeroGridFunctionTraits | A grid-function tight to zero |
| CZeroModel | Define a simple zero model to optimize expression templates |
| CZeroOperatorParts | Define a simple zero model to optimize expression templates |
| CZeroParameter | The zero parameter, unconditionally evalute to zero |
| CScopedRedirect | A class to redirect streams |
|
Legal Statements / Impressum |
Hosted by TU Dresden & Uni Heidelberg |
generated with Hugo v0.111.3
(Mar 12, 23:28, 2025)