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... > > | |
CApply< T > | Default implementation of the recursive map function |
CApply< std::array< T, n > > | |
CApply< std::pair< T1, T2 > > | |
CApply< std::tuple< TT... > > | |
CApply< std::vector< T > > | |
CApply< TypeTree::InnerNodeStorage< Value, Container > > | |
CApply< TypeTree::LeafNodeStorage< Value > > | |
CApply< TypeTree::TreeContainerStorage< Container > > | |
CArg< I > | |
CAssemblerInterface< Traits, Nodes > | Abstract base-class of a Assembler |
►CAssemblerInterface< Traits, Nodes... > | |
CAssembler< Traits, Operator, Nodes > | Implementation of interface AssemblerBase |
CAssemblerTriple< ElementAssembler, IntersectionAssembler, BoundaryAssembler > | |
Cassign | |
Cassign | |
CAttributeSet< C > | |
Caverage | |
CBackupRestoreByGridFactory< Grid > | |
►CBase | |
CBoundaryCondition< Mat, Sol, Rhs > | Interface class for boundary conditions |
►CBase | |
CCompositeNodeCache< Node > | |
CPowerNodeCache< Node > | |
Cbjacobi | |
CBlockMatrixType< T, class > | |
CBlockMatrixType< T, typename T::field_type > | |
CBlockVectorType< T, class > | |
CBlockVectorType< T, typename T::field_type > | |
►CBoundaryManagerBase | |
CBoundaryManager< G > | Manage boundary ids of boundary segments in a grid |
CBoundarySubset< IS > | Class defining a subset of a domain boundary |
►CBoundarySubset< I > | |
Cboundary_operator< I > | |
CBoundarySubset< Intersection > | |
CCallable | |
CcanCommunicate | |
CCheckNumCols< T, S0, S1 > | |
CCheckNumRows< T, S0, S1 > | |
CCheckSize< T, S0, S1 > | |
CClamp< T > | |
CDefaultLevelGridViewTraits< GridImp >::Codim< cd > | |
CDefaultLeafGridViewTraits< GridImp >::Codim< cd > | |
CRowNodeData< NodeData, Tree, leafOnly >::ColNodeData< RowNode > | |
►CCommDataHandleIF | |
CUniqueBorderPartition< Grid > | Determine for each border entity which processor owns it |
CCommunicationCreator< C > | Implementation of a creator pattern for Communication types |
CCommunicationCreator< DistributedCommunication< G, L > > | |
CCommunicationCreator< ISTLCommunication< G, L > > | |
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 > > | |
►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< EigenSparseMatrix< T, O > > | |
CConstraints< ISTLBCRSMatrix< T, C > > | |
CConstraints< MTLSparseMatrix< T > > | |
CConstraints< PetscMatrix< DofMap > > | |
CContainerFactory< NodeToValue, leafOnly > | A factory class creating a hybrid container compatible with a type tree |
CContextGeometry< LC > | Wrapper class for element and geometry |
CCoordsCompFunction | A functor that evaluates to a component of the global coordinates |
CCoordsFunction | A functor that evaluates to the global coordinates |
CAnalyticPreGridFunction< Function >::Creator | |
CCoordsFunction::Creator | |
CCoordsCompFunction::Creator | |
CDerivativePreGridFunction< Expr, Type >::Creator | |
CFunctorPreGridFunction< Functor, PreGridFunctions >::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< Interface > | |
►CCreatorInterfaceName< Interface > | |
CISTLPreconCreator< Model, Traits >::Creator | |
CISTLSolverCreator< Model, Traits >::Creator | |
►CCreatorInterface< ISTLPreconCreatorInterface< Traits > > | |
►CCreatorInterfaceName< ISTLPreconCreatorInterface< Traits > > | |
CAMGPreconCreator< AMGSolver, Traits > | A creator for AMGPrecon, reads the smoother type from initfile: |
►CCreatorInterface< LinearSolverInterface< Mat, Vec > > | |
►CCreatorInterfaceName< LinearSolverInterface< Mat, Vec > > | |
CIterativeSolverCreator< Mat, Vec, IterativeSolver > | Default solver creator for iterative solvers |
►CCreatorInterface< Super > | |
►CCreatorInterfaceName< Super > | |
CAMGPrecon< AMGCreator, Smoother, Traits >::Creator | |
CISTLSolver< Mat, Vec >::Creator | A creator to be used instead of the constructor |
CLinearSolver< Mat, Vec, Runner >::Creator | A creator to be used instead of the constructor |
CPreconditioner< Mat, Vec, PreconImpl >::Creator | A creator to be used instead of the constructor |
CSolverPrecon< Mat, Vec >::Creator | A creator to be used instead of the constructor |
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 |
CDataTransferFactory< Container > | Factory to create DataTransfer objects based on the DataTransferOperation |
►CDataTransferInterface< Container > | Interface for Containers allowing data transfer between grid changes |
CDataTransfer< Container, Basis > | |
CNoDataTransfer< Container > | Implementation of DataTransferInterface that does not interpolate, but just resizes the containers to the dimension of the basis |
CDataTransferWrapper< Container > | |
CDataTransferWrapper< Self > | |
CClamp< T >::DClamp | |
CDefaultAssemblerTraits< LC, C > | |
CDefaultAttributeSet | |
CDefaultBasisCreator< HostGrid, PreBasisCreator, T, TraitsImpl > | 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, k > > | |
CTaylorHoodBasis< Grid, k > | ProblemStatTraits of Taylor-Hood basis of lagrange-type with pressure degree k |
CDefaultCommunicationCreator< C > | |
CDefaultCreators< BaseClass > | |
CDefaultCreators< ISTLPreconCreatorInterface< Traits > > | Adds default creators for preconditioners for ISTL |
CDefaultCreators< PreconditionerInterface< Mat, Vec > > | |
►CDefaultDerivativeTraits | |
CDerivativeTraits< R(D), tag::gradient > | |
CDerivativeTraits< R(D), tag::jacobian > | |
Cdefaulted | |
►CDefaultGlobalBasis | |
CGlobalBasis< PB > | Global basis defined on a pre-basis |
CDefaultLeafGridView< GridImp > | |
CDefaultLeafGridViewTraits< GridImp > | |
CDefaultLevelGridView< GridImp > | |
CDefaultLevelGridViewTraits< GridImp > | |
CDefaultProblemTraits< GB, T, TraitsImpl > | Wrapper around a global basis providing default traits |
CDefaultSolverCreators< Traits, Interface > | Adds default creators for linear solvers based on Dune::BCRSMatrix |
►CDefaultSolverCreators< SolverTraits< Mat, Vec >, LinearSolverInterface< Mat, Vec > > | |
CDefaultCreators< LinearSolverInterface< Mat, Vec > > | Adds default creators for linear solvers based on Eigen::SparseMatrix |
►CDefaultSolverCreators< Traits, ISTLSolverCreatorInterface< Traits > > | |
CDefaultCreators< ISTLSolverCreatorInterface< Traits > > | |
CCoordsFunction::Derivative | |
CCoordsCompFunction::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< SubBasis, 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 |
CDistributedCommunication< GlobalId, SizeType > | |
►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 > | |
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 |
CFlag | Encapsulates flags which represents simple information. Used e.g. while mesh traversal to specify, which elements should be visited |
CFlatPreBasis< PreBasis, MultiIndex > | |
CForEach< V > | Default implementation of the recursive forEach function |
CForEach< std::array< T, n > > | |
CForEach< std::pair< T1, T2 > > | |
CForEach< std::tuple< TT... > > | |
CForEach< std::vector< T > > | |
CForEach< TypeTree::InnerNodeStorage< Value, Container > > | |
CForEach< TypeTree::LeafNodeStorage< Value > > | |
CForEach< TypeTree::TreeContainerStorage< Container > > | |
CFunctorGridFunction< Functor, GridFunctions > | A Gridfunction that applies a functor to the evaluated Gridfunctions |
CFunctorLocalFunction< Signatur, Functor, LocalFunctions > | |
CFunctorLocalFunction< R(D), Functor, LocalFunctions... > | |
CFunctorPreGridFunction< Functor, PreGridFunctions > | |
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 > > | |
Cgmres< Solver > | |
Cgrad_test | |
Cgrad_trial | |
►Cgradient | |
Cderivative_type | |
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< Function, std::enable_if_t< Concepts::CallableDomain< Function > > > | |
CGridFunctionCreator< Value, std::enable_if_t< Concepts::ConstantToGridFunction< Value > > > | |
CGridType | |
ChasBackupRestoreFacilities | |
CHasDerivative | |
ChasEntity | |
ChasEntityIterator | |
CHasFunctorOrder | |
CHasGridFunctionTypes | |
CLeafNodeCache< Node >::CoordKey::hasher | |
CHasLocalFunction | |
CHasLocalFunctionDerivative | |
CHasPartial | |
ChasSingleGeometryType | |
CHierarchicNodeToRangeMap | A simple node to range map using the nested tree indices |
CId | (Unary-)Functor representing the identity |
CImpl | |
CIndexMapTuple< Indices, Map > | |
CIndexMapTuple< std::index_sequence< I... >, Map > | |
CDistributedCommunication< GlobalId, SizeType >::IndexSet | |
CInitfile | |
CInitfileParser | Parser for AMDiS initfile format |
CInnerNodeStorage< Value, Container > | |
CInterpolateData | |
Cintersection_operator< I > | |
►CInverseOperator | |
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, C > | |
CISTLLinearOperatorCreator< M, X, Y > | Creator to create Linear Operator objects |
CISTLParallelPreconditionerCreator< X, Y > | Creator to create parallel Preconditioners |
►CISTLPreconCreatorInterface< Traits > | |
CAMGPrecon< AMGCreator, Smoother, Traits > | |
CISTLPreconCreator< Model, Traits > | Base class for precon creators, |
►CISTLPreconCreator< PreconCreator< Precon, Traits >, Traits > | |
CPreconCreator< Precon, Traits > | Default precon creator |
►CISTLPreconCreator< PreconCreator< tag::bjacobi, Traits >, Traits > | |
CPreconCreator< tag::bjacobi, Traits > | Precon creator for the BJacobi preconditioner |
►CISTLPreconCreator< PreconCreator< tag::solver, Traits >, Traits > | |
CPreconCreator< tag::solver, Traits > | Precon creator for the InverseOperator2Preconditioner preconditioner |
CISTLScalarProductCreator< X > | Creator to create ScalarProduct objects |
►CISTLSolverCreatorInterface< Traits > | |
CISTLSolverCreator< Model, Traits > | Base class for solver creators, |
►CISTLSolverCreator< Creator, Traits > | |
CISTLIterativeSolverCreator< Creator, Traits > | Base solver creator for iterative solvers |
►CISTLSolverCreator< DirectSolverCreator< Solver, Traits >, Traits > | |
CDirectSolverCreator< Solver, Traits > | Default creator for direct solvers |
►CISTLSolverCreator< IterativeSolverCreator< Solver, Traits >, Traits > | |
►CISTLIterativeSolverCreator< IterativeSolverCreator< Solver, Traits >, Traits > | |
CIterativeSolverCreator< Mat, Vec, IterativeSolver > | Default solver creator for iterative solvers |
►CISTLSolverCreator< IterativeSolverCreator< tag::gmres< Solver >, Traits >, Traits > | |
►CISTLIterativeSolverCreator< IterativeSolverCreator< tag::gmres< Solver >, Traits >, Traits > | |
CIterativeSolverCreator< tag::gmres< Solver >, Traits > | Solver creator for iterative GMRes-like solvers |
►CISTLSolverCreator< IterativeSolverCreator< tag::pcg< Solver >, Traits >, Traits > | |
►CISTLIterativeSolverCreator< IterativeSolverCreator< tag::pcg< Solver >, Traits >, Traits > | |
CIterativeSolverCreator< tag::pcg< Solver >, Traits > | Solver creator for iterative CG-like solvers |
CISTLTraits< Basis > | |
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 |
CIdentityPreconditioner | ITL_Preconditioner implementation of identity preconditioner, |
CILUPreconditioner | ITL_Preconditioner implementation of ILU (Incomplete LU factorization) 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 |
CLeafNodeStorage< Value > | |
►CLinearSolverInterface< Mat, Vec > | Abstract base class for linear solvers |
CISTLSolver< Mat, Vec > | Implementation of RunnerInterface for ISTL solvers |
CLinearSolver< Mat, Vec, Runner > | Wrapper class for various solvers. These solvers are parametrized by MatrixType and VectorType. The different algorithms, like krylov subspace methods or other external solvers where the backend provides an interface, can be assigned by different Runner objects |
CDiscreteFunction< Coeff, GB, TreePath, R >::LocalFunction< Type > | |
CFunctorLocalFunction< R(D), Functor, LocalFunctions... >::LocalFunctionWrapper< LocalFct > | |
►CLocalOperator< Derived, LC > | The main implementation of an operator to be used in a Assembler |
CGridFunctionOperatorBase< Derived, LC, GF > | The main implementation of an CRTP-base class for operators using a grid-function coefficient to be used in an Assembler |
►CLocalOperator< ConvectionDiffusionOperator< LC, GridFctA, GridFctB, GridFctC, GridFctF, conserving >, LC > | |
CConvectionDiffusionOperator< LC, GridFctA, GridFctB, GridFctC, GridFctF, conserving > | |
►CLocalOperator< Derived, Transposed::LocalContext > | |
CGridFunctionOperatorTransposed< Derived, Transposed > | The transposed operator, implemented in term of its transposed by calling getElementMatrix with inverted arguments |
►CLocalOperator< GridFunctionOperator< Tag, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< Tag, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< Tag, LC, GridFct > | The base-template for GridFunctionOperators |
►CLocalOperator< GridFunctionOperator< tag::divtestvec, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::divtestvec, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::divtestvec, LC, GridFct > | First-order operator \( \langle\nabla\cdot\Psi, c\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::divtestvec_divtrialvec, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::divtestvec_divtrialvec, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::divtestvec_divtrialvec, LC, GridFct > | Second-order operator \( \langle\nabla\cdot\Psi, c\,\nabla\cdot\Phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::divtestvec_trial, LC, GridFct >, GridFunctionOperator< tag::test_divtrialvec, LC, GridFct > ::LocalContext > | |
►CGridFunctionOperatorTransposed< GridFunctionOperator< tag::divtestvec_trial, LC, GridFct >, GridFunctionOperator< tag::test_divtrialvec, LC, GridFct > > | |
CGridFunctionOperator< tag::divtestvec_trial, LC, GridFct > | First-order operator \( \langle\nabla\cdot\Psi, c\,\phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::gradtest, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::gradtest, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::gradtest, LC, GridFct > | First-order operator \( \langle\nabla\psi, b\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::gradtest_gradtrial, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::gradtest_gradtrial, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::gradtest_gradtrial, LC, GridFct > | Second-order operator \( \langle\nabla\psi, c\,\nabla\phi\rangle \), or \( \langle\nabla\psi, A\,\nabla\phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::gradtest_trial, LC, GridFct >, GridFunctionOperator< tag::test_gradtrial, LC, GridFct > ::LocalContext > | |
►CGridFunctionOperatorTransposed< GridFunctionOperator< tag::gradtest_trial, LC, GridFct >, GridFunctionOperator< tag::test_gradtrial, LC, GridFct > > | |
CGridFunctionOperator< tag::gradtest_trial, LC, GridFct > | First-order operator \( \langle\nabla\psi, \mathbf{b}\,\phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::gradtest_trialvec, LC, GridFct >, GridFunctionOperator< tag::testvec_gradtrial, LC, GridFct > ::LocalContext > | |
►CGridFunctionOperatorTransposed< GridFunctionOperator< tag::gradtest_trialvec, LC, GridFct >, GridFunctionOperator< tag::testvec_gradtrial, LC, GridFct > > | |
CGridFunctionOperator< tag::gradtest_trialvec, LC, GridFct > | First-order operator \( \langle\nabla\psi, c\,\Phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::partialtest, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::partialtest, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::partialtest, LC, GridFct > | First-order operator \( \langle\partial_i\psi, c\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::partialtest_partialtrial, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::partialtest_partialtrial, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::partialtest_partialtrial, LC, GridFct > | Second-order operator \( \langle\partial_i\psi, c\,\partial_j\phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::partialtest_trial, LC, GridFct >, GridFunctionOperator< tag::test_partialtrial, LC, GridFct > ::LocalContext > | |
►CGridFunctionOperatorTransposed< GridFunctionOperator< tag::partialtest_trial, LC, GridFct >, GridFunctionOperator< tag::test_partialtrial, LC, GridFct > > | |
CGridFunctionOperator< tag::partialtest_trial, LC, GridFct > | First-order operator \( \langle\partial_i\psi, c\,\phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::stokes, LC, ViscosityExpr >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::stokes, LC, ViscosityExpr >, LC, ViscosityExpr > | |
CGridFunctionOperator< tag::stokes, LC, ViscosityExpr > | 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 \) |
►CLocalOperator< GridFunctionOperator< tag::test, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::test, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::test, LC, GridFct > | Zero-order vector-operator \( (c\, \psi) \) |
►CLocalOperator< GridFunctionOperator< tag::test_divtrialvec, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::test_divtrialvec, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::test_divtrialvec, LC, GridFct > | First-order operator \( \langle\psi, c\,\nabla\cdot\Phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::test_gradtrial, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::test_gradtrial, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::test_gradtrial, LC, GridFct > | First-order operator \( \langle\psi, \mathbf{b}\cdot\nabla\phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::test_partialtrial, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::test_partialtrial, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::test_partialtrial, LC, GridFct > | First-order operator \( \langle\psi, c\,\partial_i\phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::test_trial, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::test_trial, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::test_trial, LC, GridFct > | Zero-order operator \( \langle\psi, c\,\phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::test_trialvec, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::test_trialvec, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::test_trialvec, LC, GridFct > | Zero-order operator \( \langle\psi, \mathbf{b}\cdot\Phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::testvec, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::testvec, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::testvec, LC, GridFct > | Zero-order vector-operator \( (\mathbf{b}\cdot\Psi) \) |
►CLocalOperator< GridFunctionOperator< tag::testvec_gradtrial, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::testvec_gradtrial, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::testvec_gradtrial, LC, GridFct > | First-order operator \( \langle\Psi, c\,\nabla\phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::testvec_trial, LC, GridFct >, GridFunctionOperator< tag::test_trialvec, LC, GridFct > ::LocalContext > | |
►CGridFunctionOperatorTransposed< GridFunctionOperator< tag::testvec_trial, LC, GridFct >, GridFunctionOperator< tag::test_trialvec, LC, GridFct > > | |
CGridFunctionOperator< tag::testvec_trial, LC, GridFct > | Zero-order operator \( \langle\Psi, \mathbf{b}\,\phi\rangle \) |
►CLocalOperator< GridFunctionOperator< tag::testvec_trialvec, LC, GridFct >, LC > | |
►CGridFunctionOperatorBase< GridFunctionOperator< tag::testvec_trialvec, LC, GridFct >, LC, GridFct > | |
CGridFunctionOperator< tag::testvec_trialvec, LC, GridFct > | Zero-order operator \( \langle\Psi, c\,\Phi\rangle \), or \( \langle\Psi, A\,\Phi\rangle \) |
CLocalToGlobalBasisAdapter< BasisCache, Geometry > | Convert a simple (scalar) local basis into a global basis |
CLocalView< GB > | The restriction of a finite element basis to a single element |
CMacroGridFactory< GridType > | |
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 |
Cmatrix | |
CMatrixFacade< T, MatrixImpl > | |
►CMatrixFacade< T, Traits::template MatrixImpl > | |
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 |
CNodeDataTransfer< Node, Container, Basis > | |
CNodeIdSet< PB, TP, NodeTag > | |
CNodeIdSet< PreBasis, TreePath > | |
CNodeWrapper< NodeType > | |
►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, Tags > | Implementation of the ObserverInterface |
CObserver< Event, index_t< Is > > | |
►CObserverInterface< event::adapt > | |
►CObserver< event::adapt > | |
CDOFVector< GB, T, TraitsType > | The basic container that stores a base vector and a corresponding basis |
CGlobalBasis< PB > | Global basis defined on a pre-basis |
►CObserverInterface< event::postAdapt > | |
►CObserver< event::postAdapt > | |
CDOFVector< GB, T, TraitsType > | The basic container that stores a base vector and a corresponding basis |
►CObserverInterface< event::preAdapt > | |
►CObserver< event::preAdapt > | |
CDOFVector< GB, T, TraitsType > | The basic container that stores a base vector and a corresponding basis |
►CObserverSequenceImpl< Event, Tags > | |
CBiLinearForm< RB, CB, T, Traits > | |
COperatorLists< GridView, Container > | |
►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 |
Cpcg< Solver > | |
CPeriodicBC< Basis, TP > | Implements a periodic boundary condition |
CPetscMatrix< DofMap > | The basic container that stores a base matrix |
CPetscTraits< Basis > | |
CPetscVector< DofMap > | The basic container that stores a base vector data |
CPlus | Functor that represents A+B |
Cplus_assign | |
►CPolicy | |
CConcurrentCache< Key, Data, Policy, Container > | The class template ConcurrentCache describes an associative static container that allows the concurrent access to the stored data |
CConcurrentCache< ShapeGradients > | |
CConcurrentCache< ShapeValues > | |
CPolynomial | |
CpostAdapt | |
CPow_ | Functor that represents x^p, |
CPowImpl< p, positive > | |
CPowImpl< p, true > | Functor that represents x^p |
CPowType< p > | |
CPowType< 0 > | |
CPowType< 1 > | |
CpreAdapt | |
CPreBasisFactory< MultiIndex > | |
CPreconConfig< Precon > | |
CPreconConfig< Eigen::IncompleteLUT< T, I > > | |
►CPreconditioner | |
CPreconWrapper< P, S > | |
►CPreconditionerInterface< Mat, Vec > | Interface for Preconditioner y = M*x |
CPreconditioner< Mat, Vec, PreconImpl > | Wrapper for using ITL preconditioners in AMDiS |
CSolverPrecon< Mat, Vec > | Use a LinearSolver as Preconditioner |
CPreConvectionDiffusionOperator< PreGridFctA, PreGridFctB, PreGridFctC, PreGridFctF, c > | |
CPreGridFunctionOperator< Tag, PreGridFct, PQF > | |
CPreQuadFactoryFromLocalFunction | |
CPreQuadFactoryFromOrder | |
CPreQuadFactoryFromRule< QuadRule > | |
►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() |
►CStandardProblemIteration | A master problem for a single non coupled problem |
CStandardProblemIterationAdaptor< Model > | StandardProblemIteration when derived from ProblemStat |
►CStandardProblemIterationAdaptor< ProblemStat< Traits > > | |
CProblemStat< Traits > | |
►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 |
►CQuadratureFactory< ctype, dim, LocalFunction > | Base class for quadrature factories for localFunctions |
CQuadFactoryFromLocalFunction< ctype, dim, LocalFunction > | Factory for quadrature rule, that calculates the coefficient order from a localFunction passed to the bind method |
CQuadFactoryFromOrder< ctype, dim, LocalFunction > | Factory for quadrature rule, that takes to order of the localFunction and a quadrature-type |
CQuadFactoryFromRule< ctype, dim, LocalFunction > | Factory for quadrature rule, that is based on an existing rule |
CDistributedCommunication< GlobalId, SizeType >::RemoteIndices | |
Cremove_cvref< T > | Remove cv and ref qualifiers of type T |
CRowNodeData< NodeData, Tree, leafOnly > | |
►CRunnerInterface< Mat, Vec > | Interface for Runner / Worker types used in solver classes |
CDirectRunner< Mat, Vec, Solver > | |
CDirectRunner< Mat, Vec, Solver > | |
CIterativeRunner< Mat, Vec, IterativeSolver > | |
CKrylovRunner< Mat, Vec, ITLSolver > | Wrapper class for different MTL4 itl-solvers. These solvers are parametrized by Matrix and Vector |
CUmfpackRunner< Mat, Vec > | |
CUmfpackRunner< Mat, Vec > | |
►CRunnerInterface< Matrix, Vector > | |
CPetscRunner< Matrix, Vector > | Wrapper around PETSc KSP and PC objects to solve a linear system |
Cscalar | |
CAdaptInfo::ScalContent | Stores adapt infos for a scalar problem or for one component of a vector valued problem |
CSequentialCommunication | Dummy implementation for sequential communication |
CSequentialDofMapping< IS, GI > | Fallback for ParallelDofMapping in case there is only one mpi core |
CSequentialDofMapping< IndexSet, PetscInt > | |
CSequentialISTLCommunication< G, L > | Dummy implementation for ISTL-specific communication when no MPI is found |
CSignum | Functor that represents the signum function |
CSlotSize | |
Csolver | |
CSolverConfig< Solver > | |
CSolverConfig< Eigen::DGMRES< M, P > > | |
CSolverConfig< Eigen::GMRES< M, P > > | |
CSolverInfo | |
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 | |
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 | |
CSeqSolverTraits< Traits > | |
►CTraits | |
CAdaptiveGridFamily< HostGrid >::Traits | |
CTrans | |
CTransposedMatrix< Matrix > | The transposed view onto a matrix |
CTreeContainerStorage< Container > | Vector data-structure with tree-path index access and hierarchic structure given by the Container template type |
CConstraints< MTLSparseMatrix< T > >::Triplet< Value > | |
►Ctrue_type | |
CIsPreGridFunction< AnalyticPreGridFunction< Functor > > | |
CIsPreGridFunction< DerivativePreGridFunction< Expr, Type > > | |
CIsPreGridFunction< FunctorPreGridFunction< Functor, PreGridFcts... > > | |
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 > > > | |
►Cvector | |
Cpath | |
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 |
CFlatMatrix< CoefficientType > | |
CFlatVector< CoefficientType > | |
Cvector | |
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< T, Traits::template VectorImpl > | |
CLinearForm< GB, T, Traits > | The basic container that stores a base vector and a corresponding basis |
►CVectorFacade< T, TraitsType::template VectorImpl > | |
CDOFVector< GB, T, TraitsType > | 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 |
Cbool | |
Cdouble | |
CGlobalIdSet const & | |
CGridFct | |
Cint | |
CSqrt | |
Ctemplate MatrixImpl< T > | |
Ctemplate VectorImpl< T > | |
Ctemplate VectorImpl< T > | |
CTree | |
CViscosityExpr | |