AMDiS  0.3
The Adaptive Multi-Dimensional Simulation Toolbox
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234]
 CAbsMaxOperation that represents max(|A|,|B|)
 CAbsMinOperation that represents min(|A|,|B|)
 CAccessUnified accessor class
 Cadapt
 CAdaptBaseInterface for adaption loops
 CAdaptInfoHolds adapt parameters and infos about the problem
 CAdaptionInterfaceInterface 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
 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... >
 CAssemblerTriple< ElementAssembler, IntersectionAssembler, BoundaryAssembler >
 Cassign
 Cassign
 CAttributeSet< C >
 Caverage
 CBackupRestoreByGridFactory< Grid >
 CBase
 CBase
 Cbjacobi
 CBlockMatrixType< T, class >
 CBlockMatrixType< T, typename T::field_type >
 CBlockVectorType< T, class >
 CBlockVectorType< T, typename T::field_type >
 CBoundaryManagerBase
 CBoundarySubset< IS >Class defining a subset of a domain boundary
 CBoundarySubset< 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
 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 > >
 CComposer< Sqrt, UnaryDot >
 CComposerBuilder< F, Gs >
 CComposerBuilder< Id, F >
 CComposerBuilder< Id, G >
 CComposerBuilder< Id, Negate >
 CComposerBuilder< Id, Pow< p1 *p2 > >
 CComposerBuilder< Id, Zero >
 CComposerBuilder< Minus, Arg< 1 >, Arg< 0 > >
 CComposerBuilder< Minus, G, Id >
 CComposerBuilder< Pow< p >, Multiplies >
 Cconjunction
 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
 CCoordsCompFunctionA functor that evaluates to a component of the global coordinates
 CCoordsFunctionA functor that evaluates to the global coordinates
 CAnalyticPreGridFunction< Function >::Creator
 CCoordsFunction::Creator
 CCoordsCompFunction::Creator
 CDerivativePreGridFunction< Expr, Type >::Creator
 CFunctorPreGridFunction< Functor, PreGridFunctions >::Creator
 CCreator
 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
 CCreatorInterface< Interface >
 CCreatorInterface< ISTLPreconCreatorInterface< Traits > >
 CCreatorInterface< LinearSolverInterface< Mat, Vec > >
 CCreatorInterface< Super >
 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
 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... > >
 CDefaultBasisCreator< Grid, Impl::LagrangePreBasisCreator< degrees... > >
 CDefaultBasisCreator< Grid, Impl::TaylorHoodPreBasisCreator< Grid::dimensionworld, k > >
 CDefaultCommunicationCreator< C >
 CDefaultCreators< BaseClass >
 CDefaultCreators< ISTLPreconCreatorInterface< Traits > >Adds default creators for preconditioners for ISTL
 CDefaultCreators< PreconditionerInterface< Mat, Vec > >
 CDefaultDerivativeTraits
 Cdefaulted
 CDefaultGlobalBasis
 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 > >
 CDefaultSolverCreators< Traits, 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
 CDividesFunctor 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 >
 CEnvironmentEstablishes 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
 Cfalse_type
 CFileWriterCreator< SystemVector >Creator class for filewriters depending on a given type name
 CFileWriterInterfaceInterface class for filewriters
 CFlagEncapsulates 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 >
 Cgmres< Solver >
 Cgrad_test
 Cgrad_trial
 Cgradient
 Cgradtest
 Cgradtest_gradtrial
 Cgradtest_trial
 Cgradtest_trialvec
 CGridDefaultImplementation
 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
 CHierarchicNodeToRangeMapA 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
 CInitfileParserParser for AMDiS initfile format
 CInnerNodeStorage< Value, Container >
 CInterpolateData
 Cintersection_operator< I >
 CInverseOperator
 Cis_arithmetic
 Cis_integral
 Cis_same
 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 >
 CISTLScalarProductCreator< X >Creator to create ScalarProduct objects
 CISTLSolverCreatorInterface< Traits >
 CISTLTraits< Basis >
 CIsValidTreePath< Tree, TreePath, NodeTag >
 CITL_Preconditioner
 CITL_Solver
 Cjacobian
 CLeafNode
 CLeafNodeStorage< Value >
 CLinearSolverInterface< Mat, Vec >Abstract base class for linear solvers
 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
 CLocalOperator< ConvectionDiffusionOperator< LC, GridFctA, GridFctB, GridFctC, GridFctF, conserving >, LC >
 CLocalOperator< Derived, Transposed::LocalContext >
 CLocalOperator< GridFunctionOperator< Tag, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::divtestvec, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::divtestvec_divtrialvec, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::divtestvec_trial, LC, GridFct >, GridFunctionOperator< tag::test_divtrialvec, LC, GridFct > ::LocalContext >
 CLocalOperator< GridFunctionOperator< tag::gradtest, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::gradtest_gradtrial, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::gradtest_trial, LC, GridFct >, GridFunctionOperator< tag::test_gradtrial, LC, GridFct > ::LocalContext >
 CLocalOperator< GridFunctionOperator< tag::gradtest_trialvec, LC, GridFct >, GridFunctionOperator< tag::testvec_gradtrial, LC, GridFct > ::LocalContext >
 CLocalOperator< GridFunctionOperator< tag::partialtest, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::partialtest_partialtrial, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::partialtest_trial, LC, GridFct >, GridFunctionOperator< tag::test_partialtrial, LC, GridFct > ::LocalContext >
 CLocalOperator< GridFunctionOperator< tag::stokes, LC, ViscosityExpr >, LC >
 CLocalOperator< GridFunctionOperator< tag::test, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::test_divtrialvec, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::test_gradtrial, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::test_partialtrial, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::test_trial, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::test_trialvec, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::testvec, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::testvec_gradtrial, LC, GridFct >, LC >
 CLocalOperator< GridFunctionOperator< tag::testvec_trial, LC, GridFct >, GridFunctionOperator< tag::test_trialvec, LC, GridFct > ::LocalContext >
 CLocalOperator< GridFunctionOperator< tag::testvec_trialvec, LC, GridFct >, LC >
 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
 Cmatrix
 CMatrixFacade< T, MatrixImpl >
 CMatrixFacade< T, Traits::template MatrixImpl >
 CMatrixNnzStructureSparsity pattern used to create PETSc matrices
 CMatrixSize
 CMaxOperation that represents max(A,B)
 CMeshCreator< G >A creator class for dune grids
 CMinOperation that represents min(A,B)
 CMinusFunctor that represents A-B
 Cminus_assign
 CMTLSparseMatrix< T >The basic container that stores a base matrix
 CMTLTraits
 CMultiIndex
 CMultipliesFunctor that represents A*B
 Cmultiplies_assign
 CNegateFunctor that represents A-B
 CNodeDataTransfer< Node, Container, Basis >
 CNodeIdSet< PB, TP, NodeTag >
 CNodeIdSet< PreBasis, TreePath >
 CNodeWrapper< NodeType >
 CNodeWrapper< Node >
 Cnone
 CNoOpA functor with no operation
 CNotifier< Event, Events >Mixin for signaling of certain events
 CNotifier< Event >
 CNotifier< event::adapt >
 CNotifier< event::postAdapt >
 CNotifier< event::preAdapt >
 CNotifier< event::preAdapt, event::adapt, event::postAdapt >
 CObserverInterface< Event >
 CObserverInterface< event::adapt >
 CObserverInterface< event::postAdapt >
 CObserverInterface< event::preAdapt >
 CObserverSequenceImpl< Event, Tags >
 COperatorLists< GridView, Container >
 Cpair
 Cpartial
 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
 CPlusFunctor that represents A+B
 Cplus_assign
 CPolicy
 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
 CPreconditionerInterface< Mat, Vec >Interface for Preconditioner y = M*x
 CPreConvectionDiffusionOperator< PreGridFctA, PreGridFctB, PreGridFctC, PreGridFctF, c >
 CPreGridFunctionOperator< Tag, PreGridFct, PQF >
 CPreQuadFactoryFromLocalFunction
 CPreQuadFactoryFromOrder
 CPreQuadFactoryFromRule< QuadRule >
 CProblemIterationInterfaceInterface 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()
 CProblemStatBaseInterface 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
 CProblemTimeInterfaceInterface for time dependent problems. Concrete problems must override all pure virtual methods
 CQuadratureFactory< ctype, dim, LocalFunction >Base class for quadrature factories for localFunctions
 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
 CRunnerInterface< Matrix, Vector >
 Cscalar
 CAdaptInfo::ScalContentStores adapt infos for a scalar problem or for one component of a vector valued problem
 CSequentialCommunicationDummy 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
 CSignumFunctor that represents the signum function
 CSlotSize
 Csolver
 CSolverConfig< Solver >
 CSolverConfig< Eigen::DGMRES< M, P > >
 CSolverConfig< Eigen::GMRES< M, P > >
 CSolverInfo
 CSolverTraits< Mat, VecX, VecY >
 CSparsityPatternA 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
 CTraits
 CTraits
 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
 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
 Cvector
 CVectorBase< Derived >CRTP base class for flat vector backends
 CVectorBase< EigenVector< T > >
 CVectorBase< ISTLBlockVector< T > >
 CVectorBase< MTLVector< T > >
 CVectorFacade< T, VectorImpl >The basic container that stores a base vector and a corresponding basis
 CVectorFacade< T, Traits::template VectorImpl >
 CVectorFacade< T, TraitsType::template VectorImpl >
 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