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