| ►Nboost | |
| ►Nfusion | |
| ►Nresult_of | |
| Cmake_range | A meta-function defining a boost::fusion iterator range from given sequence indices |
| ►NBridge | |
| ►CFixedSystemLinearization | Linearization Implementation for a fixed system, i.e. an inherently finite dimensional system, may be a template parameter Functional |
| CEmpty | |
| CIPLinearization | Linearization for Constrained Optimization with Barrier methods |
| CLinearizationTraits< Dune::BlockVector< T >, Functional > | |
| CLinearizationTraits< VariableSet< Descr >, IPFunctional< Functional, BarrierFu, paralin > > | Traits class to choose the right Bridge::Linearization class |
| ►NDune | |
| ►NImpl | |
| CDenseMatrixAssigner< DenseMatrix, typename DenseMatrix::value_type, std::enable_if_t<!Dune::IsNumber< typename DenseMatrix::value_type >::value > > | |
| CAmiraMeshWriter | Provides file writing facilities in the AmiraMesh format |
| CBlockVector | |
| CDenseMatVecTraits< Kaskade::DynamicMatrix< K > > | |
| CDenseMatVecTraits< Kaskade::DynamicMatrixDetail::StridedVector< K > > | |
| CFieldMatrix | |
| CFieldTraits< Kaskade::DynamicMatrix< K > > | |
| CFieldVector | |
| CLeafAmiraMeshWriter | Provides file writing facilities in the AmiraMesh format for leaf grids |
| CLevelAmiraMeshWriter | Provides file writing facilities in the AmiraMesh format for level grids |
| CMatrix | |
| CQuadratureRule | |
| ►NGeometricObject | |
| ►NImplementationDetail | |
| CDistanceImpl | |
| CDistanceImpl< Metric, Scalar, dim, Ball< Scalar, dim >, BoundingBox< Scalar, dim > > | |
| CDistanceImpl< Metric, Scalar, dim, Ball< Scalar, dim >, Line< Scalar, dim > > | |
| CDistanceImpl< Metric, Scalar, dim, Ball< Scalar, dim >, Point< Scalar, dim > > | |
| CDistanceImpl< Metric, Scalar, dim, Ball< Scalar, dim >, Rectangle< Scalar, dim > > | |
| CDistanceImpl< Metric, Scalar, dim, Point< Scalar, dim >, Line< Scalar, dim > > | |
| CDistanceImpl< Metric, Scalar, dim, Point< Scalar, dim >, Point< Scalar, dim > > | |
| CDistanceImpl< Metric, Scalar, dim, Point< Scalar, dim >, Rectangle< Scalar, dim > > | |
| CIntersectionCheckImpl | |
| CIntersectionCheckImpl< Metric, Scalar, dim, Ball< Scalar, dim >, BoundingBox< Scalar, dim > > | |
| CProjectionImpl | |
| CProjectionImpl< Point< Scalar, dim >, Line< Scalar, dim >, Scalar, dim, ScalarProduct > | |
| CProjectionImpl< Point< Scalar, dim >, Rectangle< Scalar, dim >, Scalar, dim, ScalarProduct > | |
| CBall | A ball |
| CBoundingBox | A bounding box |
| CBoundingBoxWrapper | |
| CBoundingBoxWrapper< BoundingBox< Scalar, dim > > | |
| CBoundingBoxWrapper< FastBoundingBox< Scalar, dim > > | |
| CFastBoundingBox | |
| CLine | |
| CPoint | |
| CRectangle | |
| CTriangle | |
| ►NKaskade | |
| ►NAdaptationStrategy_Detail | |
| CAdd | |
| CBiggerThanAbs | |
| ►NAdaptivity | |
| CErrorEquilibration | |
| CErrorEquilibration2 | |
| CFixedCellFraction | |
| CFixedErrorFraction | |
| ►NAssemblyDetail | |
| CFill | Specialize this template for your matrix type in order to use it with VariationalFunctionalAssembler::template get<Matrix>() or MatrixRepresentedOperator::template get<Matrix>() |
| CFill< Dune::BCRSMatrix< Dune::FieldMatrix< Scalar, 1, 1 >, Allocator > > | Allows to use Dune::BCRSMatrix with VariationalFunctionalAssembler and classes satisfying the Kaskade::MatrixRepresentedOperator concept |
| CFill< MatrixAsTriplet< Scalar, SparseIndexInt > > | Allows to use Kaskade::MatrixAsTriplet with VariationalFunctionalAssembler and classes satisfying the Kaskade::MatrixRepresentedOperator concept |
| CFill< NumaBCRSMatrix< Dune::FieldMatrix< Scalar, 1, 1 >, Index > > | Allows to use NumaBCRSMatrix with VariationalFunctionalAssembler and classes satisfying the Kaskade::MatrixRepresentedOperator concept |
| ►NBDDC | |
| CBDDCSolver | Balanced Domain Decomposition with Constraints preconditioner |
| CInterfaceAverages | A class for computing and providing BDDC coarse space constraints (interface averages) |
| CKKTSolver | A class for solving a block-diagonal-structured KKT system |
| CLocalDof | A pair \( (s,i) \) of subdomain id \( s \) and local dof index \( i \) denotes a subdomain-local reference to a global dof |
| CSharedMemoryDomain | A class that orchestrates the exchange of data between BDDC subdomains |
| CSpaceTransfer | A trivial BDDC space transfer |
| CSpaceTransferBase | Base class for BDDC SpaceTransfer implementations |
| CSubdomain | A class representing small KKT systems on a single subdomain |
| ►NBoundaryLocatorDetail | |
| CSpatialIndex | |
| CZeroDisplacement | |
| ►NBoundarySpace_Detail | |
| CChooseMapper | Choose implementation for mapper. Not the best design, but works.. |
| CChooseMapper< ContinuousHierarchicExtensionMapper< Scalar, GridView > > | |
| CChooseMapper< ContinuousHierarchicMapper< Scalar, GridView > > | |
| CChooseMapper< ContinuousLagrangeMapper< Scalar, GridView > > | |
| CChooseMapper< DiscontinuousHierarchicMapper< Scalar, GridView > > | |
| CChooseMapper< DiscontinuousLagrangeMapper< Scalar, GridView > > | |
| CGetSFDataType | |
| CGetSFDataType< ContinuousHierarchicExtensionMapper< Scalar, GridView > > | |
| CGetSFDataType< ContinuousHierarchicMapper< Scalar, GridView > > | |
| CGetSFDataType< ContinuousLagrangeMapper< Scalar, GridView > > | |
| CShapeFunctionSetRestriction | Get restricted shape function set for simplicial grid |
| CShapeFunctionSetRestriction< ContinuousHierarchicExtensionMapperImplementation< Scalar, GridView, Data > > | |
| CShapeFunctionSetRestriction< ContinuousHierarchicMapperImplementation< Scalar, GridView, Data > > | |
| CShapeFunctionSetRestriction< ContinuousLagrangeMapperImplementation< Scalar, GridView, Data > > | |
| ►NBridge | Namespace of Classes that implement the abstract interface classes via the bridge-pattern |
| CAdaptiveGrid | Implements AbstractAdaptiveGrid, uses a bulk criterion as a marking strategy |
| CC1ParameterFunctional | A functional that may depend on parameters, implements AbstractC1ParameterFunctional |
| CConnectedLinearization | |
| CDirectInnerSolver | |
| CErrorEstimator | Bridge class for an error estimator, implements AbstractErrorEstimator |
| CFunctional | Object that represents the linearization of a nonlinear functional, implements AbstractLineariztion |
| CKaskadeLinearization | Bridge::Linearization class that uses a VariationalFunctionalAssembler to create linear systems |
| CKaskadeNormalStepFunctional | Bridge class for Functionals. Its most prominent task is to create linearizations, implements AbstractFunctional |
| CKaskadeTangentialStepFunctional | Bridge class for Functionals. Its most prominent task is to create linearizations, implements AbstractFunctional |
| CLinearization | |
| CLinearizationTraits | Traits class to choose the right linearization class |
| CNormalStepLinearization | |
| CParameterFunctional | A functional that may depend on parameters, implements AbstractParameterFunctional |
| CPINVSolver | |
| CProjTCGSolver | |
| CSpaceTransfer | |
| CTangentialStepLinearization | |
| CTCGSolver | |
| CVector | Mathematical Vector that supports copy-on-write, implements AbstractFunctionSpaceElement |
| CVectorTraits | Traits class to unify the assignment of std::vector to a Vector |
| ►CVectorTraits< VariableSet< Descr > > | Specialization for variable sets |
| CComponentWiseScalarMult | |
| ►NCellLocatorDetail | |
| CSpatialIndex | |
| ►NCG_Detail | |
| CChooseRegularization | |
| CNoRegularization | |
| CRegularization | |
| ►NCoarseningDetail | |
| ►CCreateProjection | |
| Cresult | |
| Cresult< CreateProjection(SpacePtr)> | |
| CGetLocalTransferProjection | |
| CGroupByCell | |
| CProjectCoefficients | |
| CProjector | |
| ►NCrsutil_Detail | |
| CVectorTraits | |
| CVectorTraits< Dune::BlockVector< Entry > > | |
| CVectorTraits< Dune::FieldVector< Entry, n > > | |
| ►NDirectSolver_Detail | |
| CHasFieldType | |
| CHasScalar | |
| CNoFieldType | |
| CNoScalar | |
| CScalarType | |
| ►NDynamicMatrixDetail | |
| Ccat | |
| Ccat< Entry, Entry > | |
| CCopy | |
| CCopy< Dune::FieldMatrix< A, n, m >, Dune::FieldMatrix< B, n, m > > | |
| CGetAddress | |
| CGetAddress< Dune::BlockVector< K, A > > | |
| CGetAddress< Dune::FieldMatrix< K, n, m > > | |
| CGetAddress< Dune::FieldVector< K, n > > | |
| CProductTraits | |
| CProductTraits< Dune::FieldMatrix< EntryA, n, m >, Dune::FieldMatrix< EntryB, m, k >, void > | |
| CProductTraits< Scalar, Scalar, std::enable_if_t< std::is_arithmetic_v< Scalar > > > | |
| CStridedVector | |
| ►NElastomechanics | |
| ►NMaterialLaws | A namespace containing various material laws |
| CBlatzKo | Blatz-Ko material law for rubber foams in terms of the shifted invariants \( i_1, i_2, i_3 \) of the doubled Green-Lagrange strain tensor \( 2E \) |
| CCompressibleInvariantsMaterialLaw | Adaptor for hyperelastic material laws, providing an easy way to formulate compressible material laws in terms of the invariants of the isochoric part \( \bar C = C/(det C)^(1/d) \) of the Cauchy-Green strain tensor and a penalization of the deviatoric part \( I_d \) |
| CInvariantsMaterialLaw | Adaptor for hyperelastic material laws, providing an easy way to formulate incompressible material laws in terms of the invariants of the Cauchy-Green strain tensor \( C = I+2E\) |
| CMaterialLawBase | Base class for hyperelastic material laws, providing default implementations of the stress and the tangent stiffness tensor \( C \) |
| CMooneyRivlin | Mooney-Rivlin material law formulated in terms of the (shifted) invariants \( i_1, i_2, i_3 \) of the doubled Green-Lagrange strain tensor \( 2E \) |
| CNeoHookean | Neo-Hookean material law formulated in terms of the shifted invariants \( i_1, i_2, i_3 \) of the doubled Green-Lagrange strain tensor \( 2E \) |
| COrthotropicLinearMaterial | Orthotropic linear material law |
| COrthotropicNonLinearMaterial | |
| CStVenantKirchhoff | The St. Venant-Kirchhoff material, foundation of linear elastomechanics |
| CViscoPlasticEnergy | An adaptor for using hyperelastic stored energies for viscoplasticity |
| CDetIpm1 | A class for computing determinants and their derivatives |
| CElasticModulus | Material parameters for isotropic linearly elastic materials |
| CExtendedGreenLagrangeTensor | Full (right) Green-Lagrange strain tensor for displacements from dim-1 to dim |
| CFirstPiolaKirchhoffStress | Represents the first Piola Kirchhoff stress as known in nonlinear elasticity. The Piola-Kirchhoff stress is \( T = F\sigma = (I+u_x) \sigma(u) \) |
| CGreenLagrangeTensor | Full (right) Green-Lagrange strain tensor, the workhorse of hyperelasticity |
| CHyperelasticVariationalFunctional | General base class for variational functionals defined in terms of hyperelastic stored energies |
| CIsochoricGreenLagrangeTensor | Isochoric part of the full (right) Green-Lagrange strain tensor, used in compressible hyperelasticity |
| CLameNavier | Convenience class for handling linear elastomechanics |
| CLinearizedGreenLagrangeTensor | Linearized (right) Green-Lagrange strain tensor, the workhorse of linear elastomechanics |
| COrthotropicLameNavier | Convenience class for handling orthotropic materials in linear elastomechanics |
| CPstable | Numerically stable evaluation of \( (x+1)^p -1 \) |
| CShellEnergy | A stored energy density class for Taylor-based shell models |
| CShellKinematics | A lower-dimensional kinematics ansatz useful for shell models |
| CShellKinematicsDerivative | A lower-dimensional kinematics ansatz useful for shell models |
| CShiftedInvariants | A class for shifted invariants of a tensor |
| CStrainView | A function view that provides on the fly computed strain tensors of displacemnts |
| CSurfaceGreenLagrangeTensor | Full (right) Green-Lagrange strain tensor for displacements from dim-1 to dim |
| ►NErrorestDetail | |
| CGroupedSummationCollector | A Collector coalescing the information of multi-variable functions on cell groups |
| ►NErrorEstimator_Detail | |
| CTraits | |
| ►NFunctional_Aux_Detail | |
| CcheckSymmetry | |
| CcheckSymmetry< Functional,-1 > | |
| ►NFunctionSpace_Detail | |
| CToDomainRepresentation | |
| CToDomainRepresentation< FunctionSpaceElement< FEFunctionSpace< BoundaryMapper< DomainMapper, Scalar, GridView > >, m > > | |
| ►NFunctionViews | Namespace of views on a FunctionSpaceElement Views on Function SpaceElements can be used in a restricted sense like FunctionSpaceElements. The idea is to transform a given function to another function while evaluating it at a certain point. Such a view has provide certain functionality: |
| CAbsSquare | |
| CDifference | |
| CGradient | Derivative of a given finite element function |
| CGradientAbsSquare | A function view returning the square of the Frobenius norm of a function's derivative |
| ►Nifff | Creates a (linear) model to a linearization of a functional |
| Cif_ | |
| Cif_< false > | |
| ►NJacobiPreconditionerDetail | |
| CDiagonalBlock | |
| ►CExtractDiagonal | |
| Cresult | |
| Cresult< ExtractDiagonal(Block)> | |
| CJacobiPreconditionerBase | |
| ►NLinAlg | |
| CEuclideanScalarProduct | Euclidean scalar product |
| CInfinityNorm | Infinity norm for stl-container, Dune::FieldVector and Dune::FieldMatrix |
| CNorm | Norm defined via ScalarProdcut |
| CNormSquared | Norm squared defined via ScalarProduct |
| COneNorm | One norm for stl-container, Dune::FieldVector and Dune::FieldMatrix |
| ►NLinearSpace_Detail | |
| CCopy | |
| CCopy< VariableSet< VSDescriptions >, Space, 0 > | |
| CCopy< VariableSet< VSDescriptions >, Space, id > | |
| ►NMultiGridSolver_Detail | |
| CMultiLevelStack | |
| CParentalNodes | Finds the parent nodes and their interpolation weight for each node in the grid. usage eg.: ParentalNodes<Grid> parentalNodes( gridManager.grid() ); |
| ►NPartitionedSpaceDetail | |
| CAllShapeFunctions | |
| CCompressedFirst | A functor for extracting the first component of a boost compressed pair |
| CEmpty | |
| CFirstLess | |
| CRestrictToBoundary | |
| CSingleTagger | |
| ►NScalarSpaceDetail | |
| CAllShapeFunctions | |
| CCompressedFirst | A functor for extracting the first component of a boost compressed pair |
| CEmpty | |
| CFirstLess | |
| CRestrictToBoundary | |
| ►NSchurPreconditionerDetail | |
| CApplyDirectSolver | |
| CExtractDomainAndRange | |
| CInvertLumpedMatrix | |
| CJacobiIteration | |
| ►NSemiEulerDetail | |
| CSemiImplicitEulerInnerBoundaryPolicyImpl | |
| ►CSemiImplicitEulerInnerBoundaryPolicyImpl< ParabolicEquation, SemiEuler, true > | |
| CInnerBoundaryCache | Evaluates jump contributions at interior faces, suitable for discontinuous Galerkin methods (optional) |
| ►NTaylorHoodPreconditionerDetail | |
| CLocalStokesSolver | Solves small Stokes systems even if incompressibility constraints are linearly dependent |
| ►NThreadedMatrixDetail | |
| CCopyMatrixToChunk | |
| CCopyMatrixToChunk< Entry, Matrix, false, true, Index > | |
| CCopyMatrixToChunk< Entry, Matrix, true, transposed, Index > | |
| CCRSChunk | This class stores a couple of compressed row storage rows in memory allocated locally on a NUMA node |
| CCRSChunkPattern | This class maintains the sparsity structure of a couple of matrix rows (a NUMA matrix chunk) |
| CCRSChunkPatternCreator | A class supporting two-stage construction of sparsity patterns of NUMA matrix chunks |
| CCRSChunkPatternInfo | A base class representing basic meta information about sparsity patterns of NUMA matrix chunks |
| CMatrixEntry | |
| CMatrixEntry< Entry, Entry > | |
| CMatrixEntry< To, From, typename std::is_same< typename To::field_type, typename From::field_type >::type > | |
| CNumaBCRSMatrixConstIterator | |
| CNumaBCRSMatrixConstRowIterator | An iterator stepping through all entries in a row |
| CNumaBCRSMatrixExpression | |
| ►CNumaBCRSMatrixExpressionChunk | |
| Citerator | |
| CNumaBCRSMatrixIterator | |
| CNumaBCRSMatrixRowIterator | |
| CNumaBCRSRow | |
| ►NWeakFunctionViews | Namespace of classes that mimick a FunctionSpaceElement in a very weak sense |
| CConstantGradient | |
| CGridLevel | Get level() of entity in Grid |
| CIsRegular | Return 1, if entity is constructed from red refinement |
| CMightBeCoarsened | Return 1, if entity mightbecoarsened |
| CWasRefined | Return 1, if entity was refined |
| CZeroOrderView | Base class providing int order() |
| ►NXMLHelper | Some helper's for a correct indentation of XML-code |
| CXMLBlock | |
| CAbstractAdaptiveGrid | Representation of an adaptive grid and a simple set of operations thereon |
| CAbstractChart | |
| CAbstractCompositeStepErrorEstimator | Representation of an error estimator |
| CAbstractConnectedLinearization | |
| CAbstractErrorEstimate | Representation of an error estimate, i.e. the output of an error estimator |
| CAbstractErrorEstimator | Representation of an error estimator |
| CAbstractFlushConnection | Abstract connection |
| CAbstractFunctional | Representation of a nonlinear functional |
| CAbstractFunctionSpaceElement | Abstract Vector for function space algorithms |
| CAbstractHierarchicalErrorEstimator | |
| CAbstractLinearization | Abstract linearization |
| CAbstractNewtonDirection | Class that models the functionality of a (possibly inexact) linear solver |
| CAbstractNorm | |
| CAbstractNormalDirection | |
| CAbstractParameterFunctional | Creates a functional from a homotopy of functionals by inserting a parameter |
| CAbstractParameters | Representation of parameters |
| CAbstractPreconditioner | |
| CAbstractScalarProduct | |
| CAbstractTangentialSpace | Class that models the functionality of a (possibly inexact) linear solver |
| CActiveStressModelBase | Convenience base class for active stress generation models providing numerical differentiation |
| CAdaptationCoarseningPolicy | Policy class for LocalTransfer These two structures are used for determining whether to perform a "normal" grid transfer (default, AdaptionCoarseningPolicy), or to calculate prolongation matrices for a FE function space based on a HierarchicIndexSet (see mgtools.hh) |
| CAdaptiveParameters | Parameters that are used by SimpleAdaptiveRefinement |
| CAdditiveMultiGrid | An additive multigrid preconditioner for P1 elements |
| CAdditiveSchwarzPreconditioner | |
| CAddToFunctionSpaceElement | |
| CAddToFunctionSpaceElement< FSE, CoeffVector, rbegin, rbegin > | |
| CAdjointEquationHBErrorEstimator | |
| CAdjointEquationLinearPropagationHBErrorEstimator | |
| CAdjugate | |
| CAdjugate< 2, Source > | |
| CAdjugate< 3, Source > | |
| CAdvectedFunctionView | A weak function view that defines an advected function |
| CAgglomerationPreconditioner | An agglomeration-based preconditioner for elliptic problems discretized with higher-order Lagrange finite elements |
| CAgglomerationPreconditioner< AssembledGalerkinOperator< Assembler, firstRow, firstRow+1, firstCol, firstCol+1, IstlInterfaceDetail::RangeBlockSelector< firstRow, firstRow+1, firstCol, firstCol+1 >, true > > | |
| CAlgorithm | Base class for algorithms. Provides a unified interface and some simple wrapper routines, which perform optional timing, etc |
| CAlievPanfilov | Phenomenological model by Aliev and Panfilov |
| CAlwaysRegularizeWithThetaGuess | |
| CAngleFeatureDetector | Specifying geometric features in terms of angles between face normals and edge tangents |
| CAnotherHBErrorEstimator | |
| CAnsysMeshReader | Reader for Ansys *.inp grid files |
| CApproximateSchurComplement | Approximation of the schur complement according to Pearson/Wathen '10 |
| CApproximateSchurComplement2 | Approximation of the schur complement |
| CARMSPreconditioner | |
| ►CAssembledGalerkinOperator | An adaptor presenting a Dune::LinearOperator <domain_type,range_type> interface to a contiguous sub-blockmatrix of an assembled heterogeneous Galerkin operator |
| CApplyScaleAdd | |
| CTransposedApplyScaleAdd | |
| CBabuskaRheinboldtCriterion | Babuska-Rheinboldt refinement criterion. Determines the refinement thresholds such that all cells with an error contribution exceeding the expected error contribution of the worst cell after refinement will be marked. This tends to equilibrate the error contributions quite fast |
| CBarrier | Barrier<q,p> = sum_{i=p}^{q} Barrier<i,i> |
| CBarrier< 0, 0 > | Logarithmic Barrier functions |
| CBarrier< q, q > | Rational Barrier functions of order q/2+1 (gradient has rational order q/2+1) |
| CBasicGridElement | |
| CBezierMortar | Defines a constraint formulation where samples are weighted by Bezier test functions |
| CBlockDiagonalSchurPreconditioner | |
| CBlockLUFactorization | |
| CBlockSchurParameters | |
| CBoomerAMG | |
| CBoundaryDisplacementByInterpolation | |
| CBoundaryEdge | A class storing a boundary edge consisting of two vertex indices and associated boundary curve tangents |
| CBoundaryFace | A class for representing displaced/deformed boundary faces |
| CBoundaryInterpolationDisplacement | The BoundaryInterpolationDisplacement class provides a Kaskade WeakFunctionView on the displacement from grid to actual domain boundary (which is computed by boundary interpolation) |
| CBoundaryJumpsTimesTestFunction | |
| CBoundaryLocator | |
| ►CBoundaryMapper | A local to global mapper implementation for boundary spaces, with functions defined on the domain boundary (or parts of it) only |
| CElement | Type of the FunctionSpaceElement, associated to the FEFunctionSpace |
| CBoundaryStar | A class storing all the corners (vertex-boundaryface incidences) at a boundary vertex |
| CBoundaryTangents | A class providing information about domain boundary tangent vectors |
| CBulkCriterion | Bulk refinement criterion. Determines the refinement thresholds such that approximately the specified fraction of the total error is removed by the refinement (under the unrealistically optimistic assumption that refinement eliminates the error completely in that cell - in reality, it's only reduced by a certain factor, so the total error is reduced somewhat less) |
| CBWErrorFunction | Obtain an error function by solving local Neumann problems in the flavour of Bank/Weiser |
| CCacheBase | Provides implementations of d1 and d2 for (possibly mixed) use of scalar and power spaces |
| CCachingBoundaryDetector | |
| ►CCardioD2 | |
| CD2 | |
| CCellData | Class that stores information for each cell of a grid |
| CCellLocator | |
| CCellRanges | A class storing cell ranges of roughly equal size for multithreaded mesh traversal |
| CCGBase | Regularized preconditioned conjugate gradient method |
| CCGFminModel | |
| CChebyshevPreconditioner | Preconditioner based on the Chebyshev semi-iteration. In order to provide a linear preconditioner the termination criterion based on relative descent in the energy-norm induced by the preconditioner is disabled here. Instead the preconditioner performs a fixed number of iterations thus yielding a linear preconditioner |
| CChebyshevSemiIteration | Preconditioned chebyshev semi iteration |
| CCheckPoint | |
| CChooseProjectionPolicy | |
| CChooseProjectionPolicy< InexactTangentSpacePreconditioner< Functional, Assembler, components > > | |
| CCircle | |
| CCofactor | |
| CComponents | Helper class for specifying the number of components of a variable |
| CCompositeStep | |
| CConcurrentQueue | A concurrent fifo queue |
| ►CConstantMapper | |
| CCombiner | A class implementing a matrix \( K \) mapping a subset of global degrees of freedom (those given by globalIndices()) to local degrees of freedom (shape functions) |
| CConverter | A class mapping local shape function values and derivatives to global shape function values and derivatives.
|
| CElement | |
| CConstraintD1LipschitzConstant | |
| ►CConstructCoefficientVector | A boost::fusion functor for generating coefficient vectors for given variables |
| Cresult | |
| Cresult< ConstructCoefficientVector< Spaces >(Variable)> | |
| ►CConstructElement | A boost::fusion functor for generating function space elements for given variables |
| Cresult | For a given variable, defines the correct FunctionSpaceElement type |
| Cresult< ConstructElement< Spaces >(Variable)> | |
| ►CContinuousHierarchicExtensionMapper | A degrees of freedom manager for globally continuous FEFunctionSpace s of piecewise polynomials |
| CElement | |
| CContinuousHierarchicExtensionMapperImplementation | |
| ►CContinuousHierarchicMapper | A degrees of freedom manager for globally continuous FEFunctionSpace s of piecewise polynomials |
| CElement | |
| CContinuousHierarchicMapperImplementation | |
| CContinuousLagrangeBoundaryMapper | |
| ►CContinuousLagrangeMapper | A degrees of freedom manager for globally continuous FEFunctionSpace s of piecewise polynomials |
| CElement | |
| CContinuousLagrangeMapperImplementation | |
| ►CContinuousLagrangeMapperSubdomain | A local-to-global mapper for continuous finite elements on a subdomain |
| CElement | |
| CContinuousLagrangeMapperSubdomainImplementation | |
| CContinuousScalarFunction | |
| CContractionModelFunction | |
| CConvertTo | Reports the converted type |
| CConvertTo< Dune::FieldMatrix< T, n, m >, Real > | |
| CCopyFromFunctionSpaceElement | |
| CCopyFromFunctionSpaceElement< FSE, CoeffVector, rbegin, rbegin > | |
| CCorner | A class storing algebraic and geometric information about a vertex-boundaryface incidence in simplicial grids |
| CCreator | Abstract base class of creators that can be registered at the pluggable factory |
| CCreator< Factorization< Scalar > > | Abstract base class for factorization creators to be plugged into a factorization factory |
| CCSCubicRegularization | |
| Ccsr_matrix | |
| CCube | |
| CCubicModel1dForFmin | |
| CCubicModelFunction | |
| CCUBThetaModelFunction | For optimization with cubic upper bounds method |
| CDampedCovariantNewtonMethod | Damped Newton's method that measures the Newton contraction via a simplified Newton step |
| ►CDampedCovariantNewtonParameters | Paramters that are used and Logged by GuardedCovariantNewtonMethod |
| CLastRejected | |
| CDefaultDualPairing | Default implementation of dual pairing (relies on scalar product operator * being defined) |
| CDefaultProjectionPolicy | |
| CDeformingGridManager | A grid manager for asymptotically \( G^1 \)-continuous domains |
| CDenseCholeskyLocalMatrixStorage | An inverse local matrix representation that simply stores a dense Cholesky factor |
| CDenseCholeskyStorageTag | A parametrized tag type for selecting storage of inverses by dense Cholesky factors with floating point representation of type Scalar |
| CDenseInverseLocalMatrixStorage | An inverse local matrix representation that simply stores the dense inverse |
| CDenseInverseStorageTag | A parametrized tag type for selecting dense storage of inverses with floating point representation of type Scalar |
| CDeprecated | Convenience class for marking deprecated functions. A static object of this class can be created inside deprecated functions. It will output a warning message to stderr if the deprecated function is called, but only once |
| CDerivativeChecker | Class that checks the derivatives of a functional at a linearization point |
| CDetailedException | A wrapper class for conveniently providing exceptions with context information |
| CDeterminant | A class for computing determinants and their derivatives |
| CDeterminant< 2, Source > | |
| CDeterminant< 3, Source > | Determinant |
| CDiagonalCombiner | A base class for implementing combiners with diagonal structure |
| CDifferentiableScalarFunction | |
| ►CDim | Get dimension as nested integral static constexpr |
| CDummy | |
| CEvaluateDim | |
| CEvaluateDim< T, true > | |
| CEvaluateDimension | |
| CEvaluateDimension< T, true > | |
| CDiracMortar | Defines a constraint formulation where each sample is taken as a single constraint of its own |
| CDirectBlockSchurSolver | |
| CDirectLinearSolver | Direct solver.Implements Direct Solver Interface of Algorithms |
| CDirectNormalSolver | |
| CDirectPreconditioner | |
| CDirectPreconditionerFloatWrapper | |
| CDirectSolver | |
| CDirectSolver< Dune::FieldVector< S, n >, Dune::FieldVector< S, n > > | |
| CDirectSolverException | To be raised if a direct solver fails |
| CDirichletNitscheBoundary | Dirichlet boundary conditions by Nitsche's method |
| CDirichletPenaltyBoundary | Dirichlet boundary conditions by the penalty approach |
| ►CDiscontinuousHierarchicExtensionMapper | A degrees of freedom manager for FEFunctionSpace s of piecewise polynomials of given order |
| CElement | |
| CDiscontinuousHierarchicExtensionMapperImplementation | |
| ►CDiscontinuousHierarchicMapper | A degrees of freedom manager for FEFunctionSpace s of piecewise polynomials of order Order |
| CElement | |
| CDiscontinuousHierarchicMapperImplementation | |
| ►CDiscontinuousLagrangeMapper | A degrees of freedom manager for FEFunctionSpace s of piecewise polynomials of order Order |
| CElement | |
| CDiscontinuousLagrangeMapperImplementation | |
| ►CDiscontinuousLagrangeMapperSubdomain | |
| CElement | |
| CDiscreteBlockTraits | |
| CDoNotAlwaysRegularize | |
| CDoNotMeasureTime | |
| CDoRegularization | |
| CDualPairing | Abstract base class for dual pairing of \( X \) and its dual space \( X^* \) |
| CDummy | |
| CDynamicMatrix | A LAPACK-compatible dense matrix class with shape specified at runtime |
| CEdgeScanner | Class to scan functions along the edges of a computational grid |
| CEmbeddedErrorEstimator | Embedded error estimation and mesh refinement |
| CEmptyShapeFunctionSet | |
| CEnergyScalarProduct | |
| CEntityNumbering | |
| CEntryTraits | |
| CEntryTraits< Dune::FieldMatrix< Entry, n, m > > | |
| CEntryTraits< Dune::FieldVector< Entry, n > > | |
| CEntryTraits< Tensor< Entry, Sizes... > > | |
| CEquidistantLagrange | Lagrange shape functions on an equidistant grid over the simplex. These are polynomial basis functions \( p_i \) over the unit simplex, together with interpolation nodes \( \xi_j \), such that \( p_i(\xi_j) = \delta_{ij} \) holds |
| ►CErrorDistribution | |
| CBoundaryCache | |
| CD1 | |
| CD2 | |
| CDomainCache | |
| CErrorEstimationTraits | |
| CErrorEstimatorBase | |
| CEstimatorDescription | |
| CEtaModel | |
| CEuclid | |
| CEulerSDC | Base class to perform SDC iterations based on forward Euler method. Total iterations performed depends on the value set for variable maxSDCiterations |
| CExp | Exponential function of the form a*exp(b*x) |
| CExtrapolationTableau | Polynomial extrapolation following Aitken-Neville |
| ►CFactorization | Abstract base class for matrix factorizations |
| ►CInfo | The Info struct provides output information of direct solvers |
| CMumps | The Mumps struct provides output information specific to MUMPS |
| ►CFactorizationOptions | The Options struct allows to specify several options of factorization |
| CMumps | The Mumps struct allows to specify options which are exclusively relevant for the MUMPS solver |
| CFactory | A pluggable factory |
| ►CFEFunctionSpace | A representation of a finite element function space defined over a domain covered by a grid.
|
| CElement | DEPRECATED use Element_t<m> instead |
| CEvaluator | A helper class that stores all informations necessary to evaluate FE functions at a certain point |
| CFentonKarma | The 3-variable Fenton-Karma membrane model |
| CFileIOException | An exception class for file IO errors |
| CFinalAdaptiveRefinement | Performs error estimation and creates error indicators, but does not refine. Good for testing error estimators |
| CFirstGreater | A comparator functor that supports sorting std::pair by their first component |
| CFirstLess | A comparator functor that supports sorting std::pair by their first component |
| CFixedFractionCriterion | Fixed fraction refinement criterion. Determines the refinement thresholds such that at least the specified fraction of the cells are marked for refinement. This ensures that not too few cells are marked, which could lead to very many refinement iterations, but may lead to erratic refinement if there are indeed only very local refinements necessary |
| CFixedSolverWithErrorEstimate | Performs error estimation and creates error indicators, but does not refine. Good for testing error estimators |
| CForwardingBoundaryDetector | |
| ►CFunctionalBase | Convenience base class for the easy definition of variational functionals and weak formulations |
| CB2 | |
| CD1 | Static a priori default information about the right hand side blocks |
| CD2 | Static a priori default information about the matrix blocks |
| CFunctionSpaceElement | A class for representing finite element functions |
| CFunctionViewAdaptor | An adaptor that allows to turn lambda functions into function views |
| CGaussSeidelPreconditioner | A simple single-level symmetric Gauss-Seidel preconditioner |
| CGaussTimeGrid | Spectral time grid for defect correction methods with Gauss points |
| ►CGbit | Iterative solution of a large linear system using an error based termination-criterium. Includes some special termination-criterium options which are used by the giantGbit code |
| CGbitInfo | |
| CGeometricFeatureDetector | The interface for specifying feature edges and feature vertices |
| CGet | Get object from reference or functor. Is itself a functor |
| CGet< Type, Type > | |
| CGetEvaluators | A boost::fusion functor for creating an evaluator from the space, using a shape function cache that is given on construction of the functor |
| CGetEvaluatorTypes | A boost::fusion functor for extracting the evaluator type from a pointer to a FE space. This is more or less redundant to GetEvaluators, but no shape function cache type needs to be provided |
| ►CGetScalar | Get scalar type from Dune (-> field_type) or Kaskade (-> Scalar) member |
| CExtractScalar | |
| CExtractScalar< LocalType, false, true > | |
| CExtractScalar< LocalType, true, hasFieldType_ > | |
| CTypeNotFound | |
| CGetSubType | |
| CGetSubType< Scalar, dim, Dune::FieldMatrix< Scalar, dim, dim > > | |
| ►CGetVarArgs | A boost::fusion functor for creating a variational arg from the space, using a shape function cache that is given on construction of the functor |
| Cresult | |
| Cresult< GetVarArgs(VD)> | |
| ►CGiant | Solution of a nonlinear system of equations by a damped Newton-method with adaptive precision control of the used iterative linear solver Gbit |
| CNleqInfo | |
| CGlobalBarycentricPermutation | A class for computing permutations of local vertex numbers of simplex subentities to a globally unique ordering |
| CGlobalLocalIndexRelationship | The GlobalLocalIndexRelationship class provides relationships between local indices of (e.g. matrix) blocks and global indices (of the corresponding block matrix) |
| CGoalOrientedErrorEstimator | |
| CGradientAverage | |
| CGradientAverageFull | |
| CGradientJumpsTimesTestFunction | |
| CGridException | An exception class for grid related errors |
| CGridLocking | Grid locking information based on grid type |
| CGridLocking< Dune::GeometryGrid< HostGrid, Deformation, Allocator > > | |
| CGridManager | Class that takes care of the transfer of data (of each FunctionSpaceElement) after modification of the grid |
| CGridManagerBase | Basic functionality for managing grids and their refinement |
| CGridSignals | A class that provides access to signals that are emitted from the grid manager on various occasions |
| CGuardedCovariantNewtonParameters | Paramters that are used and Logged by GuardedCovariantNewtonMethod |
| CH1Norm | H1-norms |
| CH1SemiNorm | H1-semi-norms |
| CHalfGradientJump | |
| CHcurlConverter | A class mapping local vectorial shape function values and gradients to global shape function values and gradients in \( H(\text{curl}) \) conforming FE spaces |
| CHdivConverter | A class mapping local vectorial shape function values and gradients to global shape function values and gradients in \( H(\text{div}) \) conforming FE spaces |
| ►CHdivMapper | Degrees of freedom manager for H(div) conforming elements |
| CCombiner | A class implementing a matrix \( K \) mapping a subset of global degrees of freedom (those given by globalIndices()) to local degrees of freedom (shape functions) |
| CHdivShapeFunctionSetContainer | |
| CHdivSimplexShapeFunction | Vectorial \( H(\text{div}) \) conforming shape functions on the unit simplex |
| CHdivSimplexShapeFunctionSet | A shape function set of \( H(\text{div}) \) conforming functions |
| CHierarchicalBasisErrorEstimator | |
| CHierarchicalBasisErrorEstimator2 | |
| CHierarchicalBasisErrorEstimator3 | |
| CHierarchicalBasisPreconditioner | A hierarchical basis preconditioner |
| CHierarchicErrorEstimator | Defines assembly of hierarchically extended problems for defining DLY style error estimators |
| CHierarchicExtensionMapperImplementation | |
| CHierarchicExtensionShapeFunctionSetContainer | |
| CHierarchicExtensionSimplexShapeFunctionSet | A container of hierarchic shape functions of nominal order Ord on the unit simplex of grid dimension. For Ord<0, this set is empty |
| CHierarchicMapperImplementation | |
| ►CHierarchicMapperImplementationBase | A local to global mapper implementation for scalar hierarchic bases |
| CCombiner | |
| CHierarchicShapeFunctionSetContainer | |
| CHierarchicSimplexShapeFunction | Scalar hierarchic shape functions on the unit simplex |
| CHierarchicSimplexShapeFunctionSet | A container of hierarchic shape functions (see HierarchicSimplexShapeFunction) up to a given nominal order on the unit simplex of grid dimension |
| CHigherOrderRecovery | Construct a higher order estimate for the finite element solution from gradient information |
| CHomogeneousNeumannBoundary | A simple boundary cache implementing homogeneous Neumann boundary conditions |
| CHomotopyBase | Base class for homotopy methods. Here, the main algorithm is programmed |
| CHypIP | |
| CHypIPParameters | |
| CICC_0Preconditioner | Incomplete Cholesky factorization by algorithm from book "Matrix Computations" by Gene Golub & Charles van Loan |
| CIdentityChart | |
| CIdentityPreconditioner | The trivial (identity) preconditioner |
| CIdentityScaling | A trivial Scaling |
| CILUKPreconditioner | |
| CILUTPreconditioner | |
| CInDomainTraits | |
| CInexactTangentSpacePreconditioner | |
| CInexactTangentSpacePreconditionerILU | |
| CInfeasibleProblemException | To be raised if an iterative solver detects the problem to be infeasible (has no valid solution) |
| CIntegral | Evaluation class for integrals |
| CIntegralF | Integral |
| CIntegrator | |
| CInteriorPointParameters | |
| CInteriorPointParametersSqrt | |
| CInteriorPointSimple | Very simple implementation of homotopy method: fixed stepsize |
| CInteriorPointSlopeEstimate | |
| CInteriorPointSqrtModel | InteriorPointMethod with a sqrt-model of the path: eta ~ mu^{-1/2}, omega ~mu^{-1/2} |
| CInteriorPointTangentialPredictor | |
| CInverseLinearOperator | Dune::LinearOperator interface for inverse operators |
| CInverseLocalMatrixStorageBase | A base class providing common functionality for storage of inverse local matrices |
| CInverseVolume | A Weighing that associates to each cell its inverse volume |
| CIOException | An exception class for IO errors |
| CIoOptions | Options for VTK/AMIRA output |
| ►CIPFunctional | Functional that adds barrier terms to VarFu |
| CBoundaryCache | |
| CD1 | |
| CD2 | |
| CDomainCache | |
| CIsFunction | Checks if type is a function or member function |
| CIsotropicCubicRegularization | |
| CIterationParameters | Base class for algorithmic parameters |
| CIterativeSolverException | To be raised if an iterative solver fails |
| CJacobiPreconditioner | |
| CJacobiPreconditioner< AssembledGalerkinOperator< Assembler, firstRow, lastRow, firstCol, lastCol, BlockFilter, symmetric > > | A recursive Jacobi preconditioner for heterogeneous square block matrices from a variational assembler |
| CJacobiPreconditioner< NumaBCRSMatrix< Entry, Index > > | A simple single-level Jacobi preconditioner working on sparse matrices |
| CJacobiPreconditionerForTriplets | |
| CJacobiSolver | |
| CJacobiSolverForTriplets | |
| CJModel | |
| CJModelLin | |
| CKalloc | A simple memory manager for NUMA systems |
| CKallocUnlocked | A class for local memory management |
| CL2Norm | L_2-norms |
| CLagrangeBase | |
| CLagrangeCubeShapeFunction | Scalar Lagrange shape functions on the unit cube |
| CLagrangeCubeShapeFunctionSet | |
| CLagrangeLinearization | |
| ►CLagrangeMapperImplementation | A local to global mapper for scalar Lagrange bases |
| CCombiner | A class implementing a matrix \( K \in \R^{n\times m}\) mapping a subset of \( m \) global degrees of freedom (those given by globalIndices()) to \( n \) local degrees of freedom (shape functions) |
| ►CLagrangeOperator | |
| CNormalStepApplyScaleAdd | |
| CTangentialStepApplyScaleAdd | |
| CLagrangeShapeFunctionSetContainer | |
| CLagrangeSimplexShapeFunction | Scalar Lagrange shape functions on the unit simplex |
| CLagrangeSimplexShapeFunctionSet | A container of Lagrange shape functions of order Ord on the unit simplex of grid dimension. For Ord<0, this set is empty |
| CLagrangianD2LipschitzConstant | |
| CLaplace | Convenience class for handling diffusion terms in elliptic/parabolic equations |
| CLeaveRHS | |
| CLimex | Extrapolated linearly implicit Euler method |
| CLinearAlgebraException | A base class for linear algebra exceptions |
| ►CLinearizationAt | Proxy class for the linearization of a nonlinear functional |
| CD1 | Rhs block information |
| CD2 | Matrix block information |
| ►CLinearizationDifferenceAt | Proxy class for evaluating differences of linearizations of a nonlinear functional |
| CBoundaryCache | |
| CD1 | Rhs block information |
| CD2 | Matrix block information |
| CDomainCache | |
| CLinearProductSpace | |
| CLinesearchException | To be raised if a linesearch fails |
| CLN | Natural logarithm of the form a*\ln(x) |
| CLobattoGridLagrange | |
| CLobattoTimeGrid | Spectral time grid for defect correction methods with Lobatto points on \( [a,b]\) |
| CLocalGeometryInCoarseGridAncestor | |
| CLocalIntegral | Create a CellData by computing local integrals over each Cell |
| CLocalMatrices | A structure for holding a sequence of several local matrices to be filled sequentially and to be scattered jointly |
| CLocalMatrix | Providing a matrix or array interface to LAPACK-ordered entries |
| CLocalNormalMatrixBlock | |
| CLocalNormalMatrixRow | |
| CLocalTransfer | Class that stores for a cell ("this entity" or "father") a local projection matrix |
| CLocalVector | Providing a vector interface for contiguously stored entries |
| CLocalVectors | A structure for holding a sequence of several local vectors to be filled sequentially and to be scattered jointly |
| CLoggedQuantity | Class that represents a quantity that can be logged during the course of an algortihm |
| CLogger | Simple logging facility |
| CLogLogModel | Polynomial model in a loglog scale |
| CLookupException | An exception that can be thrown whenever a key lookup fails |
| CMakeAdditiveSchwarzSmoother | Functor for creating overlapping Schwarz smoothers |
| CMakeJacobiSmoother | Functor for creating Jacobi smoothers |
| CMartinsErrorEstimator | |
| CMaterialAmiraMeshWriter | |
| CMatrix_to_Triplet | A class template that supports converting certain Dune matrices into the coordinate (triplet) format |
| CMatrix_to_Triplet< Dune::BCRSMatrix< Dune::FieldMatrix< K, N, M >, Allocator > > | |
| CMatrix_to_Triplet< Dune::FieldMatrix< K, n, m > > | |
| CMatrix_to_Triplet< NumaBCRSMatrix< Dune::FieldMatrix< K, N, M >, Index > > | |
| CMatrixAsTriplet | |
| CMatrixRepresentedOperator | Operator with matrix-representation and coordinate mappings |
| CMatrixRepresentedOperator< Dune::BCRSMatrix< MatrixBlock, Allocator >, Domain_, Range_ > | |
| CMatrixRepresentedOperator< MatrixAsTriplet< Scalar_, SparseInt >, Domain_, Range_ > | |
| CMatrixTraits | Defines domain and range types for matrix classes |
| CMatrixTraits< Dune::FieldMatrix< Scalar, n, m > > | |
| CMatrixTraits< NumaBCRSMatrix< Entry, Index > > | |
| CMaxValueCriterion | Max value refinement criterion. Determines the refinement thresholds such that all cells with an error contribution exceeding a certain fraction of the maximum error contribution are refined |
| CMeasureTime | |
| CMembraneModelBase | Convenience base class for membrane models providing numerical differentiation |
| CMGProjectionOnTangentSpace | |
| CMGProlongation | A prolongation operator for P1 finite elements from a coarser grid level to the next finer level |
| CMGSolverStatistics | An interface for gathering multigrid solver statistics |
| CModifiedCovariantNewtonParameters | |
| CMonomial | Monomial a*x^k of order k |
| ►CMorleyMapper | Degrees of freedom manager for Morley nonconforming elements |
| CCombiner | A combiner class implementing a matrix \( K \) mapping a subset of global degrees of freedom (those given by globalIndices()) to local degrees of freedom (shape functions) |
| CMortar | Abstract base class for computation of constraints from constraint samples |
| CMortarB | Defines the sample-based contact constraint formulation |
| CMultiGridPreconditioner | |
| ►CMultigridSolver | |
| CParameter | |
| CMultiGridStack | Class for multigrid stacks |
| CMultilevelCoarseningPolicy | Policy class for LocalTransfer These two structures are used for determining whether to perform a "normal" grid transfer (default, AdaptionCoarseningPolicy), or to calculate prolongation matrices for a FE function space based on a HierarchicIndexSet (see mgtools.hh) |
| CMultiLevelLocalGeometry | Transformation of coordinates between ancestor and child |
| CMultiplicativeMultiGrid | A general multiplicative multigrid preconditioner |
| CMUMPSFactorization | Factorization of sparse linear systems with mumps |
| CMutex | A utility class implementing appropriate copy semantics for boost mutexes |
| ►CNedelecMapper | Degrees of freedom manager for Nedelec edge elements |
| CCombiner | A class implementing a matrix \( K \) mapping a subset of global degrees of freedom (those given by globalIndices()) to local degrees of freedom (shape functions) |
| CNedelecShapeFunctionSetContainer | |
| CNedelecSimplexShapeFunction | Vectorial Nedelec shape functions on the unit simplex |
| CNedelecSimplexShapeFunctionSet | |
| CNestedDissection | Nested dissection factorization for symmetric positive definite sparse matrices |
| CNestedDissectionCholeskyLocalMatrixStorage | An inverse local matrix representation that stores a sparse Cholesky factor using nested dissection |
| CNestedDissectionStorageTag | A parametrized tag type for selecting storage of inverses by nested dissection with floating point representation of type Scalar |
| CNewtonCotesRule3 | |
| CNewtonParameters | |
| ►CNewtonsMethod | Base class for Newton's method. Defines the main algorithm, potentially using damping |
| CCycleDetection | |
| ►CNleqSolver | Solution of a nonlinear system of equations by a damped Newton-method |
| CNleqInfo | |
| CNMIIIAPCGSolver | Conjugate gradient method |
| CNMIIICGSolver | Conjugate gradient method |
| CNMIIIPCGSolver | Conjugate gradient method |
| CNonpositiveMatrixException | To be raised if the matrix is not positive definite |
| CNonsquareMatrixException | To be raised if the matrix is nonsquare |
| CNoRegularization | |
| CNormalStep | |
| CNormalStepNewton | |
| CNormalStepPreconditioner | |
| CNormalStepPreconditioner2 | |
| CNormalStepPreconditioner3 | |
| CNormModelCreator | |
| ►CNumaAllocator | An STL allocator that uses memory of a specific NUMA node only |
| Crebind | |
| CNumaBCRSMatrix | A NUMA-aware compressed row storage matrix adhering mostly to the Dune ISTL interface (to complete...) |
| CNumaCRSPattern | A NUMA-aware compressed row storage sparsity pattern |
| CNumaCRSPatternCreator | A NUMA-aware creator for matrix sparsity patterns |
| CNumaDenseMatrix | A dense matrix class tailored towards NUMA architectures |
| CNumaThreadPool | Implementation of thread pools suitable for parallelization of (more or less) memory-bound algorithms (not only) on NUMA machines |
| CNumaVector | A vector class tailored towards NUMA architectures. This vector distributes its entries in blocks of approximately equal size to the different nodes of NUMA machines in order to exploit the larger accumulated memory bandwidth for fast vector operations. This is most beneficial for large vectors exceeding the cache of the CPUs. Modern processors (2015-01-01) have up to 6MB 3rd level cache, so this is intended for vectors of more than 50,000 doubles, say |
| COmegaModel | |
| COptimization | |
| COptimizationParameters | |
| COptions | |
| CParameters | ...for parameter dependent functionals, implements AbstractParameters |
| CPardisoFactorization | Factorization with DirectType::PARDISO |
| CPartialDirectPreconditioner | DEPRECATED A partial direct preconditioner applicable to assembled operators |
| CPatchDomainDecompositionPreconditioner | An additive overlapping domain decomposition type preconditioner for higher order finite elements applied to elliptic equations |
| CPatchDomainDecompositionPreconditionerTraits | Provides the actual type of local matrix storage based on a tag and the number of components |
| CPatchDomainDecompositionPreconditionerTraits< DenseCholeskyStorageTag< Scalar >, components > | |
| CPatchDomainDecompositionPreconditionerTraits< DenseInverseStorageTag< Scalar >, components > | |
| CPatchDomainDecompositionPreconditionerTraits< NestedDissectionStorageTag< StorageScalar, FactorizationScalar >, components > | |
| CPcg | Preconditioned conjugate gradient method |
| CPCGCountingTerminationCriterion | PCG termination after a given number of iterations |
| CPCGEnergyErrorTerminationCriterion | TerminationCriterion based on an absolute energy error estimate |
| CPCGTerminationCriterion | Interface for IterateType::PCG termination criterion policy classes |
| CPenaltyFunction | Sets a function to std::numeric_limits<double>::max() for negative arguments |
| CPhysiologicalAlievPanfilov | Phenomenological model based on Aliev and Panfilov, scaled to physiological values |
| ►CPiecewiseContinuousLagrangeMapper | A degrees of freedom manager for piecewise continuous FEFunctionSpace s of local polynomials |
| CElement | |
| CPlainAverage | A Weighing that associates to each cell a constant weight of 1 |
| CPolynomial | |
| CPolynomialModel | |
| CPPCGAsNormalSolver | |
| CPreconditionerAsNormalSolver | |
| CPreconditionerFactory | |
| CPrimalChart | |
| CProjectedAPCGSolver | |
| CProjectionOnTangentSpace | |
| CQPALSolver | An augmented Lagrangian solver for small instances of a particular class of quadratic programs |
| CQPBoundSolver | An iterative solver for small instances of bound constrained quadratic programs |
| CQPBoundSolverBase | An iterative solver for small instances of bound constrained quadratic programs |
| CQPDirectSparse | A solver for sparse, medium-sized instances of bound constrained quadratic programs |
| CQPMultiGrid | A multigrid solver for convex QPs |
| CQPMultiGridBase | A base class for multigrid solver for QPs |
| CQPMultiGridStrict | |
| CQPPenalizedSolver | An iterative solver for small instances of a particular class of quadratic programs |
| CQPPenaltySmoother | |
| CQPSlackSolver | An iterative solver for particular instances of bound constrained quadratic programs |
| CQPSmoother | |
| CQPSolver | An iterative solver for small instances of a particular class of quadratic programs |
| CQuadraticAndLogBase | |
| CQuadraticFunction | TODO !!!!! Entscheidung über Vektortyp !!!!!! |
| ►CQuadraticModel | Creates a (linear) model to a linearization of a functional |
| CBoundaryCache | |
| CD1 | |
| CD2 | |
| CDomainCache | |
| ►CHessianTimesDirection | |
| Cresult | |
| Cresult< HessianTimesDirection< row, dim, Cache >(T, State)> | |
| ►CLinearFunctionalTimesDirection | |
| Cresult | |
| Cresult< LinearFunctionalTimesDirection< LinFunctional >(T, State)> | |
| CRowValueType | |
| CQuadraticModelCreator | |
| CQuadratureTraits | A cache that stores suitable quadrature rules for quick retrieval |
| CQuadratureTraits< Dune::QuadratureRule< ctype, dim > > | A cache that stores suitable quadrature rules for quick retrieval |
| CRadauTimeGrid | Spectral time grid for defect correction methods with Radau points on \( [a,b]\) |
| CRangeView | DEPRECATED. Use boost::iterator_range instead |
| CRefinedTrapezoidal | |
| CRefinementCriterion | Base class for refinement criteria |
| CRegularizedQuadraticFunction | |
| CRestrictedShapeFunctionSet | Restricted shape function set. Introduces a new local ordering for the shape functions. To retrieve the original shape function id use getId(int newLocalId) |
| CScalarConverter | A Converter for scalar shape functions that do not change their value under transformation from reference to actual element geometry |
| CScalarLaplace | Convenience class for handling diffusion terms in elliptic/parabolic equations |
| CScalarModelFunction | Interface for a scalar model function on a scalar domain that may fit data |
| CScalarProductView | (Scalar) product of two functions |
| CScalarTraits | Helper class for working with (real or complex) scalar field types |
| CScalarTraits< std::complex< T > > | |
| CScaledl2ScalarProduct | |
| CScaledTwoNorm2Collector | A functor for computing scaled \(L^2\)-norms of a set of (possibly vector-valued) functions |
| CScatterFullLocalSolution | |
| CScatterLocalSolution | |
| CScopedTimingSection | A scope guard object that automatically closes a timing section on destruction |
| CSdc | Encapsulates the state of an SDC fixed point iteration and provides stepping |
| CSDCGridImplementationBase | A convenience class simplifying the implementation of different SDCTimeGrid derived classes |
| CSDCTimeGrid | Abstract base class of time grids for (block) spectral defect correction methods |
| CSearchSpaceCreator | |
| ►CSemiImplicitEulerStep | Linearly implicit Euler method |
| CBoundaryCache | |
| CD1 | |
| CD2 | |
| CDomainCache | |
| CSemiLinearizationAt | Proxy class for the linearization of semi-linear time stepping schemes |
| CSemiLinearizationAtInner | |
| CShapeFunction | Shape functions |
| ►CShapeFunctionCache | This class caches values and derivatives of shape functions at quadrature points |
| CDataType | Defines the type returned by evaluate(sfs,qr,subId) |
| CLocalDataType | Defines the type returned by evaluate(sfs,qr,ip,subId) |
| CShapeFunctionSet | A set of shape functions |
| CShapeFunctionSetContainer | Base class for sets of shape function containers |
| CSimpleAdaptiveRefinement | Adaptive refinement algorithm |
| CSimpleSparseLinearSystem | Simple Implementation for SparseLinearSystem |
| CSingularMatrixException | To be raised if the matrix is singular |
| CSLAPMatrix | Very simple dense matrix class for interfacing with LAPACK routines and the optimization tool uncmin |
| CSolveLocalSystem | |
| CSpaceIndex | Helper class for specifying the FE space index of a variable |
| CSpaceType | Extracts the type of FE space with given index from set of spaces |
| CSparseLinearSystem | Abstract base class for a sparse linear system |
| CSqrt | |
| CSquare | |
| CStateConstraintsNewtonMethod | A Newton method that uses a pointwise damping strategy to cope with bounds |
| CStateEquationHBErrorEstimator | |
| CStaticIndexRange | A compile-time index range |
| CStepPolicyProjectedRHS | |
| CStrakosTichyEnergyErrorTerminationCriterion | Relative energy error termination criterion according to Strakos, Tichy: Error estimation in preconditioned conjugate gradients. Requires that IterateType::CG starts at \( x = 0 \). More general starting values might be used, but must be chosen such that the estimate for the energy norm of the solution stays positive (see the above mentioned paper for details) |
| CStrakosTichyPTerminationCriterion | Relative error termination criterion based on the norm induced by the preconditioner, according to Strakos, Tichy: Error estimation in preconditioned conjugate gradients. Requires that IterateType::CG starts at \( x = 0 \). More general starting values might be used, but must be chosen such that the estimate for the energy norm of the solution stays positive (see the above mentioned paper for details) |
| CStrongBoundaryValues | |
| CStrongResidualsTimesTestFunction | |
| CStupidHBErrorEstimator | |
| CSubstractCorrection | |
| CSumCache | |
| ►CSumFunctional | |
| CBoundaryCache | |
| CD1 | |
| CD2 | |
| CDomainCache | |
| CRowValueType | |
| CSummationCollector | A Collector that sums up the weighted contributions |
| CSumUp | |
| CSUPERLUFactorization | Factorization of sparse linear systems with mumps |
| CSymmetricLinearOperator | Interface for symmetric linear operators |
| CSymmetricLinearOperatorWrapper | Wrapper class to present (hopefully) symmetric linear operators in the SymmetricLinearOperator interface |
| CSymmetricMatrixOperator | A symmetric operator represented by a matrix |
| CSymmetricPreconditioner | Interface for symmetric preconditioners |
| CSymmetricPreconditionerWrapper | Wrapper class presenting a symmetric preconditioner interface for any preconditioner |
| CSymmetricTaylorHoodPreconditioner | Symmetric Taylor-Hood constraint preconditioner |
| CSystDim | |
| CSystDimFull | |
| CTangentialStep | |
| CTangentialStepArmijo | |
| CTangentialStepNewton | |
| CTangentSpacePreconditioner | |
| CTangentSpacePreconditioner2 | |
| CTaskTiming | A class that gathers data on task timing and provides gnuplot visualization |
| CTaylorHoodPreconditioner | Constraint preconditioner for Taylor-Hood discretizations of incompressibility problems |
| CTCG | Preconditioned conjugate gradient method |
| CTensor | A class for representing tensors of arbitrary static rank and extents |
| CTensor< Entry, Size0 > | |
| CTenTusscher16 | Physiologcial model by tenTusscher et al |
| CTenTusscher18 | Physiologcial model by tenTusscher et al. (2006) |
| CTestErrorEstimator | |
| CTimeSeriesVTKWriter | |
| CTimings | Supports gathering and reporting execution times information for nested program parts |
| ►CTransferData | A class storing data collected before grid adaptation that is necessary to transfer FE functions. This includes global indices of shape functions on leaf cells and restriction matrices to coarser cells in case some leaf cells might be removed during grid adaptation |
| CTransferMatrix | Matrix that transforms a data vector v_1 corresponding to the old grid to a data vector v_2 corresponding to the new grid, such that the functions represented by these vectors coincide as much as possible |
| CTransformedPolynomialModel | |
| CTransposedOperator | |
| CTrapezoidalRule | |
| CTrivialBoundaryDetector | |
| CTrivialCacheBase | Base class simplifying the definition of domain and boundary caches |
| CTrivialPreconditioner | The trivial preconditioner: this is simply the identity that does exactly nothing |
| CUMFFactorization | Factorization of sparse linear systems with UMFPack |
| CUnaryTrue | |
| CUnboundedProblemException | To be raised if an iterative solver detects the optimization problem to be unbounded (has no valid solution) |
| CUNCMINVector | Very simple vector wrapper for the use of the optimization tool uncmin, which is not capable of using std::vector :( |
| CUniformPartitionedMapper | Base class for piecewise continuous mappers |
| CUniformSampler | Class that can sample a Function(View) on a uniform rectangular grid |
| CUniformScalarMapper | Base class for uniform scalar local to global mappers |
| CUzawaSolver | An inexact Uzawa type solver for solving symmetric saddle point systems |
| CVariable | A class defining elementary information about a single variable |
| CVariableDescription | A class storing elementary information about a single variable.This includes the number of components, the id and name of the variable, and the index of the associated FEFunctionSpace from which the variable comes |
| CVariableId | DEPRECATED |
| CVariableSet | A class for storing a heterogeneous collection of FunctionSpaceElement s |
| ►CVariableSetDescription | A class that stores information about a set of variables |
| CCoefficientVectorRepresentation | Typedefs for coefficient vector representations of contiguous subranges of the variables |
| CComponents | DEPRECATED, use components instead |
| CSpaceIndex | DEPRECATED, use spaceIndex instead |
| CVariationalArg | A class that stores values, gradients, and Hessians of evaluated shape functions |
| CVariationalEquationHBErrorEstimator | |
| ►CVariationalFunctionalAssembler | A class for assembling Galerkin representation matrices and right hand sides for variational functionals depending on multiple variables |
| CBlockToSequence | |
| CBlockToTriplet | |
| CCountNonzeros | |
| Cvec | |
| CVectorialConverterBase | A class mapping local vectorial shape function values and gradients to global shape function values and gradients |
| CVolume | A Weighing that associates to each cell its volume |
| ►CVTKReader | A class to create a grid and load coefficients from a VTK file |
| CFunctionInfo | Information about a data set loaded from a file |
| CWeakBoundaryValues | |
| CWeakBoundaryValuesFull | |
| CWeakFunctionViewAdaptor | An adaptor that turns callables (e.g., lambdas) into weak function views |
| CWeakResiduum | |
| CWeakResiduumFull | |
| CWeakResiduumMainPart | |
| CXXstress | Active stress generation from XX |
| CYetAnotherHBErrorEstimator | |
| CYetAnotherHBErrorEstimator_Elasticity | |
| CZeroDualPairing | Zero dual pairing implementation (mainly useful whenever a dual pairing is needed for formal language reasons, but never used) |
| ►NLossy_Detail | |
| CMlStack | |
| CParentalNodes | |
| CProlongation | |
| CProlongationStack | |
| CAlphabet | A simple alphabet of symbols with frequencies to be used with the range coder |
| CBisectionPolicy | The default splitting policy |
| ►CBlockFilter | A block filter specifying which subblocks of a stiffness matrix or right hand side shall be assembled |
| CD1 | |
| CD2 | |
| CCollector | Defines an interface for integrating values computed over a grid |
| CCombinerConcept | Algebraic combiner of global degrees of freedom to shape function coefficients |
| CConverterConcept | Geometrical transformation of shape function values |
| Ccuboid | |
| CDuneAmiraMesh | |
| CFirstOrderEquation | |
| CFullHierarchicIterator | |
| CFunction | Function is the interface for evaluatable functions \( f:\Omega\to\mathbb{R}^m \) |
| CFunctionView | A function that supports efficient evaluation via an evaluator |
| CGetProtectedConstructor | A wrapper class for access to protected constructors |
| CGridTree | Stores a grid in a tree structure, allowing fast searches |
| CHierarchicErrorEstimator_D2BlockInfo | Defines the block structure of defect systems to be solved by the hierarchical error estimator |
| ►CHierarchicErrorEstimatorD2Info | Concept for providing block information to hierarchical error estimator |
| CD2 | |
| ►CHierarchicIndexSet | |
| ►CCodim | |
| CPartition | |
| CHyperelasticMaterialLaw | A hyperelastic material law |
| CInteriorPointTangentialPredictor | |
| CInvariantsMaterialConcept | A hyperelastic material law formulated in terms of the invariants \( I_1, I_2, I_3 \) of the Cauchy-Green strain tensor \( C \) |
| CKBiCGSTABSolver | Statistics about the application of an inverse operator |
| CLocalToGlobalMapperConcept | Management of degrees of freedom |
| CLossyStorage | |
| CMatrixRepresentedOperator | Defines a linear operator \(A:\ X\rightarrow Y\) with matrix representation \(M_A \in \mathbb{K}^{n\times m}\) |
| CMlStack | |
| CMultigridSolver | |
| CMultilevelTransfer | |
| ►CNonlinearVariationalFunctional | Documentation of the concept of a nonlinear variational functional The nonlinear variational functional concept defines the interface that is accessed by the LinearizationAt and linearizationAt adapters. It differs from the basic VariationalFunctional concept mainly in how the DomainCache and the BoundaryCache are constructed |
| CBoundaryCache | Defining boundary conditions |
| CD1 | |
| CD2 | |
| CDomainCache | This evaluation cache concept defines the interface that is accessed by the assembler |
| ►CParabolicEquation | Documentation of the concept of a parabolic parabolic equation |
| CB2 | |
| CBoundaryCache | Defining boundary conditions |
| CD1 | |
| CD2 | |
| CDomainCache | This evaluation cache concept defines the interface that is accessed by the assembler |
| CPARDISOFactorization | Factorization with DirectType::PARDISO |
| CParentalNodes | Finds the parent nodes and their interpolation weight for each node in the grid. usage eg.: ParentalNodes<Grid> parentalNodes( gridManager.grid() ); |
| ►CPartialIndexSet | |
| ►CCodim | |
| ►CPartition | |
| CIterator | |
| CPointwiseCorrection | Pointwise damping strategy |
| CProlongationStack | |
| CPWDampingChart | |
| CRangeCoder | Base class for entropy coding with range encoder and decoder |
| CRangeDecoder | Entropy coding with range decoder |
| CRangeEncoder | Entropy coding with range encoder |
| CRestartedFGMResSolver | Implements the Generalized Minimal Residual (GMRes) method |
| CScaling | A callable that allows to implement weighted (scaled) norms |
| CSecondOrderEquation | |
| CSelect | Deprecated (use std::conditional_t instead). Will be removed after 2019-12-31 |
| CSelect< false, T1, T2 > | |
| CStepEquation | |
| CTranspose | Returns the matrix type or its transposed type, depending on the given transpose flag |
| CTranspose< Dune::FieldMatrix< Scalar, n, m >, transposed > | |
| CUniformQuantizationPolicy | |
| ►CVariationalFunctional | Documentation of the concept of a quadratic variational functionalThe variational functional concept defines the interface that is accessed by the VariationalFunctionalAssembler |
| CBoundaryCache | Evaluation of boundary conditions |
| CD1 | Provides static information about the right hand side blocks |
| CD2 | Provides static information about the submatrix blocks of the stiffness block matrix |
| CDomainCache | This evaluation cache concept defines the interface that is accessed by the assembler |
| CInnerBoundaryCache | Evaluates jump contributions at interior faces, suitable for discontinuous Galerkin methods (optional) |
| CWeakFunctionView | A function that supports efficient evaluation via cell and local coordinate |
| CWeighing | A Weighing is a class that allows to compute weighted averages of values associated to cells of a grid |
