Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

►NAMDiS
►NAssigner
Cassign
Cdivides_assign
Cminus_assign
Cmultiplies_assign
Cplus_assign
►NConcepts
►NDefinition
CCallable
CConstantToGridFunction
CConstantToGridFunction< std::reference_wrapper< T > >
CHasDerivative
CHasFunctorOrder
CHasGridFunctionTypes
CHasLocalFunction
CHasLocalFunctionDerivative
CHasPartial
CInterpolateData
CIsPreTreePath
CIsPreTreePath< std::integer_sequence< Index, I... > >
CIsPreTreePath< std::integral_constant< Index, I > >
CIsPreTreePath< std::tuple< Indices... > >
CMultiIndex
CPolynomial
CPreBasisFactory
CUpdateData
►Nevent
Cadapt
CpostAdapt
CpreAdapt
►Nfilesystem
Cpath
►NOperation
CAbsMax	Operation that represents max(|A|,|B|)
CAbsMin	Operation that represents min(|A|,|B|)
CArg
►CClamp
CDClamp
CComposer	Composition of Functors
CComposerBuilder
CComposerBuilder< Id, F >
CComposerBuilder< Minus, G, Zero >
CComposerBuilder< Minus, Zero, G >
CComposerBuilder< Minus, Zero, Zero >
CComposerBuilder< Multiplies, G, Zero >
CComposerBuilder< Multiplies, PowImpl< p, pos >, PowImpl< p, pos > >
CComposerBuilder< Multiplies, Zero, G >
CComposerBuilder< Multiplies, Zero, Zero >
CComposerBuilder< Negate, Minus >
CComposerBuilder< Plus, G, Negate >
CComposerBuilder< Plus, G, Zero >
CComposerBuilder< Plus, Zero, G >
CComposerBuilder< Plus, Zero, Zero >
CComposerBuilder< PowImpl< p1, pos1 >, PowImpl< p2, pos2 > >
CComposerBuilder< Scale< F >, Scale< G > >
CConstant	Functor representing a constant value
►CCoordsCompFunction	A functor that evaluates to a component of the global coordinates
CCreator
CDerivative
►CCoordsFunction	A functor that evaluates to the global coordinates
CCreator
CDerivative
CDivides	Functor that represents A/B
CDot	(Binary-)Functor representing the euclidean dot-product
CGet
CGet_
CId	(Unary-)Functor representing the identity
CMax	Operation that represents max(A,B)
CMin	Operation that represents min(A,B)
CMinus	Functor that represents A-B
CMultiplies	Functor that represents A*B
CNegate	Functor that represents A-B
CPlus	Functor that represents A+B
CPower	Functor that represents x^p,
CPowImpl
CPowImpl< p, false >
CPowImpl< p, true >	Functor that represents x^p
CPowType
CPowType< 0 >
CPowType< 1 >
CReference	Functor representing a constant value
CScale	Functor that represents f*A
CSignum	Functor that represents the signum function
CStaticConstant	Functor representing a static constant value
CTrans
CTwoNorm	(Unary-)Functor representing the euclidean 2-norm
CUnaryDot	(Unary-)Functor representing the euclidean dot-product
►NRecursive
CForEach
CForEach< EigenVector< T > >
CForEach< ISTLBlockVector< T > >
CForEach< MTLVector< T > >
CForEach< PetscVector< DofMap > >
CForEach< VectorBase< D > >
CForEach< VectorFacade< T, Impl > >
CInnerProduct	General implementation of recursive inner-product
CInnerProduct< EigenVector< T > >
CInnerProduct< ISTLBlockVector< T > >
CInnerProduct< MTLVector< T > >
CInnerProduct< PetscVector< DofMap > >
CInnerProduct< VectorBase< D > >
CInnerProduct< VectorFacade< S, Impl > >
CMap	Default implementation of the recursive map function
CMap< std::array< T, n > >
CMap< std::pair< T1, T2 > >
CMap< std::tuple< TT... > >
CMap< std::vector< T > >
CTransform
CTransform< EigenVector< T > >
CTransform< ISTLBlockVector< T > >
CTransform< MTLVector< T > >
CTransform< PetscVector< DofMap > >
CTransform< VectorBase< D > >
CTransform< VectorFacade< T, Impl > >
►Ntag
Cassign
Caverage
Cbjacobi
Cdatatransfer	Base tag type for all data transfer tags
Cdefaulted
Cderivative_type
Cdivergence
Cdivtestvec
Cdivtestvec_divtrialvec
Cdivtestvec_trial
Celement_operator
Cgrad_test
Cgrad_trial
Cgradtest
Cgradtest_gradtrial
Cgradtest_trial
Cgradtest_trialvec
Cinterpolation_datatransfer
Cintersection_operator
Cjacobian
Clocal_average
Cmatrix
Cno_datatransfer
Cnone
Cpartial
Cpartial_test
Cpartial_trial
Cpartialtest
Cpartialtest_partialtrial
Cpartialtest_trial
Cpreconditioner
Cscalar
Csimple_datatransfer	Tag that referrs to the SimpleDataTransfer
Csolver
Cstokes
Ctest
Ctest_divtrialvec
Ctest_gradtrial
Ctest_partialtrial
Ctest_trial
Ctest_trialvec
Ctestvec
Ctestvec_gradtrial
Ctestvec_trial
Ctestvec_trialvec
Cunknown
Cvalue
Cvector
►NTraits
CAccess	Unified accessor class
CIsFlatIndex
CIsFlatIndex< std::array< I, 1 > >
CIsPreGridFunction
CIsPreGridFunction< AnalyticPreGridFunction< Functor > >
CIsPreGridFunction< ComposerPreGridFunction< Functor, PreGridFcts... > >
CIsPreGridFunction< DerivativePreGridFunction< Expr, Type > >
CIsPreGridFunction< Operation::CoordsCompFunction >
CIsPreGridFunction< Operation::CoordsFunction >
CIsReferenceWrapper
CIsReferenceWrapper< std::reference_wrapper< T > >
CIsSame
CIsSame< T0, Ts... >
CIsSame<>
CIsSimilar
CIsSimilar< Types< A >, Types< B > >
CIsSimilar< Types< A0, As... >, Types< B0, Bs... > >
CIsSimilar< Types<>, Types<> >
CIsValidTreePath
CAdaptBase	Interface for adaption loops
►CAdaptInfo	Holds adapt parameters and infos about the problem
CScalContent	Stores adapt infos for a scalar problem or for one component of a vector valued problem
CAdaptInstationary	AdaptInstationary implements the adaptive procedure for time dependent problems (see ProblemInstat). It contains a pointer to a ProblemInstat object
CAdaptionInterface	Interface for transfer between grid changes
CAdaptiveGrid	Wrapper class for Dune-grids that allows automatic signalling of events during grid adaptation
►CAdaptiveGridFamily
CTraits
CAdaptStationary	Contains all classes needed for space and time adaption
CAMGCreator
CAMGPreconCreator
CAnalyticGridFunction	A Gridfunction that evaluates a function with global coordinates
CAnalyticLocalFunction
CAnalyticLocalFunction< R(D), LC, Function >
►CAnalyticPreGridFunction
CCreator
CAssembler	An Assembler is the main driver for building the local element matrices and vectors by assembling operators bound to elements, intersections and boundary intersection
CAttributeSet
CAverageInterpolator
CBackupRestoreByGridFactory
CBackupWriter
Cbicg_solver_type	ITL_Solver <bicg_solver_type> implementation of bi-conjugate gradient method
Cbicgstab2_type	ITL_Solver <bicgstab2_type> implementation of BiCGStab(l) method with l=2
Cbicgstab_ell_type	ITL_Solver <bicgstab_ell_type> implementation of stabilized BiCG(ell) method
Cbicgstab_type	ITL_Solver <bicgstab_type> implementation of stabilized bi-conjugate gradient method
CBiLinearForm
CBlockMatrixType
CBlockMatrixType< T, typename T::field_type >
CBlockVectorType
CBlockVectorType< T, typename T::field_type >
CBoundaryCondition	Interface class for boundary conditions
CBoundaryLocalOperator	The local operator associated to BoundaryOperator
CBoundaryManager	Manage boundary ids of boundary segments in a grid
CBoundaryManagerBase
CBoundaryOperator	An operator to be assembled on a boundary intersection belonging to a given boundary subset
CBoundarySubset	Class defining a subset of a domain boundary
Ccg_solver_type	ITL_Solver <cg_solver_type> implementation of conjugate gradient method
Ccgs_solver_type	ITL_Solver <cgs_solver_type> implementation of squared conjugate gradient method
CCheckNumCols
CCheckNumRows
CCheckSize
►CCoarsenedGridFunction	A grid function defining data on a coarser entity level than it can be bound to
►CCoarsenedLocalFunction
CChildElement
CComposerGridFunction	A Gridfunction that applies a functor to the evaluated Gridfunctions
CComposerGridFunction< R(D), ES, Functor, GridFunctions... >
CComposerLocalFunction
CComposerLocalFunction< R(D), E, Functor, LocalFunctions... >
►CComposerPreGridFunction
CCreator
CCompositeNodeCache
CConcurrentCache	The class template ConcurrentCache describes an associative static container that allows the concurrent access to the stored data
CConsecutivePolicy	Store cache in instance
CConstantGridFunction	Gridfunction returning a constant value
CConstantLocalFunction
CConstantLocalFunction< R(D), LC, T >	LocalFunction of a Gridfunction returning a constant value
CConstraints
CConstraints< BiLinearForm< RB, CB, T, Traits > >
►CConstraints< MTLSparseMatrix< T > >
CTriplet
CConstraints< PetscMatrix< DofMap > >
CContextGeometry	Wrapper class for element and geometry
CConvectionDiffusionLocalOperator
CConvectionDiffusionOperator
CConvectionDiffusionOperatorTerm
CCreatorInterface	Interface for the implementation of the factory method pattern. The creation of an object of a sub class of BaseClass is deligated to a corresponding sub class of Creator<BaseClass>. So it is possible to manage a CreatorMap, which can be extended at run-time. An example is the LinearSolverInterfaceMap: If you write your own LinearSolverInterface sub class and a corresponding Creator<LinearSolverInterface<T> >, you can add the creator together with a key string to the LinearSolverInterfaceMap. Then you can create an LinearSolverInterface depending of a key string read from the init file, which can also be your own new solver
CCreatorInterfaceName	Interface for creators with name
CCreatorMap	A CreatorMap is used to construct objects, which types depends on key words determined at run time. For example the LinearSolverInterfaceMap can create the different solver types depending on the solver parameter of the init file. The benefit of such creator maps is, that you can extend them only by writing an creator class for your own new class and give the creator together with a key word to the map
CDataTransfer	The base class for data transfer classes
CDataTransferFactory
CDataTransferFactory< tag::interpolation_datatransfer >
CDataTransferFactory< tag::no_datatransfer >
CDataTransferFactory< tag::simple_datatransfer >	Register the SimpleDataTransfer using the tag simple_datatransfer
CDefaultAttributeSet
CDefaultBasisCreator	Generator for a basis and default problem traits
CDefaultCreators
CDefaultCreators< LinearSolverInterface< M, X, Y > >	Adds default creators for linear solvers based on Eigen::SparseMatrix
CDefaultCreators< PreconditionerInterface< M, X, Y > >
CDefaultCreators< tag::preconditioner< Traits > >	Adds default creators for preconditioners for ISTL
CDefaultCreators< tag::solver< Traits > >	Adds default creators for linear solvers based on Dune::BCRSMatrix
CDefaultIndexDistribution	Dummy implementation for sequential index "distribution"
CDefaultLeafGridView
►CDefaultLeafGridViewTraits
►CCodim
CPartition	Define types needed to iterate over entities of a given partition type
CDefaultLevelGridView
►CDefaultLevelGridViewTraits
►CCodim
CPartition	Define types needed to iterate over entities of a given partition type
CDefaultProblemTraits	Wrapper around a global basis providing default traits
CDerivativeGridFunction	A Gridfunction that returns the derivative when calling localFunction
►CDerivativePreGridFunction
CCreator
CDerivativeTraits
CDerivativeTraits< R(D), tag::jacobian >
CDerivativeTraits< R(D), tag::value >
CDiagonalPreconditioner	ITL_Preconditioner implementation of diagonal (jacobi) preconditioner,
►CDirectRunner
CCreator
CDirectSolverCreator	Default creator for direct solvers
CDirichletBC	Implements a boundary condition of Dirichlet-type
►CDiscreteFunction	A mutable view on the subspace of a DOFVector,
CLocalFunction
CDiscreteFunction< Coeff const, GB, TreePath, R >	A Const DiscreteFunction
CDOFVector	The basic container that stores a base vector and a corresponding basis
CEigenSparseMatrix	The basic container that stores a base matrix and a corresponding row/column feSpace
►CEigenTraits
CMatrix
CVector
CEigenVector	The basic container that stores a base vector and a corresponding basis
CElementGridFunction	Gridfunction returning a constant value per element
CElementLocalFunction
CElementLocalFunction< R(D), IndexSet, Container >	LocalFunction of a Gridfunction returning a constant value per element
CElementVector	An adaptive container that stores a value per grid element
CEnvironment	Establishes an environment for sequential and parallel AMDiS programs
CESMarker	Equidistribution strategy
CEstimatorMarker	Base class for all estimator-based markers
CFaceTransformation	Affine transformation x := A*x + b
CFakeAssigner
►CFakeContainer	A container-like data-structure not storing anything and with empty implementations in many container-interface functions
Cconst_iterator
Cfgmres_type	ITL_Solver <fgmres_type> implementation of flexible GMRes method
CFileWriterBase	Base class for filewriters
CFileWriterCreator	Creator class for filewriters depending on a given type name
CFileWriterInterface	Interface class for filewriters
CFirstOrderDivTestVec	First-order operator \( \langle\nabla\cdot\Psi, c\rangle \)
CFirstOrderGradTest	First-order operator \( \langle\nabla\psi, b\rangle \)
CFirstOrderPartialTest	First-order operator \( \langle\partial_i\psi, c\rangle \)
CFirstOrderTestDivTrialvec	First-order operator \( \langle\psi, c\,\nabla\cdot\Phi\rangle \)
CFirstOrderTestGradTrial	First-order operator \( \langle\psi, \mathbf{b}\cdot\nabla\phi\rangle \)
CFirstOrderTestPartialTrial	First-order operator \( \langle\psi, c\,\partial_i\phi\rangle \)
CFirstOrderTestvecGradTrial	First-order operator \( \langle\Psi, c\,\nabla\phi\rangle \)
CFlag	Encapsulates flags which represents simple information. Used e.g. while mesh traversal to specify, which elements should be visited
CFlatIndexMergingStrategy	Define the flat index-merging strategy for a given strategy IMS
CFlatMatrix	Dense matrix with row-wise storage in flat data vector
CFlatPreBasis	Transform a PreBasis into one with flat index-merging strategy
CFlatVector	Flat data vector to be used in assembling as element vector
Cgcr_type	ITL_Solver <gcr_type> implementation of generalized conjugate residual method
CGERSMarker	Guaranteed error reduction strategy
►CGlobalBasis	Global basis defined on a pre-basis
CDummyImpl
CGlobalBasisIdSet	Provide global ids for all DOFs in a global basis
CGlobalBasisIdSet< Basis, std::void_t< typename Basis::RootBasis > >
CGlobalContext
CGlobalIdType	Type of a global used used to represent DOFs uniquely
Cgmres_type	ITL_Solver <gmres_type> implementation of generalized minimal residual method
CGMResSolverCreator	Solver creator for iterative GMRes-like solvers
CGmshWriter	The GmshWriter just writes the grid of a given gridView to a gmsh compatible .msh file
CGridFunctionCreator
CGridFunctionCreator< Value, std::enable_if_t< Concepts::ConstantToGridFunction< Value > > >
CGridFunctionLocalOperator	The main implementation of a local-operator depending on a local-function
CGridFunctionLocalOperatorTransposed
CGridFunctionMarker	Marker based on an indicator given as grid-function
CGridFunctionOperator	The main implementation of an operator depending on a grid-function
CGridFunctionOperatorRegistry	Registry to specify a tag for each implementation type
CGridFunctionOperatorRegistry< tag::divtestvec, LC >
CGridFunctionOperatorRegistry< tag::divtestvec_divtrialvec, LC >
CGridFunctionOperatorRegistry< tag::divtestvec_trial, LC >	First-order operator \( \langle\nabla\cdot\Psi, c\,\phi\rangle \)
CGridFunctionOperatorRegistry< tag::gradtest, LC >
CGridFunctionOperatorRegistry< tag::gradtest_gradtrial, LC >
CGridFunctionOperatorRegistry< tag::gradtest_trial, LC >	First-order operator \( \langle\nabla\cdot\Psi, c\,\phi\rangle \)
CGridFunctionOperatorRegistry< tag::gradtest_trialvec, LC >	First-order operator \( \langle\nabla\psi, c\,\Phi\rangle \)
CGridFunctionOperatorRegistry< tag::partialtest, LC >
CGridFunctionOperatorRegistry< tag::partialtest_partialtrial, LC >
CGridFunctionOperatorRegistry< tag::partialtest_trial, LC >	First-order operator \( \langle\partial_i\psi, c\,\phi\rangle \)
CGridFunctionOperatorRegistry< tag::stokes, LC >
CGridFunctionOperatorRegistry< tag::test, LC >
CGridFunctionOperatorRegistry< tag::test_divtrialvec, LC >
CGridFunctionOperatorRegistry< tag::test_gradtrial, LC >
CGridFunctionOperatorRegistry< tag::test_partialtrial, LC >
CGridFunctionOperatorRegistry< tag::test_trial, LC >
CGridFunctionOperatorRegistry< tag::test_trialvec, LC >
CGridFunctionOperatorRegistry< tag::testvec, LC >
CGridFunctionOperatorRegistry< tag::testvec_gradtrial, LC >
CGridFunctionOperatorRegistry< tag::testvec_trial, LC >	Zero-order operator \( \langle\Psi, \mathbf{b}\,\phi\rangle \)
CGridFunctionOperatorRegistry< tag::testvec_trialvec, LC >
CGridFunctionOperatorTransposed	The transposed operator, implemented in terms of its transposed by calling assemble with inverted arguments on the transposed element-matrix
CGRMarker	Global refinement
CHierarchicNodeWrapper
CICPreconditioner	ITL_Preconditioner implementation of IC (Incomplete Cholesky factorization) preconditioner
CIdentityPreconditioner	ITL_Preconditioner implementation of identity preconditioner,
Cidr_s_type	ITL_Solver <idr_s_type> implementation of Induced Dimension Reduction method
CILUPreconditioner	ITL_Preconditioner implementation of ILU (Incomplete LU factorization) preconditioner
CIndexMapTuple
CIndexMapTuple< std::index_sequence< I... >, Map >
CInitfile
CInitfileParser	Parser for AMDiS initfile format
CInterpolationDataTransfer
CInterpolatorFactory
CInterpolatorFactory< tag::assign >
CInterpolatorFactory< tag::average >
CInterpolatorFactory< tag::local_average >
CISTLBCRSMatrix
CISTLBlockVector
CISTLIndexDistributionType
CISTLIterativeSolverCreatorBase	Base solver creator for iterative solvers
CISTLLinearOperatorCreator	Creator to create Linear Operator objects
CISTLParallelPreconditionerCreator	Creator to create parallel Preconditioners
CISTLPreconCreator	Default precon creator
CISTLPreconCreator< tag::bjacobi, Traits >	Precon creator for the BJacobi preconditioner
CISTLPreconCreator< tag::solver< Traits >, Traits >	Precon creator for the InverseOperator2Preconditioner preconditioner
CISTLPreconCreatorBase	Base class for precon creators,
CISTLScalarProductCreator	Creator to create ScalarProduct objects
CISTLSolverCreatorBase	Base class for solver creators,
►CISTLTraits
CMatrix
CVector
CIterativeRunner
CIterativeSolverCreator	Default solver creator for iterative solvers
CIterativeSolverWrapper
►CKrylovRunner	Wrapper class for different MTL4 itl-solvers. These solvers are parametrized by Matrix and Vector
CCreator
CLagrangeBasis	ProblemStatTraits for a (composite) basis composed of lagrange bases of different degree
CLeafNodeCache	Cache of LocalBasis evaluations and jacobians at local points
CLinearForm	The basic container that stores a base vector and a corresponding basis
CLinearSolver	Implementation of LinearSolverInterface for EIGEN solvers
CLinearSolverInterface
CLocalAssembler
CLocalAverageInterpolator
CLocalOperator	The base class for a local operator to be used in a Assembler
CLocalOperatorAdapter	The local operator associated to the OperatorAdapter
CLocalToGlobalBasisAdapter	Convert a simple (scalar) local basis into a global basis
CLocalToGlobalBasisAdapterTraits	Traits class for local-to-global basis adaptors
CLocalView	The restriction of a finite element basis to a single element
CLocalViewPair	The restriction of a finite element basis to a single element
CLocalViewPair< B, B >	The restriction of a finite element basis to a single element
CMappedRangeView	A range transforming the values of another range on-the-fly
CMapTuple
CMapTuple< std::tuple< T... >, Map >
CMarker	Base class for all markers
CMatrixFacade
CMatrixNnzStructure	Sparsity pattern used to create PETSc matrices
CMatrixSize
CMeshCreator	A creator class for dune grids
Cminres_solver_type	ITL_Solver <minres_solver_type> implementation of minimal residual method
CMSMarker	Maximum strategy
CMTLSparseMatrix	The basic container that stores a base matrix
►CMTLTraits
CMatrix
CVector
CMTLVector	The basic container that stores a base vector data
CNewtonIteration
CNoDataTransfer	Implementation of DataTransfer that does not interpolate, but just resizes the containers to the dimension of the basis
CNodeDataTransfer
CNodeIdSet
CNodeWrapper	Wrapper around a basis-node storing just a pointer and providing some essential functionality like size, localIndex, and treeIndex
CNoOp	A functor with no operation
CNotifier	Mixin for signaling of certain events
CNotifier< Event >
CObserver	Implementation of the ObserverInterface
CObserverInterface
COperator	The base class for an operator to be used in an Assembler
COperatorAdapter	Wraps an operator that is bound to some tree path (rwo,col) and transforms it into an operator that associated to the root-node of the tree
COperatorTerm
COptionalNoCopy	Modification of std::optional that does not copy or move its content
CPCGSolverCreator	Solver creator for iterative CG-like solvers
CPeriodicBC	Implements a periodic boundary condition
CPetscIndexDistributionType	By default the PetscParallelIndexDistribution is just a sequential distribution
CPetscMatrix	The basic container that stores a base matrix
CPetscSequentialIndexDistribution	Fallback for PetscParallelIndexDistribution in case there is only one mpi core
►CPetscTraits
CMatrix
CVector
CPetscVector	The basic container that stores a base vector data
CPowerNodeCache
CPreconConfig
CPreconConfig< Eigen::IncompleteLUT< T, I > >
►CPreconditioner	Wrapper for using ITL preconditioners in AMDiS
CCreator	A creator to be used instead of the constructor
CPreconditionerInterface	Interface for Preconditioner y = M*x
CPreconWrapper
Cpreonly_type	ITL_Solver <preonly_type> implementation of preconditioner as
CProblemInstat	Standard implementation of ProblemTimeInterface for a time dependent problems
CProblemInstatBase	Base class for ProblemInstat
CProblemIterationInterface	Interface for master problems needed by the adaption loop. A master problem can handle one single or multiple coupled problems. In the latter case, the master problem can determine the execution order of the build, solve, estimate, and adapt steps of the single problems in oneIteration()
CProblemStat
CProblemStatBase	Interface for time independent problems. Concrete problems must override all pure virtual methods. The method adaptMethodStat() should initiate the adaption loop which in turn uses the other pure virtual functions. The default stationary adaption loop is implemented in the class AdaptStationary
CProblemTimeInterface	Interface for time dependent problems. Concrete problems must override all pure virtual methods
Cqmr_solver_type	ITL_Solver <qmr_solver_type> implementation of Quasi-Minimal Residual method
Cremove_cvref	Remove cv and ref qualifiers of type T
CSecondOrderDivTestvecDivTrialvec	Second-order operator \( \langle\nabla\cdot\Psi, c\,\nabla\cdot\Phi\rangle \)
CSecondOrderGradTestGradTrial	Second-order operator \( \langle\nabla\psi, c\,\nabla\phi\rangle \), or
CSecondOrderPartialTestPartialTrial	Second-order operator \( \langle\partial_i\psi, c\,\partial_j\phi\rangle \)
CSeqSolverTraits
CSequentialISTLIndexDistribution	Dummy implementation for ISTL-specific index distribution when no MPI is found
CSimpleDataTransfer
CSimpleInterpolator
CSlotSize
CSolverConfig
CSolverConfig< Eigen::DGMRES< M, P > >
CSolverConfig< Eigen::GMRES< M, P > >
►CSolverPrecon	Use a LinearSolver as Preconditioner
CCreator	A creator to be used instead of the constructor
CSolverTraits
CSparsityPattern	A general sparsity pattern implementation using the full pattern of the basis by adding all local indices
CStandardProblemIteration	A master problem for a single non coupled problem
CStandardProblemIterationAdaptor	StandardProblemIteration when derived from ProblemStat
CStaticLockedPolicy	Stores cache global static, requires locking on write access
CStokesOperator	Stokes operator \( \langle\nabla\mathbf{v}, \nu \nabla\mathbf{u}\rangle + \langle\nabla\cdot\mathbf{v}, p\rangle + \langle q, \langle\nabla\cdot\mathbf{u}\rangle \)
CTaylorHoodBasis	ProblemStatTraits of Taylor-Hood basis of lagrange-type with pressure degree k
Ctfqmr_solver_type	ITL_Solver <tfqmr_solver_type> implementation of Transposed-Free Quasi-Minimal Residual method
CThreadLocalPolicy	Store cache thread local, requires no locking
CTransposedMatrix	The transposed view onto a matrix
CTwist	Permutate the dof indices w.r.t. a global entity orientation
CTypes	A variadic type list
►CUmfpackRunner
CCreator
CUniqueBorderPartition	Determine for each border entity which processor owns it
CValueCategory	Category of type T, e.g. scalar, vector matrix, specified by a tag
CValueCategory< std::reference_wrapper< T > >
CValueCategory< T, std::enable_if_t< std::is_arithmetic_v< T > > >
CVectorBase	CRTP base class for flat vector backends
CVectorFacade	The basic container that stores a base vector and a corresponding basis
CVTKSequenceWriter	Class to write pvd-files which contains a list of all collected vtk-files
CVTKWriter	Adapter for the dune-grid VTKWriter
CYaspGridBasis	Specialization of LagrangeBasis for Grid type Dune::YaspGrid for a given dimension
CZeroOrderTest	Zero-order vector-operator \( (c\, \psi) \)
CZeroOrderTestTrial	Zero-order operator \( \langle\psi, c\,\phi\rangle \)
CZeroOrderTestTrialvec	Zero-order operator \( \langle\psi, \mathbf{b}\cdot\Phi\rangle \)
CZeroOrderTestVec	Zero-order vector-operator \( (\mathbf{b}\cdot\Psi) \)
CZeroOrderTestvecTrialvec	Zero-order operator \( \langle\Psi, c\,\Phi\rangle \), or \( \langle\Psi, A\,\Phi\rangle \)
Cand_t
CcanCommunicate
CGridFactoryInterface
ChasBackupRestoreFacilities
ChasEntity
ChasEntityIterator
ChasSingleGeometryType
CImpl
CisLeafwiseConforming
CisLevelwiseConforming
CITL_Preconditioner
CITL_Solver
CRunnerInterface
CthreadSafe
CTraits
CviewThreadSafe