| CAbsMax | Operation that represents max(|A|,|B|) |
| CAbsMin | Operation that represents min(|A|,|B|) |
| CAccess | Unified accessor class |
| Cadapt | |
| ►CAdaptBase | Interface for adaption loops |
| CAdaptInstationary | AdaptInstationary implements the adaptive procedure for time dependent problems (see ProblemInstat). It contains a pointer to a ProblemInstat object |
| CAdaptStationary | Contains all classes needed for space and time adaption |
| CAdaptInfo | Holds adapt parameters and infos about the problem |
| CAdaptionInterface | Interface for transfer between grid changes |
| CAdaptiveGridFamily< HostGrid > | |
| CAMGCreator< AMGSolver, Traits > | |
| CAnalyticGridFunction< Function, GridView > | A Gridfunction that evaluates a function with global coordinates |
| CAnalyticLocalFunction< Signature, LocalContext, Function > | |
| CAnalyticLocalFunction< R(D), LC, Function > | |
| CAnalyticPreGridFunction< Function > | |
| ►Cand_t | |
| CIsSimilar< Types< A0, As... >, Types< B0, Bs... > > | |
| CArg< I > | |
| CAssembler< GridView, Container, Nodes > | An Assembler is the main driver for building the local element matrices and vectors by assembling operators bound to elements, intersections and boundary intersection |
| CAssembler< GlobalBasis, FlatVector< CoefficientType > > | |
| CAssembler< RowBasis, ColBasis, FlatMatrix< CoefficientType > > | |
| Cassign | |
| Cassign | |
| CAttributeSet< C > | |
| Caverage | |
| CAverageInterpolator< Basis, TreePath > | |
| CBackupRestoreByGridFactory< Grid > | |
| ►CBase | |
| CBoundaryCondition< Mat, Sol, Rhs > | Interface class for boundary conditions |
| ►CBase | |
| CDataTransfer< Basis, Container > | The base class for data transfer classes |
| ►CBase | |
| CDataTransfer< GB, AMDiS::VectorFacade > | |
| ►CBase | |
| CLocalOperator< Traits, Nodes > | The base class for a local operator to be used in a Assembler |
| ►CBase | |
| CCompositeNodeCache< Node > | |
| CPowerNodeCache< Node > | |
| ►CBase | |
| COperator< Traits, Nodes > | The base class for an operator to be used in an Assembler |
| Cbjacobi | |
| CBlockMatrixType< T, class > | |
| CBlockMatrixType< T, typename T::field_type > | |
| CBlockVectorType< T, class > | |
| CBlockVectorType< T, typename T::field_type > | |
| CBoundaryLocalOperator< LocalOperator, Intersection > | The local operator associated to BoundaryOperator |
| ►CBoundaryManagerBase | |
| CBoundaryManager< G > | Manage boundary ids of boundary segments in a grid |
| CBoundaryOperator< Operator, Intersection > | An operator to be assembled on a boundary intersection belonging to a given boundary subset |
| CBoundarySubset< IS > | Class defining a subset of a domain boundary |
| CBoundarySubset< Intersection > | |
| CCallable | |
| CcanCommunicate | |
| CCheckNumCols< T, S0, S1 > | |
| CCheckNumRows< T, S0, S1 > | |
| CCheckSize< T, S0, S1 > | |
| CCoarsenedGridFunction< GV, GF >::CoarsenedLocalFunction< ES, LF >::ChildElement | |
| CClamp< T > | |
| CCoarsenedGridFunction< GV, GF > | A grid function defining data on a coarser entity level than it can be bound to |
| CCoarsenedGridFunction< GV, GF >::CoarsenedLocalFunction< ES, LF > | |
| CDefaultLeafGridViewTraits< GridImp >::Codim< cd > | |
| CDefaultLevelGridViewTraits< GridImp >::Codim< cd > | |
| ►CCommDataHandleIF | |
| CUniqueBorderPartition< Grid > | Determine for each border entity which processor owns it |
| CComposer< F, Gs > | Composition of Functors |
| ►CComposer< Divides, One, Pow<-p > > | |
| CPowImpl< p, false > | |
| ►CComposer< Sqrt, UnaryDot > | |
| CTwoNorm | (Unary-)Functor representing the euclidean 2-norm |
| CComposerBuilder< F, Gs > | |
| CComposerBuilder< Id, F > | |
| ►CComposerBuilder< Id, G > | |
| CComposerBuilder< Minus, G, Zero > | |
| CComposerBuilder< Plus, G, Zero > | |
| CComposerBuilder< Plus, Zero, G > | |
| ►CComposerBuilder< Id, Negate > | |
| CComposerBuilder< Minus, Zero, G > | |
| ►CComposerBuilder< Id, Pow< p1 *p2 > > | |
| CComposerBuilder< PowImpl< p1, pos1 >, PowImpl< p2, pos2 > > | |
| ►CComposerBuilder< Id, Zero > | |
| CComposerBuilder< Minus, Zero, Zero > | |
| CComposerBuilder< Multiplies, G, Zero > | |
| CComposerBuilder< Multiplies, Zero, G > | |
| CComposerBuilder< Multiplies, Zero, Zero > | |
| CComposerBuilder< Plus, Zero, Zero > | |
| ►CComposerBuilder< Minus, Arg< 1 >, Arg< 0 > > | |
| CComposerBuilder< Negate, Minus > | |
| ►CComposerBuilder< Minus, G, Id > | |
| CComposerBuilder< Plus, G, Negate > | |
| ►CComposerBuilder< Pow< p >, Multiplies > | |
| CComposerBuilder< Multiplies, PowImpl< p, pos >, PowImpl< p, pos > > | |
| CComposerBuilder< Scale< F >, Scale< G > > | |
| CComposerGridFunction< Sig, EntitySet, Functor, GridFunctions > | A Gridfunction that applies a functor to the evaluated Gridfunctions |
| CComposerGridFunction< R(D), ES, Functor, GridFunctions... > | |
| CComposerLocalFunction< Signatur, Element, Functor, LocalFunctions > | |
| CComposerLocalFunction< R(D), E, Functor, LocalFunctions... > | |
| CComposerPreGridFunction< Functor, PreGridFunctions > | |
| ►Cconjunction | |
| CIsPreTreePath< std::tuple< Indices... > > | |
| CConsecutivePolicy< Container > | Store cache in instance |
| CFakeContainer< T, value >::const_iterator | |
| CConstant< T > | Functor representing a constant value |
| CConstantGridFunction< T, GridView > | Gridfunction returning a constant value |
| CConstantLocalFunction< Signature, LocalContext, Function > | |
| CConstantLocalFunction< R(D), LC, T > | LocalFunction of a Gridfunction returning a constant value |
| CConstraints< Matrix > | |
| CConstraints< BiLinearForm< RB, CB, T, Traits > > | |
| CConstraints< MTLSparseMatrix< T > > | |
| CConstraints< PetscMatrix< DofMap > > | |
| CContextGeometry< ContextType > | Wrapper class for element and geometry |
| CConvectionDiffusionLocalOperator< LocalFctA, LocalFctB, LocalFctC, LocalFctF, conserving > | |
| CConvectionDiffusionOperator< GridFctA, GridFctB, GridFctC, GridFctF, conserving > | |
| CConvectionDiffusionOperatorTerm< PreGridFctA, PreGridFctB, PreGridFctC, PreGridFctF, c > | |
| CCoordsCompFunction | A functor that evaluates to a component of the global coordinates |
| CCoordsFunction | A functor that evaluates to the global coordinates |
| CAnalyticPreGridFunction< Function >::Creator | |
| CComposerPreGridFunction< Functor, PreGridFunctions >::Creator | |
| CDerivativePreGridFunction< Expr, Type >::Creator | |
| CCoordsCompFunction::Creator | |
| CCoordsFunction::Creator | |
| ►CCreator | |
| CGridFunctionCreator< PreGridFct, class > | |
| ►CCreatorInterface< BaseClass > | 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< BaseClass > | Interface for creators with name |
| ►CCreatorInterface< LinearSolverInterface< M, X, Y > > | |
| ►CCreatorInterfaceName< LinearSolverInterface< M, X, Y > > | |
| CDirectRunner< M, X, Y, Solver >::Creator | |
| CIterativeSolverCreator< M, X, Y, IterativeSolver > | Default solver creator for iterative solvers |
| CKrylovRunner< M, X, Y, ITLSolver >::Creator | |
| CUmfpackRunner< M, X, Y >::Creator | |
| ►CCreatorInterface< Super > | |
| ►CCreatorInterfaceName< Super > | |
| CPreconditioner< M, X, Y, PreconImpl >::Creator | A creator to be used instead of the constructor |
| CSolverPrecon< M, X, Y >::Creator | A creator to be used instead of the constructor |
| ►CCreatorInterface< tag::preconditioner< AMDiS::SeqSolverTraits > > | |
| CISTLPreconCreatorBase< AMDiS::SeqSolverTraits > | |
| ►CCreatorInterface< tag::preconditioner< Traits > > | |
| ►CISTLPreconCreatorBase< Traits > | Base class for precon creators, |
| CAMGPreconCreator< AMGSolver, Traits > | |
| CISTLPreconCreator< Precon, Traits > | Default precon creator |
| CISTLPreconCreator< tag::bjacobi, Traits > | Precon creator for the BJacobi preconditioner |
| CISTLPreconCreator< tag::solver< Traits >, Traits > | Precon creator for the InverseOperator2Preconditioner preconditioner |
| ►CCreatorInterface< tag::solver< AMDiS::SolverTraits > > | |
| CISTLSolverCreatorBase< AMDiS::SolverTraits > | |
| ►CCreatorInterface< tag::solver< Traits > > | |
| ►CISTLSolverCreatorBase< Traits > | Base class for solver creators, |
| CDirectSolverCreator< Solver, Traits > | Default creator for direct solvers |
| ►CISTLIterativeSolverCreatorBase< Traits > | Base solver creator for iterative solvers |
| CGMResSolverCreator< Solver, Traits > | Solver creator for iterative GMRes-like solvers |
| CIterativeSolverCreator< M, X, Y, IterativeSolver > | Default solver creator for iterative solvers |
| CPCGSolverCreator< Solver, Traits > | Solver creator for iterative CG-like solvers |
| CCreatorMap< BaseClass > | 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 | Base tag type for all data transfer tags |
| Cinterpolation_datatransfer | |
| Cno_datatransfer | |
| Csimple_datatransfer | Tag that referrs to the SimpleDataTransfer |
| CDataTransferFactory< Tag > | |
| CDataTransferFactory< tag::interpolation_datatransfer > | |
| CDataTransferFactory< tag::no_datatransfer > | |
| CDataTransferFactory< tag::simple_datatransfer > | Register the SimpleDataTransfer using the tag simple_datatransfer |
| CClamp< T >::DClamp | |
| CDefaultAttributeSet | |
| CDefaultBasisCreator< HostGrid, PreBasisCreator, T, Traits > | Generator for a basis and default problem traits |
| ►CDefaultBasisCreator< Dune::YaspGrid< dim >, Impl::LagrangePreBasisCreator< degrees... > > | |
| ►CLagrangeBasis< Dune::YaspGrid< dim >, degrees... > | |
| CYaspGridBasis< dim, degrees > | Specialization of LagrangeBasis for Grid type Dune::YaspGrid for a given dimension |
| ►CDefaultBasisCreator< Grid, Impl::LagrangePreBasisCreator< degrees... > > | |
| CLagrangeBasis< Grid, degrees > | ProblemStatTraits for a (composite) basis composed of lagrange bases of different degree |
| ►CDefaultBasisCreator< Grid, Impl::TaylorHoodPreBasisCreator< Grid::dimensionworld, 1 > > | |
| CTaylorHoodBasis< Grid, k > | ProblemStatTraits of Taylor-Hood basis of lagrange-type with pressure degree k |
| CDefaultCreators< BaseClass > | |
| 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 |
| ►CDefaultDerivativeTraits | |
| CDerivativeTraits< R(D), tag::jacobian > | |
| Cdefaulted | |
| ►CDefaultGlobalBasis | |
| CGlobalBasis< PB > | Global basis defined on a pre-basis |
| CDefaultIndexDistribution | Dummy implementation for sequential index "distribution" |
| CDefaultIndexDistribution< Self > | |
| CDefaultLeafGridView< GridImp > | |
| CDefaultLeafGridViewTraits< GridImp > | |
| CDefaultLevelGridView< GridImp > | |
| CDefaultLevelGridViewTraits< GridImp > | |
| ►CDefaultLocalView | |
| CLocalView< RB > | |
| CLocalView< CB > | |
| CLocalView< B > | |
| CLocalView< GB > | The restriction of a finite element basis to a single element |
| CDefaultProblemTraits< GB, T, Traits > | Wrapper around a global basis providing default traits |
| CCoordsCompFunction::Derivative | |
| CCoordsFunction::Derivative | |
| CDerivativeGridFunction< GridFunction, Type > | A Gridfunction that returns the derivative when calling localFunction |
| CDerivativePreGridFunction< Expr, Type > | |
| CDerivativeTraits< Sig, Type > | |
| CDerivativeTraits< R(D), tag::value > | |
| CDirichletBC< Basis, RowPath, ColPath, ValueGridFct > | Implements a boundary condition of Dirichlet-type |
| CDiscreteFunction< Coeff, GB, TreePath, R > | A mutable view on the subspace of a DOFVector, |
| CDiscreteFunction< Coeff const, GB, TreePath, R > | A Const DiscreteFunction |
| ►Cdivergence | |
| Cderivative_type | |
| CDivides | Functor that represents A/B |
| Cdivides_assign | |
| Cdivtestvec | |
| Cdivtestvec_divtrialvec | |
| Cdivtestvec_trial | |
| CDot | (Binary-)Functor representing the euclidean dot-product |
| CGlobalBasis< PB >::DummyImpl | |
| CEigenSparseMatrix< T, Orientation > | The basic container that stores a base matrix and a corresponding row/column feSpace |
| CEigenTraits | |
| Celement_operator< E > | |
| CElementGridFunction< GridView, Container > | Gridfunction returning a constant value per element |
| CElementLocalFunction< Signature, IndexSet, Container > | |
| CElementLocalFunction< R(D), IndexSet, Container > | LocalFunction of a Gridfunction returning a constant value per element |
| CEnvironment | Establishes an environment for sequential and parallel AMDiS programs |
| CFaceTransformation< ct, dow > | Affine transformation x := A*x + b |
| CFaceTransformation< typename Domain::field_type, Domain::dimension > | |
| ►CFakeAssigner | |
| CFakeContainer< T, value > | A container-like data-structure not storing anything and with empty implementations in many container-interface functions |
| ►Cfalse_type | |
| CIsPreGridFunction< T > | |
| CIsReferenceWrapper< T > | |
| CFileWriterCreator< SystemVector > | Creator class for filewriters depending on a given type name |
| ►CFileWriterInterface | Interface class for filewriters |
| ►CFileWriterBase | Base class for filewriters |
| CBackupWriter< SystemVector > | |
| CGmshWriter< GV > | The GmshWriter just writes the grid of a given gridView to a gmsh compatible .msh file |
| CVTKWriter< GV, GF > | Adapter for the dune-grid VTKWriter |
| 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< IMS > | Define the flat index-merging strategy for a given strategy IMS |
| CFlatPreBasis< PreBasis > | Transform a PreBasis into one with flat index-merging strategy |
| CForEach< class > | |
| CForEach< PetscVector< DofMap > > | |
| CForEach< VectorBase< D > > | |
| ►CForEach< VectorBase< EigenVector< T > > > | |
| CForEach< EigenVector< T > > | |
| ►CForEach< VectorBase< ISTLBlockVector< T > > > | |
| CForEach< ISTLBlockVector< T > > | |
| ►CForEach< VectorBase< MTLVector< T > > > | |
| CForEach< MTLVector< T > > | |
| CForEach< VectorFacade< T, Impl > > | |
| CGet< I > | |
| CGet_ | |
| CGlobalBasisIdSet< GB, class > | Provide global ids for all DOFs in a global basis |
| ►CGlobalBasisIdSet< Basis::RootBasis > | |
| CGlobalBasisIdSet< Basis, std::void_t< typename Basis::RootBasis > > | |
| CGlobalContext< GV > | |
| Cgrad_test | |
| Cgrad_trial | |
| Cgradtest | |
| Cgradtest_gradtrial | |
| Cgradtest_trial | |
| Cgradtest_trialvec | |
| ►CGridDefaultImplementation | |
| CAdaptiveGrid< HG > | Wrapper class for Dune-grids that allows automatic signalling of events during grid adaptation |
| CGridFactoryInterface | |
| CGridFunctionCreator< Value, std::enable_if_t< Concepts::ConstantToGridFunction< Value > > > | |
| CGridFunctionLocalOperator< LF, Imp > | The main implementation of a local-operator depending on a local-function |
| CGridFunctionLocalOperatorTransposed< Transposed > | |
| CGridFunctionOperator< GF, Imp > | The main implementation of an operator depending on a grid-function |
| CGridFunctionOperatorRegistry< Tag, LocalContext > | 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< Transposed > | The transposed operator, implemented in terms of its transposed by calling assemble with inverted arguments on the transposed element-matrix |
| ChasBackupRestoreFacilities | |
| CHasDerivative | |
| ChasEntity | |
| ChasEntityIterator | |
| CHasFunctorOrder | |
| CHasGridFunctionTypes | |
| CLeafNodeCache< Node >::CoordKey::hasher | |
| CHasLocalFunction | |
| CHasLocalFunctionDerivative | |
| CHasPartial | |
| ChasSingleGeometryType | |
| CHierarchicNodeWrapper< TreePath, F > | |
| CId | (Unary-)Functor representing the identity |
| CImpl | |
| CIndexMapTuple< Indices, Map > | |
| CIndexMapTuple< std::index_sequence< I... >, Map > | |
| CInitfile | |
| CInitfileParser | Parser for AMDiS initfile format |
| CInnerProduct< class > | General implementation of recursive inner-product |
| CInnerProduct< PetscVector< DofMap > > | |
| CInnerProduct< VectorBase< D > > | |
| ►CInnerProduct< VectorBase< EigenVector< T > > > | |
| CInnerProduct< EigenVector< T > > | |
| ►CInnerProduct< VectorBase< ISTLBlockVector< T > > > | |
| CInnerProduct< ISTLBlockVector< T > > | |
| ►CInnerProduct< VectorBase< MTLVector< T > > > | |
| CInnerProduct< MTLVector< T > > | |
| CInnerProduct< VectorFacade< S, Impl > > | |
| CInterpolateData | |
| CInterpolationDataTransfer< Basis, Container > | |
| CInterpolatorFactory< Tag > | |
| CInterpolatorFactory< tag::assign > | |
| CInterpolatorFactory< tag::average > | |
| CInterpolatorFactory< tag::local_average > | |
| Cintersection_operator< I > | |
| ►CInverseOperator | |
| CDirectRunner< M, X, Y, Solver > | For the (external) direct solvers |
| CIterativeSolverWrapper< S > | |
| ►Cis_arithmetic | |
| ►CConstantToGridFunction< T > | |
| CConstantToGridFunction< std::reference_wrapper< T > > | |
| ►Cis_integral | |
| CIsPreTreePath< Index > | |
| CIsPreTreePath< std::integer_sequence< Index, I... > > | |
| CIsPreTreePath< std::integral_constant< Index, I > > | |
| CIsFlatIndex< T > | |
| ►Cis_same | |
| CIsSame< T0, Ts... > | |
| ►CIsSimilar< A, B > | |
| CIsSimilar< Types< A >, Types< B > > | |
| CisLeafwiseConforming | |
| CisLevelwiseConforming | |
| CIsSame< Ts > | |
| CISTLBCRSMatrix< T, CommType > | |
| CISTLIndexDistributionType< G, L, Comm > | |
| CISTLLinearOperatorCreator< M, X, Y > | Creator to create Linear Operator objects |
| CISTLParallelPreconditionerCreator< X, Y > | Creator to create parallel Preconditioners |
| CISTLScalarProductCreator< X > | Creator to create ScalarProduct objects |
| CISTLTraits | |
| CIsValidTreePath< Tree, TreePath, NodeTag > | |
| ►CITL_Preconditioner | |
| CDiagonalPreconditioner | ITL_Preconditioner implementation of diagonal (jacobi) preconditioner, |
| CDiagonalPreconditioner | ITL_Preconditioner implementation of diagonal (jacobi) preconditioner, |
| CICPreconditioner | ITL_Preconditioner implementation of IC (Incomplete Cholesky factorization) preconditioner |
| CILUPreconditioner | ITL_Preconditioner implementation of ILU (Incomplete LU factorization) preconditioner |
| CIdentityPreconditioner | ITL_Preconditioner implementation of identity preconditioner, |
| ►CITL_Solver | |
| 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 |
| 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 |
| Cfgmres_type | ITL_Solver <fgmres_type> implementation of flexible GMRes method |
| Cgcr_type | ITL_Solver <gcr_type> implementation of generalized conjugate residual method |
| Cgmres_type | ITL_Solver <gmres_type> implementation of generalized minimal residual method |
| Cidr_s_type | ITL_Solver <idr_s_type> implementation of Induced Dimension Reduction method |
| Cminres_solver_type | ITL_Solver <minres_solver_type> implementation of minimal residual method |
| Cpreonly_type | ITL_Solver <preonly_type> implementation of preconditioner as |
| Cqmr_solver_type | ITL_Solver <qmr_solver_type> implementation of Quasi-Minimal Residual method |
| Ctfqmr_solver_type | ITL_Solver <tfqmr_solver_type> implementation of Transposed-Free Quasi-Minimal Residual method |
| ►Cjacobian | |
| Cderivative_type | |
| ►CLeafNode | |
| CLeafNodeCache< Node > | Cache of LocalBasis evaluations and jacobians at local points |
| CLinearSolverInterface< M, X, Y > | |
| ►CLinearSolverInterface< M, X, Y > | |
| CDirectRunner< M, X, Y, Solver > | For the (external) direct solvers |
| CIterativeRunner< M, X, Y, IterativeSolver > | |
| CKrylovRunner< M, X, Y, ITLSolver > | Wrapper class for different MTL4 itl-solvers. These solvers are parametrized by Matrix and Vector |
| CUmfpackRunner< M, X, Y > | Wrapper for the external UMFPACK solver |
| ►CLinearSolverInterface< Mat, VecX, VecX > | |
| CLinearSolver< Mat, VecX, VecY > | Implementation of LinearSolverInterface for EIGEN solvers |
| CLinearSolver< Mat, VecX, VecY > | Implementation of LinearSolverInterface for EIGEN solvers |
| CLinearSolver< Mat, VecX, VecY > | Implementation of LinearSolverInterface for EIGEN solvers |
| ►CLinearSolverInterface< Matrix, VectorX, VectorY > | |
| CLinearSolver< Mat, VecX, VecY > | Implementation of LinearSolverInterface for EIGEN solvers |
| Clocal_average | |
| CLocalAssembler< GridView, Container, Nodes > | |
| CLocalAverageInterpolator< Basis, TreePath > | |
| CDiscreteFunction< Coeff, GB, TreePath, R >::LocalFunction< Type > | |
| CLocalOperatorAdapter< LocalOperator, RowTreePath, ColTreePath > | The local operator associated to the OperatorAdapter |
| CLocalToGlobalBasisAdapter< BasisCache, Geometry > | Convert a simple (scalar) local basis into a global basis |
| CLocalViewPair< RB, CB > | 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 |
| CMap< T > | 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 > > | |
| CMappedRangeView< R, F > | A range transforming the values of another range on-the-fly |
| CMapTuple< Tuple, Map > | |
| CMapTuple< std::tuple< T... >, Map > | |
| ►CMarker< Grid > | Base class for all markers |
| ►CEstimatorMarker< Grid > | Base class for all estimator-based markers |
| CESMarker< Grid > | Equidistribution strategy |
| CGERSMarker< Grid > | Guaranteed error reduction strategy |
| CGRMarker< Grid > | Global refinement |
| CMSMarker< Grid > | Maximum strategy |
| CGridFunctionMarker< Grid, GridFct > | Marker based on an indicator given as grid-function |
| CEigenTraits::Matrix< class, class > | |
| CISTLTraits::Matrix< RowBasis, ColBasis > | |
| CMTLTraits::Matrix< class, class > | |
| CPetscTraits::Matrix< RowBasis, ColBasis > | |
| Cmatrix | |
| CMatrixFacade< T, MatrixImpl > | |
| ►CMatrixFacade< double, Traits::template Matrix< RB, CB >::template Impl > | |
| CBiLinearForm< RB, CB, T, Traits > | |
| CMatrixNnzStructure | Sparsity pattern used to create PETSc matrices |
| CMatrixSize | |
| CMax | Operation that represents max(A,B) |
| CMeshCreator< G > | A creator class for dune grids |
| CMin | Operation that represents min(A,B) |
| CMinus | Functor that represents A-B |
| Cminus_assign | |
| CMTLSparseMatrix< T > | The basic container that stores a base matrix |
| CMTLTraits | |
| CMultiIndex | |
| CMultiplies | Functor that represents A*B |
| Cmultiplies_assign | |
| CNegate | Functor that represents A-B |
| CNoDataTransfer | Implementation of DataTransfer that does not interpolate, but just resizes the containers to the dimension of the basis |
| CNodeDataTransfer< Node, Container, Basis > | |
| CNodeIdSet< PB, TP, NodeTag > | |
| CNodeIdSet< PreBasis, TreePath > | |
| CNodeWrapper< NodeType > | Wrapper around a basis-node storing just a pointer and providing some essential functionality like size, localIndex, and treeIndex |
| ►CNodeWrapper< Node > | |
| CCompositeNodeCache< Node > | |
| CLeafNodeCache< Node > | Cache of LocalBasis evaluations and jacobians at local points |
| CPowerNodeCache< Node > | |
| Cnone | |
| CNoOp | A functor with no operation |
| CNotifier< Event, Events > | Mixin for signaling of certain events |
| CNotifier< Event > | |
| ►CNotifier< event::adapt > | |
| CGlobalBasis< PB > | Global basis defined on a pre-basis |
| CNotifier< event::postAdapt > | |
| CNotifier< event::preAdapt > | |
| ►CNotifier< event::preAdapt, event::adapt, event::postAdapt > | |
| CAdaptiveGrid< HG > | Wrapper class for Dune-grids that allows automatic signalling of events during grid adaptation |
| ►CObserverInterface< Event > | |
| CObserver< Event, index_t< Is > > | |
| CObserver< Event, Tags > | Implementation of the ObserverInterface |
| ►CObserverInterface< event::adapt > | |
| ►CObserver< event::adapt > | |
| CDOFVector< GB, T, Traits > | The basic container that stores a base vector and a corresponding basis |
| CElementVector< G, T > | An adaptive container that stores a value per grid element |
| CGlobalBasis< PB > | Global basis defined on a pre-basis |
| CLinearForm< GB, T, Traits > | The basic container that stores a base vector and a corresponding basis |
| ►CObserverInterface< event::postAdapt > | |
| ►CObserver< event::postAdapt > | |
| CDOFVector< GB, T, Traits > | The basic container that stores a base vector and a corresponding basis |
| CElementVector< G, T > | An adaptive container that stores a value per grid element |
| ►CObserverInterface< event::preAdapt > | |
| ►CObserver< event::preAdapt > | |
| CDOFVector< GB, T, Traits > | The basic container that stores a base vector and a corresponding basis |
| CElementVector< G, T > | An adaptive container that stores a value per grid element |
| ►CObserverSequenceImpl< Event, Tags > | |
| CBiLinearForm< RB, CB, T, Traits > | |
| COperatorAdapter< Operator, RowTreePath, ColTreePath > | 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< Tag, Expr > | |
| ►Coptional | |
| COptionalNoCopy< TreeCache > | |
| COptionalNoCopy< T > | Modification of std::optional that does not copy or move its content |
| ►Cpair | |
| CGlobalIdType< EntityIdType > | Type of a global used used to represent DOFs uniquely |
| ►Cpartial | |
| Cderivative_type | |
| Cpartial_test | |
| Cpartial_trial | |
| Cpartialtest | |
| Cpartialtest_partialtrial | |
| Cpartialtest_trial | |
| CDefaultLeafGridViewTraits< GridImp >::Codim< cd >::Partition< pit > | Define types needed to iterate over entities of a given partition type |
| CDefaultLevelGridViewTraits< GridImp >::Codim< cd >::Partition< pit > | Define types needed to iterate over entities of a given partition type |
| CPeriodicBC< Basis, TP > | Implements a periodic boundary condition |
| CPetscIndexDistributionType< GlobalId, LI, Comm > | By default the PetscParallelIndexDistribution is just a sequential distribution |
| CPetscMatrix< DofMap > | The basic container that stores a base matrix |
| CPetscSequentialIndexDistribution< LI > | Fallback for PetscParallelIndexDistribution in case there is only one mpi core |
| CPetscTraits | |
| CPetscVector< DofMap > | The basic container that stores a base vector data |
| CPlus | Functor that represents A+B |
| Cplus_assign | |
| ►CPolicy | |
| CConcurrentCache< ShapeValues > | |
| CConcurrentCache< ShapeGradients > | |
| CConcurrentCache< Key, Data, Policy, Container > | The class template ConcurrentCache describes an associative static container that allows the concurrent access to the stored data |
| CPolynomial | |
| CpostAdapt | |
| CPower | Functor that represents x^p, |
| CPowImpl< p, positive > | |
| CPowImpl< p, true > | Functor that represents x^p |
| CPowType< p > | |
| CPowType< 0 > | |
| CPowType< 1 > | |
| CpreAdapt | |
| CPreBasisFactory | |
| CPreconConfig< Precon > | |
| CPreconConfig< Eigen::IncompleteLUT< T, I > > | |
| Cpreconditioner< Traits > | |
| ►CPreconditioner | |
| CPreconWrapper< P, S > | |
| ►CPreconditionerInterface< M, X, Y > | Interface for Preconditioner y = M*x |
| CPreconditioner< M, X, Y, PreconImpl > | Wrapper for using ITL preconditioners in AMDiS |
| CSolverPrecon< M, X, Y > | Use a LinearSolver as Preconditioner |
| ►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() |
| CNewtonIteration< ProblemType > | |
| ►CStandardProblemIteration | A master problem for a single non coupled problem |
| ►CStandardProblemIterationAdaptor< ProblemStat< Traits > > | |
| CProblemStat< Traits > | |
| CStandardProblemIterationAdaptor< Model > | StandardProblemIteration when derived from ProblemStat |
| ►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 |
| CProblemStat< Traits > | |
| ►CProblemTimeInterface | Interface for time dependent problems. Concrete problems must override all pure virtual methods |
| ►CProblemInstatBase | Base class for ProblemInstat |
| CProblemInstat< Traits > | Standard implementation of ProblemTimeInterface for a time dependent problems |
| CReference< T > | Functor representing a constant value |
| Cremove_cvref< T > | Remove cv and ref qualifiers of type T |
| ►CRunnerInterface | |
| CUmfpackRunner< M, X, Y > | Wrapper for the external UMFPACK solver |
| Cscalar | |
| CAdaptInfo::ScalContent | Stores adapt infos for a scalar problem or for one component of a vector valued problem |
| CScale< Factor > | Functor that represents f*A |
| 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 \) |
| CSequentialISTLIndexDistribution | Dummy implementation for ISTL-specific index distribution when no MPI is found |
| CSignum | Functor that represents the signum function |
| CSimpleDataTransfer< Basis, Container > | |
| CSimpleInterpolator< Basis, TreePath > | |
| CSlotSize | |
| Csolver< Traits > | |
| CSolverConfig< Solver > | |
| CSolverConfig< Eigen::DGMRES< M, P > > | |
| CSolverConfig< Eigen::GMRES< M, P > > | |
| CSolverConfig< Eigen::UmfPackLU< M > > | |
| CSolverTraits< Mat, VecX, VecY > | |
| CSparsityPattern | A general sparsity pattern implementation using the full pattern of the basis by adding all local indices |
| CStaticConstant< T, value > | Functor representing a static constant value |
| CStaticLockedPolicy< Container > | Stores cache global static, requires locking on write access |
| Cstokes | |
| 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 \) |
| Ctest | |
| Ctest_divtrialvec | |
| Ctest_gradtrial | |
| Ctest_partialtrial | |
| Ctest_trial | |
| Ctest_trialvec | |
| Ctestvec | |
| Ctestvec_gradtrial | |
| Ctestvec_trial | |
| Ctestvec_trialvec | |
| CThreadLocalPolicy< Container > | Store cache thread local, requires no locking |
| CthreadSafe | |
| ►CTraits | |
| CLocalToGlobalBasisAdapterTraits< LocalBasisTraits, dimGlobal > | Traits class for local-to-global basis adaptors |
| ►CTraits | |
| CAdaptiveGridFamily< HostGrid >::Traits | |
| ►CTraits | |
| CSeqSolverTraits< Traits > | |
| CTrans | |
| CTransform< class > | |
| CTransform< PetscVector< DofMap > > | |
| CTransform< VectorBase< D > > | |
| ►CTransform< VectorBase< EigenVector< T > > > | |
| CTransform< EigenVector< T > > | |
| ►CTransform< VectorBase< ISTLBlockVector< T > > > | |
| CTransform< ISTLBlockVector< T > > | |
| ►CTransform< VectorBase< MTLVector< T > > > | |
| CTransform< MTLVector< T > > | |
| CTransform< VectorFacade< T, Impl > > | |
| CTransposedMatrix< Matrix > | The transposed view onto a matrix |
| CConstraints< MTLSparseMatrix< T > >::Triplet< Value > | |
| ►Ctrue_type | |
| CIsFlatIndex< std::array< I, 1 > > | |
| CIsPreGridFunction< AnalyticPreGridFunction< Functor > > | |
| CIsPreGridFunction< ComposerPreGridFunction< Functor, PreGridFcts... > > | |
| CIsPreGridFunction< DerivativePreGridFunction< Expr, Type > > | |
| CIsPreGridFunction< Operation::CoordsCompFunction > | |
| CIsPreGridFunction< Operation::CoordsFunction > | |
| CIsReferenceWrapper< std::reference_wrapper< T > > | |
| CIsSame<> | |
| CIsSimilar< Types<>, Types<> > | |
| CTwist< IdSet, dim > | Permutate the dof indices w.r.t. a global entity orientation |
| CTwist< typename Grid::GlobalIdSet, GridView::dimension > | |
| CTypes< Ts > | A variadic type list |
| CUnaryDot | (Unary-)Functor representing the euclidean dot-product |
| Cunknown | |
| CUpdateData | |
| Cvalue | |
| CValueCategory< T, class > | 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 > > > | |
| CEigenTraits::Vector< class > | |
| CISTLTraits::Vector< class > | |
| CMTLTraits::Vector< class > | |
| CPetscTraits::Vector< Basis > | |
| Cvector | |
| ►Cvector | |
| CFlatMatrix< CoefficientType > | |
| CFlatVector< CoefficientType > | |
| CFlatMatrix< T, Allocator > | Dense matrix with row-wise storage in flat data vector |
| CFlatVector< T, Allocator > | Flat data vector to be used in assembling as element vector |
| Cpath | |
| CVectorBase< Derived > | CRTP base class for flat vector backends |
| ►CVectorBase< EigenVector< T > > | |
| CEigenVector< T > | The basic container that stores a base vector and a corresponding basis |
| ►CVectorBase< ISTLBlockVector< T > > | |
| CISTLBlockVector< T > | |
| ►CVectorBase< MTLVector< T > > | |
| CMTLVector< T > | The basic container that stores a base vector data |
| CVectorFacade< T, VectorImpl > | The basic container that stores a base vector and a corresponding basis |
| ►CVectorFacade< double, Traits::template Vector< GB >::template Impl > | |
| CDOFVector< GB, T, Traits > | The basic container that stores a base vector and a corresponding basis |
| CLinearForm< GB, T, Traits > | The basic container that stores a base vector and a corresponding basis |
| CviewThreadSafe | |
| CVTKSequenceWriter< GridView > | Class to write pvd-files which contains a list of all collected vtk-files |
| 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 \) |
| CGlobalIdSet const & | |
| Cint | |
| CSqrt | |
| Cstatic constexpr int | |
| Ctemplate Impl< double > | |
| Ctemplate Impl< double > | |
1.9.4