Dune Core Modules (2.9.0)
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 12345]
| ►NALUGrid | |
| CALU3dGridGhostIteratorHigherCodim | Ghost Iterator |
| CALUMemoryProvider | Organize the memory management for entitys used by the NeighborIterator |
| CGatherScatterBaseImpl | Corresponding interface class is defined in bsinclude.hh |
| CGatherScatterBaseImpl< GridType, DataCollectorType, 0 > | Corresponding interface class is defined in alu3dinclude.hh |
| CGatherScatterLeafData | Corresponding interface class is defined in bsinclude.hh |
| CGatherScatterLevelData | Corresponding interface class is defined in bsinclude.hh |
| CGatherScatterLevelData< GridType, DataCollectorType, 0 > | Corresponding interface class is defined in bsinclude.hh |
| CGatherScatterNoData | Corresponding interface class is defined in bsinclude.hh |
| ►NDune | Dune namespace |
| ►NAlignedNumberImpl | |
| CAlignedNumber | Aligned wrappers for arithmetic types |
| ►NAmg | |
| CAggregate | A class for temporarily storing the vertices of an aggregate in |
| ►CAggregatesMap | Class providing information about the mapping of the vertices onto aggregates |
| CDummyEdgeVisitor | A Dummy visitor that does nothing for each visited edge |
| CAggregatesPublisher< T, O, OwnerOverlapCopyCommunication< T1, T2 > > | Utility class for publishing the aggregate number of the DOFs in the overlap to other processors and convert them to local indices |
| CAggregationCriterion | Base class of all aggregation criterions |
| CAggregationLevelTransferPolicy | A LeveTransferPolicy that used aggregation to construct the coarse level system |
| CAggregationParameters | Parameters needed for the aggregation process |
| CAggregator | Class for building the aggregates |
| CAMG | Parallel algebraic multigrid based on agglomeration |
| CCoarsenCriterion | The criterion describing the stop criteria for the coarsening process |
| CCoarseningParameters | Parameters for the complete coarsening process |
| CConstructionTraits | Traits class for generically constructing non default constructable types |
| CConstructionTraits< ParSSOR< M, X, Y, C > > | Policy for the construction of the ParSSOR smoother |
| CConstructionTraits< Richardson< X, Y > > | Policy for the construction of the Richardson smoother |
| CConstructionTraits< SeqILU< M, X, Y > > | Policy for the construction of the SeqILU smoother |
| CConstructionTraits< SeqJac< M, X, Y, l > > | Policy for the construction of the SeqJac smoother |
| CConstructionTraits< SeqSOR< M, X, Y, l > > | Policy for the construction of the SeqSOR smoother |
| CConstructionTraits< SeqSSOR< M, X, Y, l > > | Policy for the construction of the SeqSSOR smoother |
| CDefaultConstructionArgs | Construction Arguments for the default smoothers |
| CDefaultSmootherArgs | The default class for the smoother arguments |
| CDependency | Dependency policy for symmetric matrices |
| CDependencyParameters | Parameters needed to check whether a node depends on another |
| CDiagonal | Norm that uses only the [N][N] entry of the block to determine couplings |
| CEdgeProperties | Class representing the properties of an ede in the matrix graph |
| CFastAMG | A fast (sequential) algebraic multigrid based on agglomeration that saves memory bandwidth |
| CFirstDiagonal | Norm that uses only the [0][0] entry of the block to determine couplings |
| CGraphEdgePropertiesSelector | Wrapper to access the internal vertex properties of a graph via operator[]() |
| CGraphVertexPropertiesSelector | Wrapper to access the internal edge properties of a graph via operator[]() |
| ►CHierarchy | A hierarchy of containers (e.g. matrices or vectors) |
| CLevelIterator | Iterator over the levels in the hierarchy |
| CIndicesCoarsener< OwnerOverlapCopyCommunication< G, L >, E > | Coarsen Indices in the parallel case |
| CIndicesCoarsener< SequentialInformation, E > | Coarsen Indices in the sequential case |
| CKAMG | Algebraic multigrid method using a Krylov-cycle |
| CKAmgTwoGrid | Two grid operator for AMG with Krylov cycle |
| CLevelTransferPolicy | Abstract base class for transfer between levels and creation of the coarse level system |
| ►CMatrixGraph | The (undirected) graph of a matrix |
| CEdgeIteratorT | Iterator over all edges starting from a vertex |
| CVertexIteratorT | The vertex iterator type of the graph |
| CMatrixHierarchy | The hierarchies build by the coarsening process |
| COneStepAMGCoarseSolverPolicy | A policy class for solving the coarse level system using one step of AMG |
| CParameters | All parameters for AMG |
| CPropertiesGraph | Attaches properties to the edges and vertices of a graph |
| CRandomAccessBundledPropertyMap | A property map that extracts one property out of a bundle using operator[]() |
| CRowSum | Functor using the row sum (infinity) norm to determine strong couplings |
| CSmootherApplier | Helper class for applying the smoothers |
| CSmootherTraits | Traits class for getting the attribute class of a smoother |
| CSparsityBuilder | Functor for building the sparsity pattern of the matrix using examineConnectivity |
| ►CSubGraph | A subgraph of a graph |
| CEdgeIndexMap | An index map for mapping the edges to indices |
| CEdgeIterator | The edge iterator of the graph |
| CVertexIterator | The vertex iterator of the graph |
| CSymmetricCriterion | Criterion taking advantage of symmetric matrices |
| CSymmetricDependency | Dependency policy for symmetric matrices |
| CSymmetricMatrixDependency | Dependency policy for symmetric matrices |
| CTwoLevelMethod | |
| CUnSymmetricCriterion | Criterion suitable for unsymmetric matrices |
| CVertexProperties | Class representing a node in the matrix graph |
| CVertexPropertiesGraph | Attaches properties to the vertices of a graph |
| CVertexVisitedTag | Tag idnetifying the visited property of a vertex |
| ►NCapabilities | Contains all capabilities classes |
| CcanCommunicate | Specialize with 'true' for all codims that a grid can communicate data on (default=false) |
| CcanCommunicate< ALUGrid< dim, dimworld, eltype, refinementtype, ALUGridMPIComm >, codim > | ALUGrid can communicate |
| CcanCommunicate< ALUGrid< dim, dimworld, eltype, refinementtype, ALUGridNoComm >, codim > | ALUGrid can communicate when Comm == ALUGridMPIComm |
| CcanCommunicate< IdentityGrid< HostGrid >, codim > | IdentityGrid can communicate when the host grid can communicate |
| CcanCommunicate< SPGrid< ct, dim, Ref, MPI_Comm >, codim > | Can a parallel grid communicate on a given codimension? |
| CcanCommunicate< UGGrid< dim >, codim > | UGGrid can communicate on entities of all (existing) codimensions |
| CcanCommunicate< YaspGrid< dim, Coordinates >, codim > | YaspGrid can communicate on all codimensions |
| ChasBackupRestoreFacilities | Specialize with 'true' if implementation provides backup and restore facilities. (default=false) |
| ChasBackupRestoreFacilities< AlbertaGrid< dim, dimworld > > | AlbertaGrid has backup and restore facilities |
| ChasBackupRestoreFacilities< ALUGrid< dim, dimworld, eltype, refinementtype, Comm > > | ALUGrid has backup and restore facilities |
| ChasBackupRestoreFacilities< SPGrid< ct, dim, Ref, Comm > > | Does a grid provide backup and restore facilities? |
| ChasEntity | Specialize with 'true' for all codims that a grid implements entities for. (default=false) |
| ChasEntity< AlbertaGrid< dim, dimworld >, codim > | AlbertaGrid has entities for all codimensions |
| ChasEntity< ALUGrid< dim, dimworld, eltype, refinementtype, Comm >, cdim > | ALUGrid has entities for all codimension |
| ChasEntity< IdentityGrid< HostGrid >, codim > | Has entities for some codimensions as host grid |
| ChasEntity< OneDGrid, cdim > | OneDGrid has entities for all codimension |
| ChasEntity< SPGrid< ct, dim, Ref, Comm >, codim > | Does a grid implement entities of a codimension? |
| ChasEntity< UGGrid< dim >, codim > | UGGrid has entities of all codimensions |
| ChasEntity< YaspGrid< dim, Coordinates >, codim > | YaspGrid has entities for all codimensions |
| ChasEntityIterator | Specialize with 'true' for all codims that a grid provides an iterator for (default=hasEntity<codim>::v) |
| ChasEntityIterator< AlbertaGrid< dim, dimworld >, codim > | AlbertaGrid can iterate over all codimensions |
| ChasEntityIterator< ALUGrid< dim, dimworld, eltype, refinementtype, Comm >, cdim > | ALUGrid has entities for all codimension |
| ChasEntityIterator< OneDGrid, codim > | OneDGrid can iterate over all codimensions |
| ChasEntityIterator< SPGrid< ct, dim, Ref, Comm >, codim > | Does a grid implement entity iterators of a codimension? |
| ChasEntityIterator< UGGrid< dim >, 0 > | UGGrid can iterate over codim=0 entities (elements) |
| ChasEntityIterator< UGGrid< dim >, codim > | Set default for hasEntityIterator to false UGGrid can currently only iterate over elements and vertices |
| ChasEntityIterator< UGGrid< dim >, dim > | UGGrid can iterate over codim=dim entities (vertices) |
| ChasEntityIterator< YaspGrid< dim, Coordinates >, codim > | YaspGrid can iterate over all codimensions |
| ChasGeometry | Specialize with 'false' for all codims that a grid does not implement geometries for. (default=true) |
| ChasSingleGeometryType | Specialize with 'true' for if the codimension 0 entity of the grid has only one possible geometry type. In this case the topologyId of this geometry type has also to be specified. (default=false, topologyId=undefined) |
| ChasSingleGeometryType< AlbertaGrid< dim, dimworld > > | AlbertaGrid has only one geometry type for codim 0 entities |
| ChasSingleGeometryType< ALUGrid< dim, dimworld, eltype, refinementtype, Comm > > | ALUGrid has only one geometry type for codim 0 entities |
| ChasSingleGeometryType< OneDGrid > | OneDGrid has only one geometry type for codim 0 entities |
| ChasSingleGeometryType< SPGrid< ct, dim, Ref, Comm > > | Do elements of a grid always have the same geometry type? |
| ChasSingleGeometryType< YaspGrid< dim, Coordinates > > | YaspGrid has only one geometry type for codim 0 entities |
| CisCartesian | Specialize with 'true' if the grid is a Cartesian grid. Cartesian grids satisfy the following properties: |
| CisCartesian< SPGrid< ct, dim, Ref, Comm > > | Is the grid Cartesian? |
| CisCartesian< YaspGrid< dim, Coordinates > > | YaspGrid is a Cartesian grid |
| CisLeafwiseConforming | Specialize with 'true' if implementation guarantees a conforming leaf grid. (default=false) |
| CisLeafwiseConforming< AlbertaGrid< dim, dimworld > > | AlbertaGrid is leafwise conforming |
| CisLeafwiseConforming< ALUGrid< dim, dimworld, eltype, refinementtype, Comm > > | ALUGrid has potentially nonconforming leaf grids (unless refinementtype is conforming) |
| CisLeafwiseConforming< IdentityGrid< HostGrid > > | Has conforming leaf grids when host grid has |
| CisLeafwiseConforming< OneDGrid > | OneDGrid is leafwise conforming |
| CisLeafwiseConforming< SPGrid< ct, dim, Ref, Comm > > | Is the leaf level of a grid always conform? |
| CisLeafwiseConforming< UGGrid< dim > > | UGGrid may not be leafwise conforming |
| CisLeafwiseConforming< YaspGrid< dim, Coordinates > > | YaspGrid is leafwise conforming |
| CisLevelwiseConforming | Specialize with 'true' if implementation guarantees conforming level grids. (default=false) |
| CisLevelwiseConforming< AlbertaGrid< dim, dimworld > > | AlbertaGrid is not levelwise conforming (since it uses bisection) |
| CisLevelwiseConforming< ALUGrid< dim, dimworld, eltype, refinementtype, Comm > > | ALUGrid has potentially nonconforming level grids |
| CisLevelwiseConforming< IdentityGrid< HostGrid > > | Has conforming level grids when host grid has |
| CisLevelwiseConforming< OneDGrid > | OneDGrid is levelwise conforming |
| CisLevelwiseConforming< SPGrid< ct, dim, Ref, Comm > > | Are all levels of a grid always conform? |
| CisLevelwiseConforming< UGGrid< dim > > | UGGrid is levelwise conforming |
| CisLevelwiseConforming< YaspGrid< dim, Coordinates > > | YaspGrid is levelwise conforming |
| CsupportsCallbackAdaptation< SPGrid< ct, dim, Ref, Comm > > | |
| CthreadSafe | Specialize with 'true' if the grid implementation is thread safe. (default=false) |
| CthreadSafe< ALUGrid< dim, dimworld, eltype, refinementtype, Comm > > | ALUGrid is not generally thread safe (only grid iteration is) |
| CthreadSafe< SPGrid< ct, dim, Ref, Comm > > | Is a grid implementation thread safe? |
| CviewThreadSafe | Specialize with 'true' if the grid implementation is thread safe, while it is not modified. (default=false) |
| CviewThreadSafe< ALUGrid< dim, dimworld, eltype, refinementtype, Comm > > | ALUGrid is view thread safe (i.e. things that don't modify the grid) |
| CviewThreadSafe< SPGrid< ct, dim, Ref, Comm > > | Is a grid implementation thread safe while not being modified? |
| CviewThreadSafe< YaspGrid< dim, Coordinates > > | YaspGrid is viewThreadSafe |
| ►NConcept | Namespace for concepts |
| CRefines | Base class for refined concepts |
| ►Ndgf | |
| CGridParameterBlock | Common Grid parameters |
| CYaspGridParameterBlock | Grid parameters for YaspGrid |
| ►NExtensions | Namespace containing capabilities for extensions |
| CSuperEntityIterator | Does a grid support superentity iterators of a codimension? |
| CSuperEntityIterator< SPGrid< ct, dim, Ref, Comm >, codim > | Does a grid support superentity iterators of a codimension? |
| ►NFloatCmp | |
| CDefaultEpsilon | Mapping from a value type and a compare style to a default epsilon |
| CEpsilonType | Mapping of value type to epsilon type |
| CEpsilonType< FieldVector< T, n > > | Specialization of EpsilonType for Dune::FieldVector |
| CEpsilonType< std::vector< T, A > > | Specialization of EpsilonType for std::vector |
| ►NFunctions | |
| ►NBasisFactory | |
| ►NExperimental | |
| CGenericIndexingTransformation | A generic implementation of a transformation |
| CPeriodicIndexSet | Container storing identified indices for a periodic basis |
| CBlockedInterleaved | Interleaved merging of direct children with blocking (i.e. creating blocks at the leaves containing one leaf per child each) |
| CBlockedLexicographic | Lexicographic merging of direct children with blocking (i.e. creating one block per direct child) |
| CFlatInterleaved | Interleaved merging of direct children without blocking |
| CFlatLexicographic | Lexicographic merging of direct children without blocking |
| CIndexMergingStrategy | Base class for index merging strategies to simplify detection |
| ►NConcept | |
| CCallable | Concept objects that can be called with given argument list |
| CDifferentiableFunction< Range(Domain), DerivativeTraits > | Concept for a differentiable function mapping Domain to Range |
| CDifferentiableGridFunction< Range(Domain), EntitySet, DerivativeTraits > | Concept for a differentiable grid function mapping Domain to Range |
| CDifferentiableGridViewFunction< Range(Domain), GridView, DerivativeTraits > | Concept for a differentiable grid view function mapping Domain to Range |
| CDifferentiableLocalFunction< Range(Domain), LocalContext, DerivativeTraits > | Concept for a differentiable local function mapping Domain to Range |
| CEntitySet | Concept for an entity set for a Concept::GridFunction<Range(Domain), EntitySet, DerivativeTraits> |
| CFunction< Range(Domain)> | Concept for a function mapping Domain to Range |
| CGridFunction< Range(Domain), EntitySet > | Concept for a grid function mapping Domain to Range |
| CGridViewFunction< Range(Domain), GridView > | Concept for a grid view function mapping Domain to Range |
| CLocalFunction< Range(Domain), LocalContext > | Concept for a local function mapping Domain to Range |
| ►NExperimental | |
| CTransformedIndexPreBasis | A pre-basis transforming multi-indices |
| CAnalyticGridViewFunction< Range(Domain), GV, F, DerivativeTraits > | Class wrapping any differentiable function as grid function |
| CBSplineLocalBasis | LocalBasis class in the sense of dune-localfunctions, presenting the restriction of a B-spline patch to a knot span |
| CBSplineLocalCoefficients | Attaches a shape function to an entity |
| CBSplineLocalFiniteElement | LocalFiniteElement in the sense of dune-localfunctions, for the B-spline basis on tensor-product grids |
| CBSplineLocalInterpolation | Local interpolation in the sense of dune-localfunctions, for the B-spline basis on tensor-product grids |
| CBSplinePreBasis | Pre-basis for B-spline basis |
| CCallableFunctionWrapper | Wrap a Dune::VirtualFunction into a callable object |
| CComposedGridFunction | Composition of grid functions with another function |
| CCompositePreBasis | A pre-basis for composite bases |
| CDefaultDerivativeTraits | Default implementation for derivative traits |
| CDefaultDerivativeTraits< double(double) > | Default implementation for derivative traits |
| CDefaultDerivativeTraits< FieldMatrix< K, 1, m >(FieldVector< K, n >)> | Default implementation for derivative traits |
| CDefaultDerivativeTraits< FieldVector< K, m >(FieldVector< K, n >)> | Default implementation for derivative traits |
| CDefaultDerivativeTraits< K(FieldVector< K, n >)> | Default implementation for derivative traits |
| CDefaultGlobalBasis | Global basis for given pre-basis |
| CDefaultLocalView | The restriction of a finite element basis to a single element |
| CDefaultNodeToRangeMap | A simple node to range map using lexicographic ordering |
| CDifferentiableFunction< Range(Domain), DerivativeTraits, bufferSize > | Class storing differentiable functions using type erasure |
| CDifferentiableFunctionFromCallables< Range(Domain), DerivativeTraits, F > | Wrap a list of callable objects as derivative sequence modelling Concept::DifferentiableFunction<Range(Domain), DerivativeTraits> |
| CDifferentiableFunctionFromCallables< Range(Domain), DerivativeTraits, F, DF, Derivatives... > | Wrap a list of callable objects as derivative sequence modelling Concept::DifferentiableFunction<Range(Domain), DerivativeTraits> |
| CDiscreteGlobalBasisFunction | A grid function induced by a global basis and a coefficient vector |
| ►CDiscreteGlobalBasisFunctionDerivative | Derivative of a DiscreteGlobalBasisFunction |
| CLocalFunction | Local function evaluating the derivative in reference coordinates |
| CFaceNormalGridFunction | Grid function implementing the piecewise element face normal |
| CFunctionFromCallable< Range(Domain), F, FunctionInterface > | Wrap a callable object as Dune::Function or Dune::VirtualFunction |
| CGridFunction< Range(Domain), ES, DerivativeTraits, bufferSize > | Wrapper class for functions defined on a Grid |
| CGridViewEntitySet | An entity set for all entities of given codim in a grid view |
| CGridViewFunction< Range(Domain), GV, DerivativeTraits, bufferSize > | Wrapper class for functions defined on a GridView |
| CHasStaticSize | Check if type is a statically sized container |
| CHierarchicalLagrangePreBasis | A pre-basis for a hierarchical basis |
| CHierarchicNodeToRangeMap | A simple node to range map using the nested tree indices |
| CHierarchicVectorWrapper | A wrapper providing multiindex access to vector entries |
| CInvalidRange | Dummy range class to be used if no proper type is available |
| CIsCallable | Helper class to check that F is callable |
| CLagrangePreBasis | A pre-basis for a PQ-lagrange bases with given order |
| CLastType | Get last entry of type list |
| CLocalDerivativeTraits | Derivative traits for local functions |
| CLocalFunction< Range(Domain), LocalContext, DerivativeTraits, bufferSize > | Class storing local functions using type erasure |
| COverflowArray | A dynamically sized array-like class with overflow |
| CPolymorphicSmallObject | A wrapper providing small object optimization with polymorphic types |
| CPolymorphicType | Base class with polymorphic type boiler plate code |
| CPolynomial | A scalar polynomial implementation |
| CPowerPreBasis | A pre-basis for power bases |
| CRannacherTurekPreBasis | Pre-basis for a Rannacher-Turek basis |
| CReservedDeque | A double-ended queue (deque) class with statically reserved memory |
| CRotateTuple | Rotate type list by one, such that last entry is moved to first position |
| CSignatureTag< Range(Domain), DerivativeTraitsT > | Tag-class to encapsulate signature information |
| CSignatureTraits | Helper class to deduce the signature of a callable |
| CSizeInfo | A class encapsulating size information |
| CStaticMultiIndex | A statically sized MultiIndex type |
| CStaticMultiIndex< size_type, 1 > | A statically sized MultiIndex type |
| CStaticSize | Obtain size of statically sized container |
| CSubEntityDOFs | Range of DOFs associated to sub-entity |
| CSubspaceLocalView | The restriction of a finite element basis to a single element |
| CTaylorHoodPreBasis | Pre-basis for lowest order Taylor-Hood basis |
| CTreeData | Container allowing to attach data to each node of a tree |
| CTrigonometricFunction | A linear combination of trigonomic functions |
| CTypeErasureBase | Base class for type-erased interface wrapper |
| CUniformNodeVisitor | Mixin for visitors that should apply the same action on all nodes |
| ►NGeo | |
| ►CReferenceElement | This class provides access to geometric and topological properties of a reference element |
| CCodim | Collection of types depending on the codimension |
| CReferenceElements | Class providing access to the singletons of the reference elements |
| ►NGeoGrid | Namespace containing the implementations of GeometryGrid |
| CEntity | DUNE-conform implementation of the entity |
| CEntityBase | Actual implementation of the entity |
| CEntityBase< codim, Grid, false > | actual implementation of the entity |
| CEntityBase< codim, Grid, true > | actual implementation of the entity |
| ►NILU | |
| CCRS | Simple compressed row storage matrix class |
| ►NMathOverloads | Namespace for customization of math functions with Dune-Semantics |
| CADLTag | Tag to make sure the functions in this namespace can be found by ADL |
| ►NMatrixImp | |
| ►CDenseMatrixBase | A Vector of blocks with different blocksizes |
| CConstIterator | ConstIterator class for sequential access |
| CIterator | Iterator class for sequential access |
| ►NMatrixMarketImpl | |
| CMatrixValuesSetter | Functor to the data values of the matrix |
| Cmm_block_structure_header | Metaprogram for writing the ISTL block structure header |
| Cmm_header_printer | Meta program to write the correct Matrix Market header |
| Cmm_numeric_type | Helper metaprogram to get the matrix market string representation of the numeric type |
| CNumericWrapper | Wrapper class of numeric values |
| CPatternDummy | Utility class for marking the pattern type of the MatrixMarket matrices |
| ►NMonomImp | |
| CEvalAccess | Access output vector of evaluateFunction() and evaluate() |
| CEvaluate | |
| CEvaluate< Traits, 1 > | |
| CJacobianAccess | Access output vector of evaluateJacobian() |
| ►NRefinementImp | This namespace contains the implementation of Refinement |
| ►NHCube | This namespace contains the Refinement implementation for hypercubes (GeometryType::cube) |
| CRefinementImp | Refinement implementation for hypercubes |
| CRefinementSubEntityIteratorSpecial | SubEntityIterator base class for hypercube refinement |
| ►NPrismTriangulation | This namespace contains the Refinement implementation for triangulating prisms (GeometryType::prism -> GeometryType::simplex) |
| CRefinementImp | Implementation of the refinement of a prism into simplices |
| ►NPyramidTriangulation | This namespace contains the Refinement implementation for triangulating pyramids (GeometryType::pyramid -> GeometryType::simplex) |
| CRefinementImp | Implementation of the refinement of a pyramid into simplices |
| CTraits | Mapping from geometryType, CoordType and coerceTo to a particular Refinement implementation |
| ►NSimd | Namespace for vectorization interface functions used by library developers |
| ►NOverloads | Namespace for the overloads and specializations that make up a SIMD implementation |
| CADLTag | Tag used to force late-binding lookup in Dune::Simd::Overloads |
| CLaneCount | Should be derived from a Dune::index_constant |
| CLaneCount< V, std::enable_if_t< VcImpl::IsVector< V >::value > > | Should be derived from an Dune::index_constant |
| CRebindType | Should have a member type type |
| CRebindType< bool, V, std::enable_if_t< VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value > > | Should have a member type type |
| CRebindType< S, M, std::enable_if_t< VcImpl::IsMask< M >::value &&VcImpl::IsVectorizable< S >::value &&!std::is_same< S, Scalar< typename M::Vector > >::value > > | Should have a member type type |
| CRebindType< S, V, std::enable_if_t< VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value &&VcImpl::IsVectorizable< S >::value &&!std::is_same< S, Scalar< V > >::value > > | Should have a member type type |
| CRebindType< S, V, std::enable_if_t< VcImpl::IsVector< V >::value &&!VcImpl::IsVectorizable< S >::value &&!std::is_same< S, bool >::value &&!std::is_same< S, Scalar< V > >::value > > | Should have a member type type |
| CRebindType< Scalar< typename M::Vector >, M, std::enable_if_t< VcImpl::IsMask< M >::value > > | Should have a member type type |
| CRebindType< Simd::Scalar< V >, V, std::enable_if_t< VcImpl::IsVector< V >::value > > | Should have a member type type |
| CScalarType | Should have a member type type |
| CScalarType< V, std::enable_if_t< VcImpl::IsVector< V >::value > > | Should have a member type type |
| ►NVcImpl | |
| CIsMask | Specialized to true for Vc mask types |
| CIsVector | Specialized to true for Vc vector and mask types |
| CProxy | A reference-like proxy for elements of random-access vectors |
| CEndMark | Final element marker for RebindList |
| ►NStd | Namespace for features backported from new C++ standards |
| Cconjunction | Forms the logical conjunction of the type traits B.. |
| Cdisjunction | Forms the logical disjunction of the type traits B.. |
| Cidentity | A function object type whose operator() returns its argument unchanged |
| Cnegation | Forms the logical negation of the type traits B.. |
| Cnonesuch | Type representing a lookup failure by std::detected_or and friends |
| ►NTypeTree | |
| ►NExperimental | |
| CDefaultHybridVisitor | Hybrid visitor interface and base class for TypeTree hybrid visitors |
| CAccumulateType | Statically accumulate a type over the nodes of a TypeTree |
| CAccumulateValue | Statically accumulate a value over the nodes of a TypeTree |
| ►CAdvancedFilter | Base class for advanced filters |
| Capply | Apply this filter to the given node and children |
| CAdvancedFilterTag | Tag describing an advanced filter that has full control over the construction of the list of FilterEntries |
| Cand_ | Statically combine two values of type result_type using && |
| ►CCompositeNode | Base class for composite nodes based on variadic templates |
| CChild | Access to the type and storage type of the i-th child |
| CCompositeNodeTag | Tag designating a composite node |
| CDefaultPairVisitor | Visitor interface and base class for visitors of pairs of TypeTrees |
| CDefaultVisitor | Visitor interface and base class for TypeTree visitors |
| CDirectChildrenPairVisitor | Convenience base class for visiting the direct children of a node pair |
| CDirectChildrenVisitor | Convenience base class for visiting the direct children of a node |
| CDynamicChildAccessors | Mixin class providing methods for child access with run-time parameter |
| CDynamicPowerNode | Collect multiple instances of type T within a dune-typetree |
| CDynamicPowerNodeTag | Tag designating a power node with runtime degree |
| CDynamicTraversal | Mixin base class for visitors that only need a dynamic TreePath during traversal |
| Cevaluate_if_meta_function | Meta function that evaluates its argument iff it inherits from meta_function |
| CException | Base class for all TypeTree exceptions |
| ►Cfilter | Adapter class that takes a SimpleFilter, validated it and turns it into an AdvancedFilter |
| Capply | Apply the filter |
| ►CFilteredCompositeNode | Base class for composite nodes representing a filtered view on an underlying composite node |
| CChild | Access to the type and storage type of the i-th child |
| CFilterEntry | A filter entry describing the mapping of one child in the filtered node |
| CFilterResult | The result of a filter |
| CHybridTreePath | A hybrid version of TreePath that supports both compile time and run time indices |
| CIndexFilter | Filter class for FilteredCompositeNode that selects the children with the given indices |
| CIsTreePath | Check if type represents a tree path |
| Clazy_evaluate | Helper meta function to delay evaluation of F |
| Clazy_identity | Identity function |
| CLeafNode | Base class for leaf nodes in a dune-typetree |
| CLeafNodeTag | Tag designating a leaf node |
| Cmax | Statically combine two values of type result_type by returning their maximum |
| Cmeta_function | Marker tag declaring a meta function |
| Cmin | Statically combine two values of type result_type by returning their minimum |
| Cminus | Statically combine two values of type result_type using - |
| Cmultiply | Statically combine two values of type result_type using * |
| CNodeInterface | Interface for nodes in a dune-typetree |
| Cor_ | Statically combine two values of type result_type using || |
| Cplus | Statically combine two values of type result_type using + |
| ►CPowerNode | Collect k instances of type T within a dune-typetree |
| CChild | Access to the type and storage type of the i-th child |
| CPowerNodeTag | Tag designating a power node |
| CProxyNode | Base class for nodes acting as a proxy for an existing node |
| CProxyNodeBase | Tag-based dispatch to appropriate base class that provides necessary functionality |
| CProxyNodeBase< Node, CompositeNodeTag > | ProxyNode base class for CompositeNode |
| CProxyNodeBase< Node, DynamicPowerNodeTag > | ProxyNode base class for DynamicPowerNode |
| CProxyNodeBase< Node, LeafNodeTag > | ProxyNode base class for LeafNode |
| CProxyNodeBase< Node, PowerNodeTag > | ProxyNode base class for PowerNode |
| ►CSimpleFilter | Default simple filter that accepts any node and leaves its child structure unchanged |
| Capply | Applies the filter to the given child node |
| Cvalidate | Validates the combination of filter and node |
| CSimpleFilterTag | Tag describing a simple filter that can only decide whether or not to include a single given child |
| ►CStaticChildAccessors | Mixin class providing methods for child access with compile-time parameter |
| CChild | Access to the type and storage type of the i-th child |
| CStaticTraversal | Mixin base class for visitors that require a static TreePath during traversal |
| CTransformTree | Transform a TypeTree |
| CTreeInfo | Struct for obtaining some basic structural information about a TypeTree |
| CTreePairVisitor | Convenience base class for visiting an entire tree pair |
| CTreeVisitor | Convenience base class for visiting the entire tree |
| CTypeAccumulationPolicy | |
| ►CVisitDirectChildren | Mixin base class for visitors that only want to visit the direct children of a node |
| CVisitChild | Template struct for determining whether or not to visit a given child |
| ►CVisitTree | Mixin base class for visitors that want to visit the complete tree |
| CVisitChild | Template struct for determining whether or not to visit a given child |
| ►NVTK | |
| CAppendedBase64DataArrayWriter | Streaming writer for data array tags, uses appended base64 format |
| CAppendedRawDataArrayWriter | Streaming writer for data array tags, uses appended raw format |
| CAsciiDataArrayWriter | Streaming writer for data array tags, uses ASCII inline format |
| CBinaryDataArrayWriter | Streaming writer for data array tags, uses binary inline format |
| CBoundaryIterator | Iterate over the GridViews boundary intersections |
| CConformingConnectivityWriter | Writer for the connectivity array in conforming mode |
| CCoordinatesWriter | Writer for the Coordinates array |
| CCorner | Simple class representing a corner of a cell |
| CCornerIterator | Iterate over the corners of some cell range |
| CDataArrayWriter | Base class for data array writers |
| CDataArrayWriterFactory | Factory for DataArrayWriters |
| CFieldInfo | Descriptor struct for VTK fields |
| CFunctionWriterBase | Base class for function writers |
| CNakedBase64DataArrayWriter | Streaming writer for appended data array tags, uses base64 format |
| CNakedRawDataArrayWriter | Streaming writer for appended data arrays, uses raw format |
| CNonConformingConnectivityWriter | Writer for the connectivity array in nonconforming mode |
| COffsetsWriter | Writer for the offsets array |
| CPointIterator | Iterate over the points of some corner range |
| CPrintType | Determine a type to safely put another type into a stream |
| CPVTUWriter | Dump a .vtu/.vtp files contents to a stream |
| CSkeletonFunctionInterface | A prototype for VTKFunctions on the skeleton |
| CSkeletonFunctionWriter | Function writer for skeleton functions |
| CTypesWriter | Writer for the types array |
| CVTKFunctionWriter | Base class for function writers |
| CVTUWriter | Dump a .vtu/.vtp files contents to a stream |
| ►NYasp | |
| CFixedSizePartitioning | Implement partitioner that gets a fixed partitioning from an array If the given partitioning doesn't match the number of processors, the grid should be distributed to, an exception is thrown |
| CPartitioning | Base class for the yaspgrid partitioning strategy |
| CPowerDPartitioning | Implement yaspgrid load balance strategy for P=x^{dim} processors |
| CAdaptDataHandleInterface | Interface class for the Grid's adapt method where the parameter is a AdaptDataHandleInterface |
| CAdderSelector | Template meta program for choosing how to add the correction |
| CAdditiveSchwarzMode | Tag that the tells the Schwarz method to be additive |
| CAddPtrTypeEvaluator | TypeEvaluator to turn a type T into a pointer to T |
| CAddRefTypeEvaluator | TypeEvaluator to turn a type T into a reference to T |
| CAffineGeometry | Implementation of the Geometry interface for affine geometries |
| CAlbertaGrid | [ provides Dune::Grid ] |
| CAlbertaGridEntity | |
| CAlbertaGridEntity< 0, dim, Grid > | |
| CAlbertaGridGeometry | Geometry implementation for AlbertaGrid |
| CAlbertaGridHierarchicIterator | |
| CAlbertaGridIdSet | Hierarchic index set of AlbertaGrid |
| CAlbertaGridTreeIterator | |
| CAlbertaMarkerVector | Marker assigning subentities to one element containing them |
| CAlignedAllocator | Allocators which guarantee alignment of the memory |
| CAlignedBase | CRTP base mixin class to check alignment |
| CAllSet | A set containing everything |
| ►CALU3dGrid | [ provides Dune::Grid ] |
| CPartition | Types for GridView |
| CALU3dGridEntity | |
| CALU3dGridEntity< 0, dim, GridImp > | |
| CALU3dGridEntityPointer< 0, GridImp > | |
| CALU3dGridEntityPointerBase | |
| CALU3dGridEntitySeed< 0, GridImp > | |
| CALU3dGridFactory | Factory class for ALUGrids |
| CALU3dGridGeometricFaceInfoBase | |
| CALU3dGridGeometricFaceInfoBase< 2, dimworld, type, Comm > | |
| CALU3dGridGeometricFaceInfoHexa | |
| CALU3dGridGeometricFaceInfoHexa< 2, dimworld, Comm > | |
| CALU3dGridGeometricFaceInfoTetra | |
| CALU3dGridGeometricFaceInfoTetra< 2, dimworld, Comm > | |
| CALU3dGridHierarchicIndexSet | Hierarchic index set of ALU3dGrid |
| CALU3dGridIntersectionIterator | |
| CALU3dGridLeafIterator | Leaf iterator |
| CALU3dGridLeafVertexList | |
| CALU3dGridLevelIterator | |
| CALU3dGridVertexList | |
| CALUGrid | Unstructured parallel implementation of the DUNE grid interface |
| CALUGridBoundaryProjection | ALUGrid boundary projection implementation DuneBndProjection has to fulfil the DuneBoundaryProjection interface |
| CALUGridMPIComm | Type of class for specialization of parallel ALUGrid (MPI_Comm as communicator) |
| CALUGridNoComm | Type of class for specialization of serial ALUGrid (No_Comm as communicator) |
| CAlwaysFalse | Template which always yields a false value |
| CAlwaysTrue | Template which always yields a true value |
| CAnalyticalCoordFunction | Derive an implementation of an analytical coordinate function from this class |
| CAnalyticalCoordFunctionInterface | Interface class for using an analytical function to define the geometry of a Dune::GeometryGrid. An implementation should be derived from Dune::AnalyticalCoordFunction and the evaluate method mapping \( R^d\to R^r \) has to be supplied |
| CArPackPlusPlus_Algorithms | Wrapper to use a range of ARPACK++ eigenvalue solvers |
| CArrayList | A dynamically growing random access list |
| CArrayListIterator | A random access iterator for the Dune::ArrayList class |
| CAssembledLinearOperator | A linear operator exporting itself in matrix form |
| CAssociativePropertyMap | An adapter to turn an unique associative container into a property map |
| CAt | Reverse element access |
| CAtType | Type for reverse element access |
| CAutonomousValueType | Type free of internal references that T can be converted to |
| CAutonomousValueType< const T > | Specialization to remove const qualifiers |
| CAutonomousValueType< Simd::VcImpl::Proxy< V > > | Specialization of AutonomousValue for Vc proxies |
| CAutonomousValueType< std::vector< bool >::reference > | Specialization for the proxies of vector<bool> |
| CAutonomousValueType< T & > | Specialization to remove lvalue references |
| CAutonomousValueType< T && > | Specialization to remove rvalue references |
| CAutonomousValueType< volatile const T > | Specialization to remove both const and volatile qualifiers |
| CAutonomousValueType< volatile T > | Specialization to remove volatile qualifiers |
| CAxisAlignedCubeGeometry | A geometry implementation for axis-aligned hypercubes |
| Cb64chunk | Struct representing the three byte text as well as the four 6 bit chunks |
| CBackupRestoreFacility | Facility for writing and reading grids |
| CBackupRestoreFacility< ALUGrid< dim, dimworld, elType, refineType, Comm > > | facility for writing and reading grids |
| CBackupRestoreFacility< const Grid > | BackupRestoreFacility taking const Grid as type and deriving from the version with the const |
| CBackupRestoreFacility< Dune::YaspGrid< dim, Coordinates > > | facility for writing and reading grids |
| CBackupRestoreFacility< YaspGrid< dim, TensorProductCoordinates< ctype, dim > > > | facility for writing and reading grids |
| CBase64Stream | Class to base64 encode a stream of data |
| ►CBasisInterface | Interface for global-valued shape functions |
| CTraits | Types of domain and range |
| CBasisInterfaceSwitch | Switch for uniform treatment of local and global basis classes |
| ►CBCRSMatrix | A sparse block matrix with compressed row storage |
| CCreateIterator | Iterator class for sequential creation of blocks |
| CRealRowIterator | Iterator access to matrix rows |
| CBCRSMatrixError | Error specific to BCRSMatrix |
| CBDFMCubeLocalBasis | Brezzi-Douglas-Fortin-Marini shape functions on a reference cube |
| CBDFMCubeLocalBasis< D, R, 2, 1 > | First order Brezzi-Douglas-Fortin-Marini shape functions on the refrence quadrialteral |
| CBDFMCubeLocalBasis< D, R, 2, 2 > | Second order Brezzi-Douglas-Fortin-Marini shape functions on the refrence quadrialteral |
| CBDFMCubeLocalBasis< D, R, 2, 3 > | Third order Brezzi-Douglas-Fortin-Marini shape functions on the refrence quadrialteral |
| CBDFMCubeLocalCoefficients | Layout map for Brezzi-Douglas-Fortin-Marini elements on cubes |
| CBDFMCubeLocalFiniteElement | Brezzi-Douglas-Fortin-Marini finite elements for cubes |
| CBDFMCubeLocalInterpolation | Interpolation for Brezzi-Douglas-Fortin-Marini shape functions on cubes |
| CBDM1Cube2DLocalBasis | First order Brezzi-Douglas-Marini shape functions on the reference quadrilateral |
| CBDM1Cube2DLocalCoefficients | Layout map for Brezzi-Douglas-Marini-1 elements on quadrilaterals |
| CBDM1Cube2DLocalFiniteElement | First order Brezzi-Douglas-Marini shape functions on quadrilaterals |
| CBDM1Cube2DLocalInterpolation | First order Brezzi-Douglas-Marini shape functions on the reference quadrilateral |
| CBDM1Cube3DLocalBasis | First order Brezzi-Douglas-Marini shape functions on the reference hexahedron |
| CBDM1Cube3DLocalCoefficients | Layout map for Brezzi-Douglas-Marini-1 elements on hexahedra |
| CBDM1Cube3DLocalFiniteElement | First order Brezzi-Douglas-Marini shape functions on hexahedron |
| CBDM1Cube3DLocalInterpolation | First order Brezzi-Douglas-Marini shape functions on the reference hexahedron |
| CBDM1Simplex2DLocalBasis | First order Brezzi-Douglas-Marini shape functions on the reference triangle |
| CBDM1Simplex2DLocalCoefficients | Layout map for Brezzi-Douglas-Marini-1 elements on triangles |
| CBDM1Simplex2DLocalFiniteElement | First order Brezzi-Douglas-Marini shape functions on triangles |
| CBDM1Simplex2DLocalInterpolation | First order Brezzi-Douglas-Marini shape functions on the reference triangle |
| CBDM2Cube2DLocalBasis | First order Brezzi-Douglas-Marini shape functions on quadrilaterals |
| CBDM2Cube2DLocalCoefficients | Layout map for Brezzi-Douglas-Marini-2 elements on quadrilaterals |
| CBDM2Cube2DLocalFiniteElement | Second order Brezzi-Douglas-Marini shape functions on quadrilaterals |
| CBDM2Cube2DLocalInterpolation | First order Brezzi-Douglas-Marini shape functions on quadrilaterals |
| CBDM2Simplex2DLocalBasis | First order Brezzi-Douglas-Marini shape functions on quadrilaterals |
| CBDM2Simplex2DLocalCoefficients | Layout map for Brezzi-Douglas-Marini-2 elements on triangles |
| CBDM2Simplex2DLocalFiniteElement | Second order Brezzi-Douglas-Marini shape functions on triangles |
| CBDM2Simplex2DLocalInterpolation | First order Brezzi-Douglas-Marini shape functions on triangles |
| CBDMatrix | A block-diagonal matrix |
| CBiCGSTABSolver | Bi-conjugate Gradient Stabilized (BiCG-STAB) |
| CBidirectionalIteratorFacade | Facade class for stl conformant bidirectional iterators |
| Cbigunsignedint | Portable very large unsigned integers |
| CBilinearMapping | A bilinear mapping |
| CBilinearSurfaceMapping | A bilinear surface mapping |
| CBitSetVector | A dynamic array of blocks of booleans |
| CBitSetVectorConstReference | A proxy class that acts as a const reference to a single bitset in a BitSetVector |
| CBitSetVectorReference | A proxy class that acts as a mutable reference to a single bitset in a BitSetVector |
| CBL | Compile-time parameter for block recursion depth |
| CBlockPreconditioner | Block parallel preconditioner |
| CBlockVector | A vector of blocks with memory management |
| CBoundarySegment | Base class for classes implementing geometries of boundary segments |
| CBoundarySegmentWrapper | |
| CBrezziDouglasMariniCubeLocalFiniteElement | Brezzi-Douglas-Marini local finite element for cubes |
| CBrezziDouglasMariniCubeLocalFiniteElement< D, R, 2, 1 > | Brezzi-Douglas-Marini local finite elements for cubes with dimension 2 and order 1 |
| CBrezziDouglasMariniCubeLocalFiniteElement< D, R, 2, 2 > | Brezzi-Douglas-Marini local finite elements for cubes with dimension 2 and order 2 |
| CBrezziDouglasMariniCubeLocalFiniteElement< D, R, 3, 1 > | Brezzi-Douglas-Marini local finite elements for cubes with dimension 3 and order 1 |
| CBrezziDouglasMariniSimplexLocalFiniteElement | Brezzi-Douglas-Marini local finite element for simplices |
| CBrezziDouglasMariniSimplexLocalFiniteElement< D, R, 2, 1 > | Brezzi-Douglas-Marini local finite elements for simplices with dimension 2 and order 1 |
| CBrezziDouglasMariniSimplexLocalFiniteElement< D, R, 2, 2 > | Brezzi-Douglas-Marini local finite elements for simplices with dimension 2 and order 2 |
| CBTDMatrix | A block-tridiagonal matrix |
| CBufferedCommunicator | A communicator that uses buffers to gather and scatter the data to be send or received |
| CCachedMultiLinearGeometry | Implement a MultiLinearGeometry with additional caching |
| CCGSolver | Conjugate gradient method |
| CCheckIfDiagonalPresent | Check whether the a matrix has diagonal values on blocklevel recursion levels |
| CCloneable | An interface class for cloneable objects |
| CCodim | Static tag representing a codimension |
| CCoefficientsInterface | Interface for global-valued coefficients |
| ►CCollectiveIterator | A collective iterator for moving over the remote indices for all processes collectively |
| Citerator | Iterator over the valid underlying iterators |
| CCombine | A set combining two other sets |
| CCombinedAdaptProlongRestrict | Class for combining 2 index sets together for adaptation process |
| CCommDataHandleIF | CommDataHandleIF describes the features of a data handle for communication in parallel runs using the Grid::communicate methods. Here the Barton-Nackman trick is used to interprete data handle objects as its interface. Therefore usable data handle classes need to be derived from this class |
| CCommMatrixRow | Utility class for comunicating the matrix entries |
| CCommMatrixRowSize | Utility class to communicate and set the row sizes of a redistributed matrix |
| CCommMatrixSparsityPattern | Utility class to communicate and build the sparsity pattern of a redistributed matrix |
| Ccommon_bits | Activate if current and mask have common bits switched on |
| ►CCommPolicy | Default policy used for communicating an indexed type |
| CCommunicationError | Error thrown if there was a problem with the communication |
| CCopyGatherScatter | GatherScatter default implementation that just copies data |
| CCommunication | Collective communication interface and sequential default implementation |
| CCommunication< MPI_Comm > | Specialization of Communication for MPI |
| CCompleteFCGSolver | Complete flexible conjugate gradient method |
| CCompressionStatistics | Statistics about compression achieved in implicit mode |
| Cconst_reference | Get the 'const' version of a reference to a mutable object |
| Cconst_reference< BitSetVectorReference< block_size, Alloc > > | |
| CConstArrayListIterator | A constant random access iterator for the Dune::ArrayList class |
| CConstAssociativePropertyMap | An adaptor to turn an unique associative container into a property map |
| CContainerWrapperIterator | Iterator class for sparse vector-like containers |
| CCrouzeixRaviartLocalFiniteElement | Crouzeix-Raviart finite element |
| CDebugStream | Generic class to implement debug output streams |
| CDebugStreamError | Standard exception for the debugstream |
| CDebugStreamState | Intermediate class to implement tie-operation of DebugStream |
| CDefaultBoundarySegmentIndexSet | DefaultBoundarySegmentIndexSet creates an index set for the macro boundary segments |
| CDefaultIndexSet | DefaultIndexSet creates an index set by using the grids persistent container an a given pair of iterators |
| ►CDefaultLeafIteratorTypes | LeafIterator tpyes for all codims and partition types |
| CCodim | The types of the iterator |
| ►CDefaultLevelIteratorTypes | LevelIterator tpyes for all codims and partition types |
| CCodim | The types |
| CDefaultSVGMatrixOptions | Default options class to write SVG matrices |
| CDenseIterator | Generic iterator class for dense vector and matrix implementations |
| CDenseMatrix | A dense n x m matrix |
| CDenseMatrixAssigner | You have to specialize this structure for any type that should be assignable to a DenseMatrix |
| CDenseVector | Interface for a class of dense vectors over a given field |
| CDGFBoundaryParameter | Contains types for additional features |
| CDGFException | Exception class for IO errors in the DGF parser |
| CDGFGridFactory< Dune::YaspGrid< dim, Dune::TensorProductCoordinates< ctype, dim > > > | Placeholder for grid factory for YaspGrid with tensor product coordinates |
| CDGFGridFactory< YaspGrid< dim, EquidistantCoordinates< ctype, dim > > > | Grid factory for YaspGrid with equidistant coordinates |
| CDGFGridFactory< YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > > > | Grid factory for YaspGrid with equidistant coordinates |
| CDGFGridInfo | Some simple static information for a given GridType |
| CDGFWriter | Write a GridView to a DGF file |
| CDGLocalCoefficients | A class providing local coefficients for dg spaces |
| CDGLocalCoefficientsFactory | A factory class for the dg local coefficients |
| CDGLocalFiniteElement | Takes the basis and interpolation factory from a given LocalFiniteElement (derived from GenericLocalFiniteElement) and replaces the coefficients with dg local keys, i.e., attaches all degrees of freedom to the codimension zero entity |
| CDiagonalMatrix | A diagonal matrix of static size |
| CDim | Static tag representing a dimension |
| CDimSpecificPQkLocalFiniteElementFactory | Factory that only creates dimension specific local finite elements |
| CDimSpecificPQkLocalFiniteElementFactory< D, R, 3, k > | Factory that only creates dimension specific local finite elements |
| CDiscreteCoordFunction | Derive an implementation of a discrete coordinate function from this class |
| CDiscreteCoordFunctionInterface | Interface class for using a discrete function to define the geometry of a Dune::GeometryGrid. An implementation should be derived from Dune::DiscreteCoordinateFunction and the evaluate method taking an entity of the host grid together with the number of a vertex returns the coordinate in \( R^r \) of that corner. The user must ensure continuity of this mapping. In addition an adapt method is provided which is called whenever adapt() is called on the Dune::GeometryGrid |
| CDualP1LocalBasis | Dual Lagrange shape functions on the simplex |
| CDualP1LocalCoefficients | Local coefficients for dual simplex P1 elements |
| CDualP1LocalFiniteElement | The local dual p1 finite element on simplices |
| CDualQ1LocalBasis | Dual Lagrange shape functions of order 1 on the reference cube |
| CDualQ1LocalCoefficients | Layout map for dual Q1 elements |
| CDualQ1LocalFiniteElement | The local dual Q1 finite element on cubes |
| CDualQ1LocalInterpolation | |
| CDuneBoundaryProjection | Interface class for vertex projection at the boundary |
| CDuneGridFormatParser | The DuneGridFormatParser class: reads a DGF file and stores build information in vector structures used by the MacroGrid class |
| CDynamicMatrix | Construct a matrix with a dynamic size |
| CDynamicMatrixSubdomainSolver | Exact subdomain solver using Dune::DynamicMatrix<T>::solve |
| CDynamicVector | Construct a vector with a dynamic size |
| ►CEdgeS0_5Basis | Basis for order 0.5 (lowest order) edge elements on simplices |
| CTraits | Export type traits for function signature |
| CEdgeS0_5Coefficients | Coefficients for lowest order edge elements on simplices |
| CEdgeS0_5Common | Common base class for edge elements |
| CEdgeS0_5FiniteElement | FiniteElement for lowest order edge elements on simplices |
| CEdgeS0_5FiniteElementFactory | Factory for EdgeS0_5FiniteElement objects |
| CEdgeS0_5Interpolation | Interpolation for lowest order edge elements on simplices |
| CElementTopologyMapping | |
| CEmpty | Just an empty class |
| CEmptySet | An empty set |
| CEnableIfInterOperable | Enable typedef if two types are interoperable |
| CEntity | Wrapper class for entities |
| ►CEntity< 0, dim, GridImp, EntityImp > | Template specialization of Dune::Entity for Elements (codim==0) |
| CCodim | Entity types of the different codimensions |
| CEntityDefaultImplementation | Default Implementations for EntityImp |
| CEntityDefaultImplementation< 0, dim, GridImp, EntityImp > | Default Implementations for EntityImp (Elements [cd=0]) |
| CEntityInfo | Structure to hold statistical information about one type of entity |
| CEntityIterator | Interface class for an iterator over grid entities |
| CEntitySeed | Store a reference to an entity with a minimal memory footprint |
| CEnumItem | A set consisting only of one item |
| CEnumRange | A set representing a range including the borders |
| CEquidistantCoordinates | Container for equidistant coordinates in a YaspGrid |
| CEquidistantOffsetCoordinates | Container for equidistant coordinates in a YaspGrid with non-trivial origin |
| CException | Base class for Dune-Exceptions |
| CExceptionHook | Base class to add a hook to the Dune::Exception |
| CFaceTopologyMapping | |
| CFactorial | |
| CFactorial< 0 > | End of recursion of factorial via specialization |
| CFakeMPIHelper | A fake mpi helper |
| CFieldMatrix | A dense n x m matrix |
| CFieldVector | Vector space out of a tensor product of fields |
| CFiniteElementFactoryInterface | Factory interface for global-valued finite elements |
| ►CFiniteElementInterface | Interface for global-valued finite elements |
| CTraits | Types of component objects |
| CFiniteElementInterfaceSwitch | Switch for uniform treatment of finite element with either the local or the global interface |
| CFirstPredicateIndex | Finding the index of a certain type in a std::tuple |
| CFirstTypeIndex | Find the first occurrence of a type in a std::tuple |
| CFlattenTuple | Flatten a std::tuple of std::tuple's |
| CFloatCmpOps | Class encapsulating a default epsilon |
| CFMatrixError | Error thrown if operations of a FieldMatrix fail |
| CFMatrixPrecision | Precisions for calculations with FieldMatrix and FieldVector |
| CForEachType | Helper template to clone the type definition of a std::tuple with the storage types replaced by a user-defined rule |
| CForwardIteratorFacade | Base class for stl conformant forward iterators |
| ►CFunction | Base class template for function classes |
| CTraits | Traits class containing raw types |
| CFuture | Type-erasure for future-like objects. A future-like object is a object satisfying the interface of FutureBase |
| CGeneralizedPCGSolver | Generalized preconditioned conjugate gradient solver |
| ►CGeneralVertexOrder | Class providing information on the ordering of vertices |
| Citerator | Iterate over the vertex indices of some sub-entity |
| CGenericIterator | Generic class for stl-conforming iterators for container classes with operator[] |
| CGenericLocalFiniteElement | A LocalFiniteElement implementation based on three TopologyFactories providing the LocalBasis, LocalCoefficients, and LocalInterpolations. Note the key type for all three factories must coincide |
| CGeometry | Wrapper class for geometries |
| CGeometryDefaultImplementation | Default implementation for class Geometry |
| ►CGeometryGrid | Grid wrapper replacing the geometries |
| CCodim | Traits structure containing types for a codimension |
| CGeometryType | Unique label for each type of entities that can occur in DUNE grids |
| CGlobalGeometryTypeIndex | Compute indices for geometry types, taking the dimension into account |
| ►CGlobalIndexSet | Calculate globally unique index over all processes in a Dune grid |
| CSubPartitionTypeProvider | Helper class to provide access to subentity PartitionTypes with a run-time codimension |
| CGlobalLookupIndexSet | Decorates an index set with the possibility to find a global index that is mapped to a specific local |
| CGMPField | Number class for high precision floating point number using the GMP library mpf_class implementation |
| CGmshReader | Read Gmsh mesh file |
| CGmshReaderOptions | Options for read operation |
| CGmshReaderParser | Dimension independent parts for GmshReaderParser |
| CGmshWriter | Write Gmsh mesh file |
| CGnuplotWriter | Writer for 1D grids in gnuplot format |
| CGradientSolver | Gradient method |
| Cgreater_or_equal | Greater or equal template test |
| ►CGrid | Grid abstract base class |
| ►CCodim | A Traits struct that collects all associated types of one implementation |
| CPartition | A struct collecting all types depending on the partition iterator type |
| CGridDefaultImplementation | |
| CGridError | Base class for exceptions in Dune grid modules |
| CGridFactory | Provide a generic factory class for unstructured grids |
| CGridFactory< AlbertaGrid< dim, dimworld > > | Specialization of the generic GridFactory for AlbertaGrid |
| CGridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > > | Specialization of the generic GridFactory for ALUGrid |
| CGridFactory< UGGrid< dimworld > > | Specialization of the generic GridFactory for UGGrid |
| CGridFactoryInterface | Provide a generic factory class for unstructured grids |
| CGridObjectStreamOrDefault | Template to choose right Object stream type for a given class |
| CGridObjectStreamOrDefaultHelper | |
| CGridObjectStreamOrDefaultHelper< false, GridImp, DefaultImp > | |
| CGridPtr | Class for constructing grids from DGF files |
| ►CGridTraits | A traits struct that collects all associated types of one grid model |
| ►CCodim | Traits associated with a specific codim |
| CPartition | Traits associated with a specific grid partition type |
| ►CGridView | Grid view abstract base class |
| ►CCodim | A struct that collects all associated types of one implementation from the Traits class |
| CPartition | Define types needed to iterate over entities of a given partition type |
| CGridViewInfo | Structure to hold information about a certain GridView |
| CGridViewInfoGTCompare | Comparison object to sort GeometryType by majorly dimension |
| Chash | Functor for hashing objects of type T |
| CHasHierarchicIndexSet | Tagging interface to indicate that Grid has HierarchicIndexSet |
| CHasNaN | Whether this type has a value of NaN |
| CHasObjectStream | Tagging interface to indicate that Grid provides typedef ObjectStreamType |
| CHelpRequest | Exception thrown if the user wants to see help string |
| CHierarchicalP2LocalFiniteElement | |
| CHierarchicalP2WithElementBubbleLocalFiniteElement | |
| CHierarchicalPrismP2LocalFiniteElement | |
| CHierarchicalPrismP2LocalInterpolation | |
| CHierarchicalSimplexP2LocalBasis< D, R, 1 > | Hierarchical P2 basis in 1d |
| CHierarchicalSimplexP2LocalBasis< D, R, 2 > | Hierarchical P2 basis in 2d |
| CHierarchicalSimplexP2LocalBasis< D, R, 3 > | Hierarchical P2 basis in 3d |
| CHierarchicalSimplexP2LocalInterpolation | |
| CHierarchicalSimplexP2WithElementBubbleLocalBasis< D, R, 1 > | Hierarchical P2 basis in 1d |
| CHierarchicalSimplexP2WithElementBubbleLocalBasis< D, R, 2 > | Hierarchical P2 basis in 1d |
| CHierarchicalSimplexP2WithElementBubbleLocalBasis< D, R, 3 > | Hierarchical P2 basis in 1d |
| CHierarchicalSimplexP2WithElementBubbleLocalCoefficients | The local finite element needed for the Zou-Kornhuber estimator for Signorini problems |
| CHierarchicSearch | Search an IndexSet for an Entity containing a given point |
| CHostGridAccess | Access to host grid objects from GeometryGrid |
| CIdentityGrid | Provides a meta grid that is identical to its host |
| CIdentityGridEntity | The implementation of entities in a IdentityGrid |
| CIdentityGridEntity< 0, dim, GridImp > | Specialization for codim-0-entities |
| CIdentityGridEntitySeed | The EntitySeed class provides the minimal information needed to restore an Entity using the grid |
| CIdentityGridHierarchicIterator | Iterator over the descendants of an entity.Mesh entities of codimension 0 ("elements") allow to visit all entities of codimension 0 obtained through nested, hierarchic refinement of the entity. Iteration over this set of entities is provided by the HierarchicIterator, starting from a given entity |
| CIdentityGridLeafIntersection | An intersection with a leaf neighbor elementMesh entities of codimension 0 ("elements") allow to visit all neighbors, where a neighbor is an entity of codimension 0 which has a common entity of codimension 1 These neighbors are accessed via a IntersectionIterator. This allows the implement non-matching meshes. The number of neighbors may be different from the number of an element! |
| CIdentityGridLeafIntersectionIterator | Iterator over all element neighborsMesh entities of codimension 0 ("elements") allow to visit all neighbors, where a neighbor is an entity of codimension 0 which has a common entity of codimension 1 These neighbors are accessed via a IntersectionIterator. This allows the implement non-matching meshes. The number of neighbors may be different from the number of an element! |
| CIdentityGridLeafIterator | Iterator over all entities of a given codimension and level of a grid |
| CIdentityGridLevelIndexSet | |
| CIdentityGridLevelIntersection | |
| CIdentityGridLevelIntersectionIterator | |
| CIdentityGridLevelIterator | Iterator over all entities of a given codimension and level of a grid |
| CIdentityMap | A property map that applies the identity function to integers |
| ►CIdSet | Id Set Interface |
| CCodim | Export the type of the entity used as parameter in the id(...) method |
| CILU0SubdomainSolver | Exact subdomain solver using ILU(p) with appropriate p |
| CILUSubdomainSolver | Base class encapsulating common algorithms of ILU0SubdomainSolver and ILUNSubdomainSolver |
| CImplementationDefined | Dummy struct used for documentation purposes |
| ►CImplicitMatrixBuilder | A wrapper for uniform access to the BCRSMatrix during and after the build stage in implicit build mode |
| Crow_object | Proxy row object for entry access |
| CImplicitModeCompressionBufferExhausted | Thrown when the compression buffer used by the implicit BCRSMatrix construction is exhausted |
| CIndent | Utility class for handling nested indentation in output |
| CIndexInfoFromGrid | Information about the index distribution |
| CIndexPair | A pair consisting of a global and local index |
| ►CIndexSet | Index Set Interface base class |
| CCodim | Export the type of the entity used as parameter in the index(...) method |
| CIndexSetDefaultImplementation | Provide default implementation of method if IndexSet |
| CIndexStack | |
| CIndicesSyncer | Class for recomputing missing indices of a distributed index set |
| CIntegerSequenceEntry | Get entry of std::integer_sequence |
| CIntegralRange | Dynamic integer range for use in range-based for loops |
| CInterface | Communication interface between remote and local indices |
| CInterfaceBuilder | Base class of all classes representing a communication interface |
| CInterfaceInformation | Information describing an interface |
| CInterpolationInterface | Interface for global-valued interpolation |
| CIntersection | Intersection of a mesh entity of codimension 0 ("element") with a "neighboring" element or with the domain boundary |
| CIntersectionDefaultNormalVectors | Default Implementations of integrationOuterNormal and unitOuterNormal for IntersectionImp |
| CIntersectionIterator | Mesh entities of codimension 0 ("elements") allow to visit all intersections with "neighboring" elements and with the domain boundary |
| CIntersectionIteratorWrapper | Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid |
| CInvalidFutureException | This exception is thrown when ready(), wait() or get() is called on an invalid future. A future is valid until get() is called and if it is not default-constructed and it was not moved from |
| CInvalidIndexSetState | Exception indicating that the index set is not in the expected state |
| CInvalidStateException | Default exception if a function was called while the object is not in a valid state for that function |
| CInverseOperator | Abstract base class for all solvers |
| CInverseOperator2Preconditioner | Turns an InverseOperator into a Preconditioner |
| CInverseOperatorResult | Statistics about the application of an inverse operator |
| CIOError | Default exception class for I/O errors |
| Cios_base_all_saver | Utility class for storing and resetting stream attributes |
| CIsCallable | Check if a type is callable with ()-operator and given arguments |
| CIsCallable< F(Args...), R > | Check if a type is callable with ()-operator and given arguments |
| CIsDofManager | Tagging interface to indicate that class is of Type DofManager |
| CIsEmptyTypeList | Check if given type is an empty TypeList |
| CIsFieldVectorSizeCorrect | TMP to check the size of a DenseVectors statically, if possible |
| CIsIndexable | Type trait to determine whether an instance of T has an operator[](I), i.e. whether it can be indexed with an index of type I |
| CIsIntegralConstant | Check if T is an std::integral_constant<I, i> |
| CIsInteroperable | Checks whether two types are interoperable |
| CIsIterable | Typetrait to check that a class has begin() and end() members |
| CIsMatrix | Test whether a type is an ISTL Matrix |
| CIsNumber | Whether this type acts as a scalar in the context of (hierarchically blocked) containers |
| CIsNumber< bigunsignedint< k > > | Declare big unsigned int is a number |
| CISTLError | Derive error class from the base class in common |
| CIsTuple | Check if T is a std::tuple<...> |
| CIsTupleOrDerived | Check if T derived from a std::tuple<...> |
| ►CIsType | Generator for predicates accepting one particular type |
| CPredicate | The actual predicate |
| CIsTypeList | Check if given type is a TypeList |
| CIsTypeList< TypeList< T... > > | Check if given type is a TypeList. |
| ►CIterativeSolver | Base class for all implementations of iterative solvers |
| CIteration | Class for controlling iterative methods |
| CIteratorDirectionSelector | Helper template meta program for application of overlapping Schwarz |
| CIteratorPropertyMap | Adapter to turn a random access iterator into a property map |
| CIteratorRange | Simple range between a begin and an end iterator |
| CIteratorTransformationTag | Tag to enable iterator based transformations in TransformedRangeView |
| CJoinTuples | Join two std::tuple's |
| CL2LocalFiniteElement | Takes the basis factory from a given LocalFiniteElement (derived from GenericLocalFiniteElement) and replaces the coefficients with dg local keys, i.e., attaches all degrees of freedom to the codimension zero entity and uses a l2 interpolation |
| CLagrangeCubeLocalFiniteElement | Lagrange finite element for cubes with arbitrary compile-time dimension and polynomial order |
| CLagrangeLocalFiniteElement | Lagrange local finite elements for a given set of interpolation points |
| CLagrangePrismLocalFiniteElement | Lagrange finite element for 3d prisms with arbitrary compile-time polynomial order |
| CLagrangePyramidLocalFiniteElement | Lagrange finite element for 3d pyramids with compile-time polynomial order |
| CLagrangeSimplexLocalFiniteElement | Lagrange finite element for simplices with arbitrary compile-time dimension and polynomial order |
| CLDL | Use the LDL package to directly solve linear systems – empty default class |
| CLDL< BCRSMatrix< FieldMatrix< T, n, m >, A > > | The LDL direct sparse solver for matrices of type BCRSMatrix |
| CLeafGnuplotWriter | GnuplotWriter on the leaf grid |
| CLeafIntersectionIteratorWrapper | Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid |
| CLeafMultipleCodimMultipleGeomTypeMapper | Multiple codim and multiple geometry type mapper for leaf entities |
| CLeafSingleCodimSingleGeomTypeMapper | Single codim and single geometry type mapper for leaf entities |
| CLevelGnuplotWriter | GnuplotWriter on a given level grid |
| CLevelIntersectionIteratorWrapper | Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid |
| CLevelIntersectionWrapper | Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid |
| CLevelMultipleCodimMultipleGeomTypeMapper | Multiple codim and multiple geometry type mapper for entities of one level |
| CLevelSingleCodimSingleGeomTypeMapper | Single codim and single geometry type mapper for entities of one level |
| CLinearMapping | A linear mapping |
| CLinearOperator | A linear operator |
| CLocalBasisTraits | Type traits for LocalBasisVirtualInterface |
| CLocalBasisVirtualImp | Class for wrapping a basis using the virtual interface |
| CLocalBasisVirtualInterface | Virtual base class for a local basis |
| CLocalCoefficientsVirtualImp | Class for wrapping local coefficients using the virtual interface |
| CLocalCoefficientsVirtualInterface | Virtual base class for local coefficients |
| CLocalFiniteElementFunctionBase | Return a proper base class for functions to use with LocalInterpolation |
| CLocalFiniteElementTraits | Traits helper struct |
| CLocalFiniteElementVariant | Type erasure class for wrapping LocalFiniteElement classes |
| CLocalFiniteElementVariantCache | A cache storing a compile time selection of local finite element implementations |
| CLocalFiniteElementVirtualImp | Class for wrapping a finite element using the virtual interface |
| CLocalFiniteElementVirtualInterface | Virtual base class for local finite elements with functions |
| CLocalGeometryTypeIndex | Compute per-dimension indices for geometry types |
| CLocalIndex | An index present on the local process |
| CLocalInterpolationVirtualImp | Class for wrapping a local interpolation using the virtual interface |
| CLocalInterpolationVirtualInterface | Virtual base class for a local interpolation |
| CLocalInterpolationVirtualInterfaceBase | Virtual base class for a local interpolation |
| CLocalKey | Describe position of one degree of freedom |
| CLocalL2Interpolation | A local L2 interpolation taking a test basis and a quadrature rule |
| CLocalL2InterpolationFactory | A factory class for the local l2 interpolations taking a basis factory |
| CLocalToGlobalBasisAdaptorTraits | Traits class for local-to-global basis adaptors |
| CLocalToGlobalInterpolationAdaptor | Convert a local interpolation into a global interpolation |
| CLoopSIMD | |
| CLoopSolver | Preconditioned loop solver |
| Clru | LRU Cache Container |
| CLvaluePropertyMapTag | Tag for the category of lvalue property maps |
| CMakeableInterfaceObject | |
| CMallocAllocator | Allocators implementation which simply calls malloc/free |
| CMapper | Mapper interface |
| CMathematicalConstants | Provides commonly used mathematical constants |
| CMathError | Default exception class for mathematical errors |
| CMatMultMatResult | Helper TMP to get the result type of a sparse matrix matrix multiplication ( \(C=A*B\)) |
| CMatrix | A generic dynamic dense matrix |
| CMatrixAdapter | Adapter to turn a matrix into a linear operator |
| CMatrixBlockError | Error when performing an operation on a matrix block |
| CMatrixIndexSet | Stores the nonzero entries in a sparse matrix |
| CMessageBufferIF | Communication message buffer interface. This class describes the interface for reading and writing data to the communication message buffer. As message buffers might be deeply implemented in various packages the message buffers implementations cannot be derived from this interface class. Therefore we just apply the engine concept to wrap the message buffer call and make sure that the interface is fulfilled |
| CMetaType | A type that refers to another type |
| CMimeticLocalCoefficients | ! |
| CMimeticLocalFiniteElement | |
| CMINRESSolver | Minimal Residual Method (MINRES) |
| CMonomialFiniteElementFactory | Factory for global-valued MonomFiniteElement objects |
| CMonomialLocalBasis | Constant shape function |
| CMonomialLocalCoefficients | Layout map for monomial finite elements |
| CMonomialLocalFiniteElement | Monomial basis for discontinuous Galerkin methods |
| CMPIFuture | Provides a future-like object for MPI communication. It contains the object that will be received and might contain also a sending object, which must be hold (keep alive) until the communication has been completed |
| CMPIGuard | Detects a thrown exception and communicates to all other processes |
| CMPIGuardError | This exception is thrown if the MPIGuard detects an error on a remote process |
| CMPIHelper | A real mpi helper |
| CMPITraits | A traits class describing the mapping of types onto MPI_Datatypes |
| CMPITraits< IndexPair< TG, ParallelLocalIndex< TA > > > | |
| CMPITraits< ParallelLocalIndex< T > > | |
| CMultiLinearGeometry | Generic geometry implementation based on corner coordinates |
| ►CMultiLinearGeometryTraits | Default traits class for MultiLinearGeometry |
| CCornerStorage | Template specifying the storage for the corners |
| ChasSingleGeometryType | Will there be only one geometry type for a dimension? |
| CMultipleCodimMultipleGeomTypeMapper | Implementation class for a multiple codim and multiple geometry type mapper |
| CMultiplicativeSchwarzMode | Tag that tells the Schwarz method to be multiplicative |
| CMultiTypeBlockMatrix | A Matrix class to support different block types |
| CMultiTypeBlockMatrix_Solver | Solver for MultiTypeBlockVector & MultiTypeBlockMatrix types |
| CMultiTypeBlockMatrix_Solver_Col | Part of solvers for MultiTypeBlockVector & MultiTypeBlockMatrix types |
| CMultiTypeBlockVector | A Vector class to support different block types |
| Cmutable_reference | Get the 'mutable' version of a reference to a const object |
| CNedelec1stKindCubeLocalFiniteElement | Nédélec elements of the first kind for cube elements |
| CNedelec1stKindSimplexLocalFiniteElement | Nédélec elements of the first kind for simplex elements |
| CNedelecL2Interpolation | An L2-based interpolation for Nedelec |
| CNegateSet | The negation of a set. An item is contained in the set if and only if it is not contained in the negated set |
| CNonConformingFaceMapping | |
| CNonConformingFaceMapping< dim, dimworld, hexa, Comm > | Non-conforming face mappings for hexahedra |
| CNonConformingFaceMapping< dim, dimworld, tetra, Comm > | Non-conforming face mappings for tetrahedra |
| CNonoverlappingBlockPreconditioner | Nonoverlapping parallel preconditioner |
| CNonoverlappingSchwarzOperator | A nonoverlapping operator with communication object |
| CNonoverlappingSchwarzScalarProduct | Nonoverlapping Scalar Product with communication object |
| CNotImplemented | Default exception for dummy implementations |
| Cnull_deleter | Implements the Deleter concept of shared_ptr without deleting anything |
| CNullPointerInitialiser | A helper template that initializes a std::tuple consisting of pointers to nullptr |
| COneDGrid | One-dimensional adaptive grid |
| COrthonormalLocalFiniteElement | A class providing orthonormal basis functions |
| COutOfMemoryError | Default exception if memory allocation fails |
| COverlappingSchwarzInitializer | Initializer for SuperLU Matrices representing the subdomains |
| COverlappingSchwarzOperator | An overlapping Schwarz operator |
| COverlappingSchwarzScalarProduct | Scalar product for overlapping Schwarz methods |
| COwnerOverlapCopyAttributeSet | Attribute set for overlapping Schwarz |
| ►COwnerOverlapCopyCommunication | A class setting up standard communication for a two-valued attribute set with owner/overlap/copy semantics |
| CCopyGatherScatter | Gather/scatter callback for communcation |
| CP0LocalBasis | Constant shape function |
| CP0LocalCoefficients | Layout map for P0 elements |
| CP0LocalFiniteElement | The local p0 finite element on all types of reference elements |
| CP0VTKFunction | Take a vector and interpret it as cell data for the VTKWriter |
| CP1VTKFunction | Take a vector and interpret it as point data for the VTKWriter |
| CParallelError | Default exception if an error in the parallel communication of the program occurred |
| ►CParallelIndexSet | Manager class for the mapping between local indices and globally unique indices |
| Citerator | The iterator over the pairs |
| CParallelLocalIndex | An index present on the local process with an additional attribute flag |
| CParallelScalarProduct | Scalar product for overlapping Schwarz methods |
| CParameterizedObjectFactory | A factory class for parameterized objects |
| CParameterTree | Hierarchical structure of string parameters |
| CParameterTreeParser | Parsers to set up a ParameterTree from various input sources |
| CParameterTreeParserError | Report parser error while reading ParameterTree |
| CParSSOR | A parallel SSOR preconditioner |
| CPartitionSet | A set of PartitionType values |
| CPersistentContainer | A class for storing data during an adaptation cycle |
| CPersistentContainer< const Grid, T > | Refer PersistentContainer<const Grid> to the implementation of the mutable grid |
| CPersistentContainer< YaspGrid< dim, CoordCont >, T > | Specialization of the PersistentContainer for YaspGrid |
| CPersistentContainerInterface | Persistent storage of data on all entities of a grid |
| CPersistentContainerMap | Map-based implementation of the PersistentContainer |
| CPersistentContainerVector | Vector-based implementation of the PersistentContainer |
| CPk1DFiniteElement | Langrange finite element of arbitrary order on triangles |
| CPk1DFiniteElementFactory | Factory for Pk1DFiniteElement objects |
| CPk2DFiniteElement | Langrange finite element of arbitrary order on triangles |
| CPk2DFiniteElementFactory | Factory for Pk2DFiniteElement objects |
| CPointerPairDeletor | Deletes all objects pointed to in a std::tuple of pointers |
| CPolynomialBasis | |
| CPolynomialBasisWithMatrix | |
| CPool | A memory pool of objects |
| ►CPoolAllocator | An allocator managing a pool of objects for reuse |
| Crebind | Rebind the allocator to another type |
| CPower | Compute power for a run-time base and a compile-time integer exponent |
| ►CPowerBasis | Meta-basis turning a scalar basis into vector-valued basis |
| CTraits | Types of domain and range |
| CPowerCoefficients | Meta-coefficients turning a scalar coefficients into vector-valued coefficients |
| ►CPowerFiniteElement | Meta-finite element turning a scalar finite element into vector-valued one |
| CTraits | Types of component objects |
| CPowerFiniteElementFactory | Factory for meta-finite elements turning scalar finite elements into vector-valued ones |
| CPowerInterpolation | Meta-interpolation turning a scalar interpolation into vector-valued interpolation |
| CPowerIteration_Algorithms | Iterative eigenvalue algorithms based on power iteration |
| CPQkLocalFiniteElementCache | A cache that stores all available Pk/Qk like local finite elements for the given dimension and order |
| CPQkLocalFiniteElementFactory | Factory to create any kind of Pk/Qk like element wrapped for the virtual interface |
| CPreconditioner | Base class for matrix free definition of preconditioners |
| CPriorityTag | Helper class for tagging priorities |
| CPriorityTag< 0 > | Helper class for tagging priorities |
| CPromotionTraits | Compute type of the result of an arithmetic operation involving two different number types |
| CPropertyMapTypeSelector | Selector for the property map type |
| CPseudoFuture | A wrapper-class for a object which is ready immediately |
| CPushBackTuple | Helper template to append a type to a std::tuple |
| CPushFrontTuple | Helper template to prepend a type to a std::tuple |
| CQ1FiniteElementFactory | Factory for global-valued Q1 elements |
| CQ2FiniteElementFactory | Factory for global-valued Q23D elements |
| CQuadratureOrderOutOfRange | Exception thrown if a desired QuadratureRule is not available, because the requested order is to high |
| CQuadraturePoint | Single evaluation point in a quadrature rule |
| CQuadratureRule | Abstract base class for quadrature rules |
| CQuadratureRuleFactory | Factory class for creation of quadrature rules, depending on GeometryType, order and QuadratureType |
| CQuadratureRules | A container for all quadrature rules of dimension dim |
| CRandomAccessIteratorFacade | Base class for stl conformant forward iterators |
| CRangeError | Default exception class for range errors |
| CRannacherTurekLocalBasis | Rannacher-Turek shape functions |
| CRannacherTurekLocalCoefficients | Layout for Rannacher-Turek elements |
| CRannacherTurekLocalFiniteElement | Rannacher-Turek shape functions |
| CRannacherTurekLocalInterpolation | Please doc me |
| CRaviartThomasCubeLocalFiniteElement | Raviart-Thomas local finite elements for cubes |
| CRaviartThomasCubeLocalFiniteElement< D, R, 2, 0 > | Raviart-Thomas local finite elements for cubes with dimension 2 and order 0 |
| CRaviartThomasCubeLocalFiniteElement< D, R, 2, 1 > | Raviart-Thomas local finite elements for cubes with dimension 2 and order 1 |
| CRaviartThomasCubeLocalFiniteElement< D, R, 2, 2 > | Raviart-Thomas local finite elements for cubes with dimension 2 and order 2 |
| CRaviartThomasCubeLocalFiniteElement< D, R, 2, 3 > | Raviart-Thomas local finite elements for cubes with dimension 2 and order 3 |
| CRaviartThomasCubeLocalFiniteElement< D, R, 2, 4 > | Raviart-Thomas local finite elements for cubes with dimension 2 and order 4 |
| CRaviartThomasCubeLocalFiniteElement< D, R, 3, 0 > | Raviart-Thomas local finite elements for cubes with dimension 3 and order 0 |
| CRaviartThomasCubeLocalFiniteElement< D, R, 3, 1 > | Raviart-Thomas local finite elements for cubes with dimension 3 and order 1 |
| CRaviartThomasL2Interpolation | An L2-based interpolation for Raviart Thomas |
| CRaviartThomasSimplexLocalFiniteElement | Raviart-Thomas local finite elements of arbitrary order for simplices of arbitrary dimension |
| CRawStream | Write out data in binary |
| CReadablePropertyMapTag | Tag for the category of readable property maps |
| CReadWritePropertyMapTag | Tag for the category of readable and writable property maps |
| CReduceTuple | Apply reduce with meta binary function to template |
| CReduceTuple< F, Tuple, Seed, 0 > | Apply reduce with meta binary function to template |
| CRefinedP0LocalBasis | Uniformly refined constant shape functions on a unit simplex in R^dim |
| CRefinedP0LocalCoefficients | Layout map for RefinedP0 elements |
| CRefinedP0LocalFiniteElement | Local finite element that is piecewise P0 on a once uniformly refined reference geometry |
| CRefinedP0LocalFiniteElement< D, R, 1 > | Local finite element that is piecewise P0 on a once uniformly refined reference geometry |
| CRefinedP0LocalFiniteElement< D, R, 2 > | Local finite element that is piecewise P0 on a once uniformly refined reference geometry |
| CRefinedP0LocalFiniteElement< D, R, 3 > | Local finite element that is piecewise P0 on a once uniformly refined reference geometry |
| CRefinedP1LocalBasis< D, R, 1 > | Uniformly refined linear Lagrange shape functions in 1D |
| CRefinedP1LocalBasis< D, R, 2 > | Uniformly refined linear Lagrange shape functions on the triangle |
| CRefinedP1LocalBasis< D, R, 3 > | Uniformly refined linear Lagrange shape functions on the 3D-simplex (tetrahedron) |
| CRefinedP1LocalFiniteElement | Piecewise linear continuous Lagrange functions on a uniformly refined simplex element |
| CRefinedSimplexLocalBasis< D, 1 > | Base class for LocalBasis classes based on uniform refinement in 1D; provides numbering and local coordinates of subelements |
| CRefinedSimplexLocalBasis< D, 2 > | Base class for LocalBasis classes based on uniform refinement in 2D; provides numbering and local coordinates of subelements |
| CRefinedSimplexLocalBasis< D, 3 > | Base class for LocalBasis classes based on uniform refinement in 3D; provides numbering and local coordinates of subelements |
| CRefinementIntervals | Holds the number of refined intervals per axis needed for virtual and static refinement |
| CRemoteIndex | Information about an index residing on another processor |
| CRemoteIndexListModifier | Modifier for adding and/or deleting remote indices from the remote index list |
| CRemoteIndices | The indices present on remote processes |
| CReservedVector | A Vector class with statically reserved memory |
| CRestartedFCGSolver | Accelerated flexible conjugate gradient method |
| CRestartedFlexibleGMResSolver | Implements the Flexible Generalized Minimal Residual (FGMRes) method (right preconditioned) |
| CRestartedGMResSolver | Implements the Generalized Minimal Residual (GMRes) method |
| CRichardson | Richardson preconditioner |
| CRT02DLocalBasis | Lowest order Raviart-Thomas shape functions on the reference triangle |
| CRT02DLocalCoefficients | Layout map for RT0 elements |
| CRT02DLocalFiniteElement | Zero order Raviart-Thomas shape functions on triangles |
| CRT03DLocalBasis | Lowest order Raviart-Thomas shape functions on the reference tetrahedron |
| CRT03DLocalCoefficients | Layout map for RT0 elements |
| CRT03DLocalFiniteElement | Zero order Raviart-Thomas shape functions on tetrahedra |
| CRT0Cube2DLocalBasis | Lowest order Raviart-Thomas shape functions on the reference quadrilateral |
| CRT0Cube2DLocalCoefficients | Layout map for RT0 elements on quadrilaterals |
| CRT0Cube2DLocalFiniteElement | Zero order Raviart-Thomas shape functions on rectangles |
| CRT0Cube2DLocalInterpolation | Lowest order Raviart-Thomas shape functions on the reference quadrilateral |
| CRT0Cube3DLocalBasis | Lowest order Raviart-Thomas shape functions on the reference hexahedron |
| CRT0Cube3DLocalCoefficients | Layout map for RT0 elements on quadrilaterals |
| CRT0Cube3DLocalFiniteElement | Zero order Raviart-Thomas shape functions on cubes |
| CRT0Cube3DLocalInterpolation | Lowest order Raviart-Thomas shape functions on the reference hexahedron |
| CRT0PrismLocalBasis | First order Raviart-Thomas shape functions on the reference prism |
| CRT0PrismLocalCoefficients | Layout map for Raviart-Thomas-1 elements on prisms |
| CRT0PrismLocalFiniteElement | First order Raviart-Thomas shape functions on prisms |
| CRT0PrismLocalInterpolation | First order Raviart-Thomas shape functions on the reference prism |
| CRT0PyramidLocalBasis | First order Raviart-Thomas shape functions on the reference pyramid |
| CRT0PyramidLocalCoefficients | Layout map for Raviart-Thomas-1 elements on pyramids |
| CRT0PyramidLocalFiniteElement | First order Raviart-Thomas shape functions on pyramids |
| CRT0PyramidLocalInterpolation | First order Raviart-Thomas shape functions on the reference hexahedron |
| CRT12DLocalBasis | First order Raviart-Thomas shape functions on the reference triangle |
| CRT12DLocalCoefficients | Layout map for Raviart-Thomas-1 elements on the reference triangle |
| CRT12DLocalFiniteElement | First order Raviart-Thomas shape functions on triangles |
| CRT12DLocalInterpolation | First order Raviart-Thomas shape functions on the reference quadrilateral |
| CRT1Cube2DLocalBasis | First order Raviart-Thomas shape functions on the reference quadrilateral |
| CRT1Cube2DLocalCoefficients | Layout map for Raviart-Thomas-1 elements on quadrilaterals |
| CRT1Cube2DLocalFiniteElement | First order Raviart-Thomas shape functions on quadrilaterals |
| CRT1Cube2DLocalInterpolation | First order Raviart-Thomas shape functions on the reference quadrilateral |
| CRT1Cube3DLocalBasis | First order Raviart-Thomas shape functions on the reference hexahedron |
| CRT1Cube3DLocalCoefficients | Layout map for Raviart-Thomas-1 elements on quadrilaterals |
| CRT1Cube3DLocalFiniteElement | First order Raviart-Thomas shape functions on cubes |
| CRT1Cube3DLocalInterpolation | First order Raviart-Thomas shape functions on the reference hexahedron |
| CRT2Cube2DLocalBasis | Second order Raviart-Thomas shape functions on the reference quadrilateral |
| CRT2Cube2DLocalCoefficients | Layout map for Raviart-Thomas-2 elements on quadrilaterals |
| CRT2Cube2DLocalFiniteElement | Second order Raviart-Thomas shape functions on cubes |
| CRT2Cube2DLocalInterpolation | Second order Raviart-Thomas shape functions on the reference triangle |
| CRT3Cube2DLocalBasis | Second order Raviart-Thomas shape functions on the reference quadrilateral |
| CRT3Cube2DLocalCoefficients | Layout map for Raviart-Thomas-3 elements on quadrilaterals |
| CRT3Cube2DLocalFiniteElement | Second order Raviart-Thomas shape functions on cubes |
| CRT3Cube2DLocalInterpolation | Second order Raviart-Thomas shape functions on the reference quadrilateral |
| CRT4Cube2DLocalBasis | Second order Raviart-Thomas shape functions on the reference quadrilateral |
| CRT4Cube2DLocalCoefficients | Layout map for Raviart-Thomas-4 elements on quadrilaterals |
| CRT4Cube2DLocalFiniteElement | Second order Raviart-Thomas shape functions on cubes |
| CRT4Cube2DLocalInterpolation | Second order Raviart-Thomas shape functions on the reference triangle |
| CScalarLocalToGlobalBasisAdaptor | Convert a simple scalar local basis into a global basis |
| CScalarLocalToGlobalFiniteElementAdaptor | Convert a simple scalar local finite element into a global finite element |
| CScalarLocalToGlobalFiniteElementAdaptorFactory | Factory for ScalarLocalToGlobalFiniteElementAdaptor objects |
| CScalarProduct | Base class for scalar product and norm computation |
| CScaledIdentityMatrix | A multiple of the identity matrix of static size |
| CSelection | A cached selection of indices |
| CSelectionIterator | A const iterator over an uncached selection |
| CSeqILDL | Sequential ILDL preconditioner |
| CSeqILU | Sequential ILU preconditioner |
| CSeqJac | The sequential jacobian preconditioner |
| CSeqOverlappingSchwarz | Sequential overlapping Schwarz preconditioner |
| CSeqOverlappingSchwarzApplier | Helper template meta program for application of overlapping Schwarz |
| CSeqOverlappingSchwarzDomainSize | |
| CSeqScalarProduct | Default implementation for the scalar case |
| CSeqSOR | Sequential SOR preconditioner |
| CSeqSSOR | Sequential SSOR preconditioner |
| CSimdScalarTypeTraits< AlignedNumber< T, align > > | Deduce the underlying scalar data type of an AlignedNumber |
| CSingleCodimSingleGeomTypeMapper | Implementation class for a single codim and single geometry type mapper |
| CSingleton | An adapter to turn a class into a singleton |
| CSizeCache | Organizes the caching of sizes for one grid and one GeometryType |
| CSizeOf | Compute size of variadic type list |
| CSizeOne | Flag for marking indexed data structures where data at each index is of the same size |
| CSLList | A single linked list |
| CSLListConstIterator | A constant iterator for the SLList |
| CSLListIterator | A mutable iterator for the SLList |
| CSLListModifyIterator | A mutable iterator for the SLList |
| CSolverAbort | Thrown when a solver aborts due to some problem |
| CSolverCategory | Categories for the solvers |
| CSolverFactory | Factory to assembly solvers configured by a ParameterTree |
| ►CSolverHelper | Helper class for notifying a DUNE-ISTL linear solver about a change of the iteration matrix object in a unified way, i.e. independent from the solver's type (direct/iterative) |
| CImplementation | Implementation that works together with iterative ISTL solvers, e.g. Dune::CGSolver or Dune::BiCGSTABSolver |
| CImplementation< true, Dummy > | Implementation that works together with direct ISTL solvers, e.g. Dune::SuperLU or Dune::UMFPack |
| CSPAnisotropicRefinement | User may choose freely along which axes the grid should be refined |
| CSPBisectionRefinement | Each element is split into 2 children |
| CSPDomain | Description of the computational domain |
| CSPEntitySeed | Entity seed for SPGrid |
| CSPGrid | Structured, parallel DUNE grid |
| CSPIntersection | |
| CSPIsotropicRefinement | Each element is split into 2dim children |
| CSPMultiIndex | Multiindex |
| CSPQR | Use the SPQR package to directly solve linear systems – empty default class |
| CSPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > > | The SPQR direct sparse solver for matrices of type BCRSMatrix |
| CSPTopology | Description of the grid's topology |
| CStandardMathematicalConstants | Standard implementation of MathematicalConstants |
| CStarCDReader | File reader for the Star-CD format |
| CStaticIntegralRange | Static integer range for use in range-based for loops |
| CStaticPower | Calculates b^p at compile time |
| ►CStaticRefinement | Wrap each Refinement implementation to get a consistent interface |
| CCodim | The Codim struct inherited from the Refinement implementation |
| CStructuredGridFactory | Construct structured cube and simplex grids in unstructured grid managers |
| CStructuredGridFactory< AlbertaGrid< dim, dimworld > > | Specialization of the generic StructuredGridFactory for AlbertaGrid |
| CStructuredGridFactory< YaspGrid< dim, EquidistantCoordinates< ctype, dim > > > | Specialization of the StructuredGridFactory for YaspGrid |
| CStructuredGridFactory< YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > > > | Specialization of the StructuredGridFactory for YaspGrid<EquidistantOffsetCoordinates> |
| CSubsamplingVTKWriter | Writer for the output of subsampled grid functions in the vtk format |
| CSuperLU | SuperLu Solver |
| CSuperLUMatrix | Utility class for converting an ISTL Matrix into a SuperLU Matrix |
| CSuperLUMatrix< BCRSMatrix< B, TA > > | Converter for BCRSMatrix to SuperLU Matrix |
| CSurfaceNormalCalculator | A bilinear surface mapping |
| CSymmetricMultiplicativeSchwarzMode | Tag that tells the Schwarz method to be multiplicative and symmetric |
| CSystemError | Default exception class for OS errors |
| CTensorGridFactory | A factory class for conveniently creating tensorproduct grids |
| CTensorProductCoordinates | Coordinate container for a tensor product YaspGrid |
| CTimer | A simple stop watch |
| CTopologyFactory | Provide a factory over the generic topologies |
| CTopologySingletonFactory | A wrapper for a TopologyFactory providing singleton storage. Same usage as TopologyFactory but with empty release method an internal storage |
| ►CTorus | |
| CProcListIterator | |
| CTransformedRangeView | A range transforming the values of another range on-the-fly |
| CTransformTupleFunctor | |
| CTransposedMatMultMatResult | Helper TMP to get the result type of a sparse matrix matrix multiplication ( \(C=A*B\)) |
| CTrilinearMapping | |
| CTupleVector | A class augmenting std::tuple by element access via operator[] |
| CTypeListElement< i, TypeList< T... > > | Get element of TypeList |
| CTypeListSize< TypeList< T... > > | Get size of TypeList |
| CUGGrid | Front-end for the grid manager of the finite element toolbox UG3 |
| CUMFPack | The UMFPack direct sparse solver |
| CUncachedSelection | An uncached selection of indices |
| CUnity | A class representing the unit of a given Field |
| CValueTransformationTag | Tag to enable value based transformations in TransformedRangeView |
| ►CVariableBlockVector | A Vector of blocks with different blocksizes |
| CCreateIterator | Iterator class for sequential creation of blocks |
| CRealIterator | Iterator class for sequential access |
| CVariableSize | Flag for marking indexed data structures where the data at each index may be a variable multiple of another type |
| CVariableSizeCommunicator | A buffered communicator where the amount of data sent does not have to be known a priori |
| ►CVertexOrderByIdFactory | Factory for GeneralVertexOrder objects using an IdSet |
| CVertexOrder | Type of vertex order object may depend on the dimension of the element |
| CVirtualFunction | Virtual base class template for function classes |
| ►CVirtualRefinement | VirtualRefinement base class |
| CCodim | Codim database of VirtualRefinement |
| CVTKFunction | A base class for grid functions with any return type and dimension |
| CVTKSequenceWriter | Writer for the ouput of grid functions in the vtk format |
| CVTKSequenceWriterBase | Base class to write pvd-files which contains a list of all collected vtk-files |
| ►CVTKWriter | Writer for the ouput of grid functions in the vtk format |
| CCellIterator | Iterator over the grids elements |
| CCornerIterator | Iterate over the elements' corners |
| CVertexIterator | Iterate over the grid's vertices |
| ►CVTKLocalFunction | Type erasure wrapper for VTK data sets |
| CFunctionWrapper | Type erasure implementation for functions conforming to the dune-functions LocalFunction interface |
| CFunctionWrapperBase | Base class for polymorphic container of underlying data set |
| CGlobalFunctionWrapper | Type erasure implementation for C++ functions, i.e., functions that can be evaluated in global coordinates |
| CVTKFunctionWrapper | Type erasure implementation for legacy VTKFunctions |
| CWritablePropertyMapTag | Tag for the category of writable property maps |
| CYaspEntitySeed | Describes the minimal information necessary to create a fully functional YaspEntity |
| CYaspFixedSizePartitioner | Implement partitioner that gets a fixed partitioning from an array If the given partitioning doesn't match the number of processors, the grid should be distributed to, an exception is thrown |
| CYaspGeometry | The general version that handles all codimensions but 0 and dim |
| CYaspGeometry< 0, cdim, GridImp > | Specialization for dim=0, this is a vertex |
| CYaspGeometry< mydim, mydim, GridImp > | Specialize for dim=dimworld, i.e. a volume element |
| CYaspGlobalIdSet | Persistent, globally unique Ids |
| CYaspGrid | [ provides Dune::Grid ] |
| CYaspHierarchicIterator | YaspHierarchicIterator enables iteration over son entities of codim 0 |
| CYaspIndexSet | Implementation of Level- and LeafIndexSets for YaspGrid |
| CYaspIntersection | YaspIntersection provides data about intersection with neighboring codim 0 entities |
| CYaspIntersectionIterator | YaspIntersectionIterator enables iteration over intersections with neighboring codim 0 entities |
| CYaspLevelIterator | Iterates over entities of one grid level |
| CYaspPersistentContainerIndex | Implement a consecutive index for all entities of given codim of a YaspGrid |
| ►CYGrid | Implements a collection of YGridComponents which form a codimension Entities of given codimension c need to be represented by d choose c YgridComponents. All entities in one such component share the same set of spanning unit vectors. A YGrid is used to iterate over the entire set of components the codimension consists of. It doesn't hold any data, but instead holds an iterator range into an array of components (which is owned by YGridLevel) |
| CIterator | Iterator over a collection o YGrids A YGrid::Iterator is the heart of an entity in YaspGrid |
| ►CYGridComponent | |
| CIterator | |
| ►CYGridList | Implements a collection of multiple std::deque<Intersection> Intersections with neighboring processors are stored as std::deque<Intersection>. Eachsuch intersection only holds one YGridComponent. To do all communication associated with one codimension, multiple such deques have to be concatenated. YGridList manges this concatenation. As for YGrids, YGridList doesn't hold any data, but an iterator range into a data array owned by YGridLevel |
| CIntersection | Type describing an intersection with a neighboring processor |
| CYLoadBalance | Base class for the yaspgrid partitioning strategy |
| CYLoadBalanceDefault | Implement the default load balance strategy of yaspgrid |
| CYLoadBalancePowerD | Implement yaspgrid load balance strategy for P=x^{dim} processors |
| CZero | A class representing the zero of a given Field |
| ►Nstd | STL namespace |
| Ctuple_element< i, Dune::MultiTypeBlockMatrix< Args... > > | Make std::tuple_element work for MultiTypeBlockMatrix |
| Ctuple_element< i, Dune::MultiTypeBlockVector< Args... > > | Make std::tuple_element work for MultiTypeBlockVector |
| CDGFWriter | Write a GridView to a DGF file |
| CGlobalBasisMoc | A Dummy global basis |
| CHybridSizeInfoDummy | A Dummy size provider |
| CMatrixInfo | Class template which yields information related to a square matrix like its spectral (i.e. 2-norm) condition number |
| CMCMGElementEdgeLayout | Layout template for edges and elements This layout template is for use in the MultipleCodimMultipleGeomTypeMapper. It selects edges and elements (entities with dim=1 or dim=dimgrid) |
| CMPIError | MPI Error. Thrown when an mpi error occurs |
| CTestPartial | Helper class to test the 'partial' method |
|
Legal Statements / Impressum |
Hosted by TU Dresden |
generated with Hugo v0.111.3
(Jan 5, 23:30, 2025)