►NAMDiS | Contains all classes needed for solving linear and non linear equation systems |
►NAssigner | |
Cassign | |
Cdivides_assign | |
Cminus_assign | |
Cmultiplies_assign | |
Cplus_assign | |
►NConcepts | |
►NDefinition | |
CCallable | |
CConstantToGridFunction | |
CConstantToGridFunction< std::reference_wrapper< T > > | |
CHasDerivative | |
CHasFunctorOrder | |
CHasGridFunctionTypes | |
CHasLocalFunction | |
CHasLocalFunctionDerivative | |
CHasPartial | |
CInterpolateData | |
CIsPreTreePath | |
CIsPreTreePath< std::integer_sequence< Index, I... > > | |
CIsPreTreePath< std::integral_constant< Index, I > > | |
CIsPreTreePath< std::tuple< Indices... > > | |
CMultiIndex | |
CPolynomial | |
CPreBasisFactory | |
CUpdateData | |
►Nevent | |
Cadapt | |
CpostAdapt | |
CpreAdapt | |
►Nfilesystem | |
Cpath | |
►NOperation | |
CAbsMax | Operation that represents max(|A|,|B|) |
CAbsMin | Operation that represents min(|A|,|B|) |
CArg | |
►CClamp | |
CDClamp | |
CComposer | Composition of Functors |
CComposerBuilder | |
CComposerBuilder< Id, F > | |
CComposerBuilder< Minus, G, Zero > | |
CComposerBuilder< Minus, Zero, G > | |
CComposerBuilder< Minus, Zero, Zero > | |
CComposerBuilder< Multiplies, G, Zero > | |
CComposerBuilder< Multiplies, PowImpl< p, pos >, PowImpl< p, pos > > | |
CComposerBuilder< Multiplies, Zero, G > | |
CComposerBuilder< Multiplies, Zero, Zero > | |
CComposerBuilder< Negate, Minus > | |
CComposerBuilder< Plus, G, Negate > | |
CComposerBuilder< Plus, G, Zero > | |
CComposerBuilder< Plus, Zero, G > | |
CComposerBuilder< Plus, Zero, Zero > | |
CComposerBuilder< PowImpl< p1, pos1 >, PowImpl< p2, pos2 > > | |
CConstant | Functor representing a constant value |
►CCoordsCompFunction | A functor that evaluates to a component of the global coordinates |
CCreator | |
CDerivative | |
►CCoordsFunction | A functor that evaluates to the global coordinates |
CCreator | |
CDerivative | |
CDivides | Functor that represents A/B |
CDot | (Binary-)Functor representing the euclidean dot-product |
CGet | |
CGet_ | |
CId | (Unary-)Functor representing the identity |
CMax | Operation that represents max(A,B) |
CMin | Operation that represents min(A,B) |
CMinus | Functor that represents A-B |
CMultiplies | Functor that represents A*B |
CNegate | Functor that represents A-B |
CPlus | Functor that represents A+B |
CPow_ | Functor that represents x^p, |
CPowImpl | |
CPowImpl< p, false > | |
CPowImpl< p, true > | Functor that represents x^p |
CPowType | |
CPowType< 0 > | |
CPowType< 1 > | |
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 |
►Ntag | |
Cassign | |
Caverage | |
Cbjacobi | |
Cboundary_operator | |
Cdefaulted | |
Cderivative_type | |
Cdivergence | |
Cdivtestvec | |
Cdivtestvec_divtrialvec | |
Cdivtestvec_trial | |
Celement_operator | |
Cgmres | |
Cgrad_test | |
Cgrad_trial | |
Cgradient | |
Cgradtest | |
Cgradtest_gradtrial | |
Cgradtest_trial | |
Cgradtest_trialvec | |
Cintersection_operator | |
Cjacobian | |
Cmatrix | |
Cnone | |
Cpartial | |
Cpartial_test | |
Cpartial_trial | |
Cpartialtest | |
Cpartialtest_partialtrial | |
Cpartialtest_trial | |
Cpcg | |
Cscalar | |
Csolver | |
Cstokes | |
Ctest | |
Ctest_divtrialvec | |
Ctest_gradtrial | |
Ctest_partialtrial | |
Ctest_trial | |
Ctest_trialvec | |
Ctestvec | |
Ctestvec_gradtrial | |
Ctestvec_trial | |
Ctestvec_trialvec | |
Cunknown | |
Cvector | |
►NTraits | |
CIsFlatIndex | |
CIsPreGridFunction | |
CIsPreGridFunction< AnalyticPreGridFunction< Functor > > | |
CIsPreGridFunction< DerivativePreGridFunction< Expr, Type > > | |
CIsPreGridFunction< FunctorPreGridFunction< Functor, PreGridFcts... > > | |
CIsPreGridFunction< Operation::CoordsCompFunction > | |
CIsPreGridFunction< Operation::CoordsFunction > | |
CIsReferenceWrapper | |
CIsReferenceWrapper< std::reference_wrapper< T > > | |
CIsSame | |
CIsSame< T0, Ts... > | |
CIsSame<> | |
CIsSimilar | |
CIsSimilar< Types< A >, Types< B > > | |
CIsSimilar< Types< A0, As... >, Types< B0, Bs... > > | |
CIsSimilar< Types<>, Types<> > | |
CIsValidTreePath | |
CAdaptBase | Interface for adaption loops |
►CAdaptInfo | Holds adapt parameters and infos about the problem |
CScalContent | Stores adapt infos for a scalar problem or for one component of a vector valued problem |
CAdaptInstationary | AdaptInstationary implements the adaptive procedure for time dependent problems (see ProblemInstat). It contains a pointer to a ProblemInstat object |
CAdaptionInterface | Interface for transfer between grid changes |
CAdaptiveGrid | Wrapper class for Dune-grids that allows automatic signalling of events during grid adaptation |
►CAdaptiveGridFamily | |
CTraits | |
CAdaptStationary | Contains all classes needed for space and time adaption |
CAMGCreator | |
►CAMGPrecon | |
CCreator | |
CAMGPreconCreator | A creator for AMGPrecon, reads the smoother type from initfile: |
CAnalyticGridFunction | A Gridfunction that evaluates a function with global coordinates |
CAnalyticLocalFunction | |
CAnalyticLocalFunction< R(D), LC, Function > | |
►CAnalyticPreGridFunction | |
CCreator | |
CAssembler | Implementation of interface AssemblerBase |
CAssemblerInterface | Abstract base-class of a Assembler |
CAssemblerTriple | |
CAttributeSet | |
CBackupRestoreByGridFactory | |
CBackupWriter | |
CBCData | |
Cbicg_solver_type | ITL_Solver <bicg_solver_type> implementation of bi-conjugate gradient method |
Cbicgstab2_type | ITL_Solver <bicgstab2_type> implementation of BiCGStab(l) method with l=2 |
Cbicgstab_ell_type | ITL_Solver <bicgstab_ell_type> implementation of stabilized BiCG(ell) method |
Cbicgstab_type | ITL_Solver <bicgstab_type> implementation of stabilized bi-conjugate gradient method |
CBiLinearForm | |
CBlockMatrixType | |
CBlockMatrixType< T, typename T::field_type > | |
CBlockVectorType | |
CBlockVectorType< T, typename T::field_type > | |
CBoundaryCondition | Interface class for boundary conditions |
CBoundaryManager | Manage boundary ids of boundary segments in a grid |
CBoundaryManagerBase | |
CBoundarySubset | Class defining a subset of a domain boundary |
Ccg_solver_type | ITL_Solver <cg_solver_type> implementation of conjugate gradient method |
Ccgs_solver_type | ITL_Solver <cgs_solver_type> implementation of squared conjugate gradient method |
CCheckNumCols | |
CCheckNumRows | |
CCheckSize | |
CCommunicationCreator | Implementation of a creator pattern for Communication types |
CCommunicationCreator< DistributedCommunication< G, L > > | |
CCommunicationCreator< ISTLCommunication< G, L > > | |
CCompositeNodeCache | |
CConcurrentCache | The class template ConcurrentCache describes an associative static container that allows the concurrent access to the stored data |
CConsecutivePolicy | Store cache in instance |
CConstantGridFunction | Gridfunction returning a constant value |
CConstantLocalFunction | |
CConstantLocalFunction< R(D), LC, T > | LocalFunction of a Gridfunction returning a constant value |
CConstraints | |
CConstraints< BiLinearForm< RB, CB, T, Traits > > | |
CConstraints< EigenSparseMatrix< T, O > > | |
CConstraints< ISTLBCRSMatrix< T, C > > | |
►CConstraints< MTLSparseMatrix< T > > | |
CTriplet | |
CConstraints< PetscMatrix< DofMap > > | |
CContextGeometry | Wrapper class for element and geometry |
CConvectionDiffusionOperator | |
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 | |
CDataTransferFactory | Factory to create DataTransfer objects based on the DataTransferOperation |
CDataTransferInterface | Interface for Containers allowing data transfer between grid changes |
CDataTransferWrapper | |
CDefaultAssemblerTraits | |
CDefaultAttributeSet | |
CDefaultBasisCreator | Generator for a basis and default problem traits |
CDefaultCommunicationCreator | |
CDefaultCreators | |
CDefaultCreators< ISTLPreconCreatorInterface< Traits > > | Adds default creators for preconditioners for ISTL |
CDefaultCreators< ISTLSolverCreatorInterface< Traits > > | |
CDefaultCreators< LinearSolverInterface< Mat, Vec > > | Adds default creators for linear solvers based on Eigen::SparseMatrix |
CDefaultCreators< PreconditionerInterface< Mat, Vec > > | |
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 |
CDefaultSolverCreators | Adds default creators for linear solvers based on Dune::BCRSMatrix |
CDerivativeGridFunction | A Gridfunction that returns the derivative when calling localFunction |
►CDerivativePreGridFunction | |
CCreator | |
CDerivativeTraits | |
CDerivativeTraits< R(D), tag::gradient > | |
CDerivativeTraits< R(D), tag::jacobian > | |
CDiagonalPreconditioner | ITL_Preconditioner implementation of diagonal (jacobi) preconditioner, |
CDirectRunner | |
CDirectSolverCreator | Default creator for direct solvers |
CDirichletBC | Implements a boundary condition of Dirichlet-type |
►CDiscreteFunction | A mutable view on the subspace of a DOFVector, |
CDerivativeLocalFunctionBase | |
CDivergenceLocalFunction | |
CGradientLocalFunction | |
CLocalFunction | |
CPartialLocalFunction | |
►CDiscreteFunction< Coeff const, GB, TreePath > | A Const DiscreteFunction |
CDerivativeLocalFunctionBase | A LocalFunction representing the derivative of the DOFVector on a bound element |
►CDistributedCommunication | |
CIndexSet | |
CRemoteIndices | |
CDOFVector | The basic container that stores a base vector and a corresponding basis |
CEigenSparseMatrix | The basic container that stores a base matrix and a corresponding row/column feSpace |
CEigenTraits | |
CEigenVector | The basic container that stores a base vector and a corresponding basis |
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 |
CFlag | Encapsulates flags which represents simple information. Used e.g. while mesh traversal to specify, which elements should be visited |
CFlatMatrix | Dense matrix with row-wise storage in flat data vector |
CFlatPreBasis | |
CFlatVector | Flat data vector to be used in assembling as element vector |
CFunctorGridFunction | A Gridfunction that applies a functor to the evaluated Gridfunctions |
CFunctorLocalFunction | |
►CFunctorLocalFunction< R(D), Functor, LocalFunctions... > | |
CLocalFunctionWrapper | |
►CFunctorPreGridFunction | |
CCreator | |
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 > > | |
CGlobalIdType | Type of a global used used to represent DOFs uniquely |
Cgmres_type | ITL_Solver <gmres_type> implementation of generalized minimal residual method |
CGmshWriter | The GmshWriter just writes the grid of a given gridView to a gmsh compatible .msh file |
CGridFunctionCreator | |
CGridFunctionCreator< Function, std::enable_if_t< Concepts::CallableDomain< Function > > > | |
CGridFunctionCreator< Value, std::enable_if_t< Concepts::ConstantToGridFunction< Value > > > | |
CGridFunctionMarker | Marker based on an indicator given as grid-function |
CGridFunctionOperator | The base-template for GridFunctionOperators |
CGridFunctionOperator< tag::divtestvec, LC, GridFct > | First-order operator \( \langle\nabla\cdot\Psi, c\rangle \) |
CGridFunctionOperator< tag::divtestvec_divtrialvec, LC, GridFct > | Second-order operator \( \langle\nabla\cdot\Psi, c\,\nabla\cdot\Phi\rangle \) |
CGridFunctionOperator< tag::divtestvec_trial, LC, GridFct > | First-order operator \( \langle\nabla\cdot\Psi, c\,\phi\rangle \) |
CGridFunctionOperator< tag::gradtest, LC, GridFct > | First-order operator \( \langle\nabla\psi, b\rangle \) |
CGridFunctionOperator< tag::gradtest_gradtrial, LC, GridFct > | Second-order operator \( \langle\nabla\psi, c\,\nabla\phi\rangle \), or \( \langle\nabla\psi, A\,\nabla\phi\rangle \) |
CGridFunctionOperator< tag::gradtest_trial, LC, GridFct > | First-order operator \( \langle\nabla\psi, \mathbf{b}\,\phi\rangle \) |
CGridFunctionOperator< tag::gradtest_trialvec, LC, GridFct > | First-order operator \( \langle\nabla\psi, c\,\Phi\rangle \) |
CGridFunctionOperator< tag::partialtest, LC, GridFct > | First-order operator \( \langle\partial_i\psi, c\rangle \) |
CGridFunctionOperator< tag::partialtest_partialtrial, LC, GridFct > | Second-order operator \( \langle\partial_i\psi, c\,\partial_j\phi\rangle \) |
CGridFunctionOperator< tag::partialtest_trial, LC, GridFct > | First-order operator \( \langle\partial_i\psi, c\,\phi\rangle \) |
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 \) |
CGridFunctionOperator< tag::test, LC, GridFct > | Zero-order vector-operator \( (c\, \psi) \) |
CGridFunctionOperator< tag::test_divtrialvec, LC, GridFct > | First-order operator \( \langle\psi, c\,\nabla\cdot\Phi\rangle \) |
CGridFunctionOperator< tag::test_gradtrial, LC, GridFct > | First-order operator \( \langle\psi, \mathbf{b}\cdot\nabla\phi\rangle \) |
CGridFunctionOperator< tag::test_partialtrial, LC, GridFct > | First-order operator \( \langle\psi, c\,\partial_i\phi\rangle \) |
CGridFunctionOperator< tag::test_trial, LC, GridFct > | Zero-order operator \( \langle\psi, c\,\phi\rangle \) |
CGridFunctionOperator< tag::test_trialvec, LC, GridFct > | Zero-order operator \( \langle\psi, \mathbf{b}\cdot\Phi\rangle \) |
CGridFunctionOperator< tag::testvec, LC, GridFct > | Zero-order vector-operator \( (\mathbf{b}\cdot\Psi) \) |
CGridFunctionOperator< tag::testvec_gradtrial, LC, GridFct > | First-order operator \( \langle\Psi, c\,\nabla\phi\rangle \) |
CGridFunctionOperator< tag::testvec_trial, LC, GridFct > | Zero-order operator \( \langle\Psi, \mathbf{b}\,\phi\rangle \) |
CGridFunctionOperator< tag::testvec_trialvec, LC, GridFct > | Zero-order operator \( \langle\Psi, c\,\Phi\rangle \), or \( \langle\Psi, A\,\Phi\rangle \) |
CGridFunctionOperatorBase | The main implementation of an CRTP-base class for operators using a grid-function coefficient to be used in an Assembler |
CGridFunctionOperatorTransposed | The transposed operator, implemented in term of its transposed by calling getElementMatrix with inverted arguments |
CGRMarker | Global refinement |
CHierarchicNodeToRangeMap | A simple node to range map using the nested tree indices |
CICPreconditioner | ITL_Preconditioner implementation of IC (Incomplete Cholesky factorization) preconditioner |
CIdentityPreconditioner | ITL_Preconditioner implementation of identity preconditioner, |
Cidr_s_type | ITL_Solver <idr_s_type> implementation of Induced Dimension Reduction method |
CILUPreconditioner | ITL_Preconditioner implementation of ILU (Incomplete LU factorization) preconditioner |
CIndexMapTuple | |
CIndexMapTuple< std::index_sequence< I... >, Map > | |
CInitfile | |
CInitfileParser | Parser for AMDiS initfile format |
CISTLBCRSMatrix | |
CISTLBlockVector | |
CISTLIterativeSolverCreator | Base solver creator for iterative solvers |
CISTLLinearOperatorCreator | Creator to create Linear Operator objects |
CISTLParallelPreconditionerCreator | Creator to create parallel Preconditioners |
►CISTLPreconCreator | Base class for precon creators, |
CCreator | |
CISTLPreconCreatorInterface | |
CISTLScalarProductCreator | Creator to create ScalarProduct objects |
►CISTLSolver | Implementation of RunnerInterface for ISTL solvers |
CCreator | A creator to be used instead of the constructor |
►CISTLSolverCreator | Base class for solver creators, |
CCreator | |
CISTLSolverCreatorInterface | |
CISTLTraits | |
CIterativeRunner | |
CIterativeSolverCreator | Default solver creator for iterative solvers |
CIterativeSolverCreator< tag::gmres< Solver >, Traits > | Solver creator for iterative GMRes-like solvers |
CIterativeSolverCreator< tag::pcg< Solver >, Traits > | Solver creator for iterative CG-like solvers |
CIterativeSolverWrapper | |
CKrylovRunner | Wrapper class for different MTL4 itl-solvers. These solvers are parametrized by Matrix and Vector |
CLagrangeBasis | ProblemStatTraits for a (composite) basis composed of lagrange bases of different degree |
CLeafNodeCache | Cache of LocalBasis evaluations and jacobians at local points |
CLinearForm | The basic container that stores a base vector and a corresponding basis |
►CLinearSolver | 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 |
CCreator | A creator to be used instead of the constructor |
CLinearSolverInterface | Abstract base class for linear solvers |
CLocalOperator | The main implementation of an operator to be used in a Assembler |
CLocalToGlobalBasisAdapter | Convert a simple (scalar) local basis into a global basis |
CLocalToGlobalBasisAdapterTraits | Traits class for local-to-global basis adaptors |
CLocalView | The restriction of a finite element basis to a single element |
CMacroGridFactory | |
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 | |
CMTLVector | The basic container that stores a base vector data |
CNoDataTransfer | Implementation of DataTransferInterface that does not interpolate, but just resizes the containers to the dimension of the basis |
CNodeDataTransfer | |
CNodeIdSet | |
CNodeWrapper | |
CNoOp | A functor with no operation |
CNotifier | Mixin for signaling of certain events |
CNotifier< Event > | |
CObserver | Implementation of the ObserverInterface |
CObserverInterface | |
COperatorLists | |
CPeriodicBC | Implements a periodic boundary condition |
CPetscMatrix | The basic container that stores a base matrix |
CPetscRunner | Wrapper around PETSc KSP and PC objects to solve a linear system |
CPetscTraits | |
CPetscVector | The basic container that stores a base vector data |
CPowerNodeCache | |
CPreconConfig | |
CPreconConfig< Eigen::IncompleteLUT< T, I > > | |
CPreconCreator | Default precon creator |
CPreconCreator< tag::bjacobi, Traits > | Precon creator for the BJacobi preconditioner |
CPreconCreator< tag::solver, Traits > | Precon creator for the InverseOperator2Preconditioner preconditioner |
►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 |
CPreConvectionDiffusionOperator | |
CPreconWrapper | |
CPreGridFunctionOperator | |
Cpreonly_type | ITL_Solver <preonly_type> implementation of preconditioner as |
CPreQuadFactoryFromLocalFunction | |
CPreQuadFactoryFromOrder | |
CPreQuadFactoryFromRule | |
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 |
CQuadFactoryFromLocalFunction | Factory for quadrature rule, that calculates the coefficient order from a localFunction passed to the bind method |
CQuadFactoryFromOrder | Factory for quadrature rule, that takes to order of the localFunction and a quadrature-type |
CQuadFactoryFromRule | Factory for quadrature rule, that is based on an existing rule |
CQuadratureFactory | Base class for quadrature factories for localFunctions |
Cremove_cvref | Remove cv and ref qualifiers of type T |
CRunnerInterface | Interface for Runner / Worker types used in solver classes |
CSeqSolverTraits | |
CSequentialCommunication | Dummy implementation for sequential communication |
CSequentialDofMapping | Fallback for ParallelDofMapping in case there is only one mpi core |
CSequentialISTLCommunication | Dummy implementation for ISTL-specific communication when no MPI is found |
CSlotSize | |
CSolverConfig | |
CSolverConfig< Eigen::DGMRES< M, P > > | |
CSolverConfig< Eigen::GMRES< M, P > > | |
CSolverInfo | |
►CSolverPrecon | Use a LinearSolver as Preconditioner |
CCreator | A creator to be used instead of the constructor |
CSolverTraits | |
CSparsityPattern | A general sparsity pattern implementation using the full pattern of the basis by adding all local indices |
CStandardProblemIteration | A master problem for a single non coupled problem |
CStandardProblemIterationAdaptor | StandardProblemIteration when derived from ProblemStat |
CStaticLockedPolicy | Stores cache global static, requires locking on write access |
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 |
CTreeContainerStorage | Vector data-structure with tree-path index access and hierarchic structure given by the Container template type |
CTwist | Permutate the dof indices w.r.t. a global entity orientation |
CTypes | A variadic type list |
CUmfpackRunner | |
CUniqueBorderPartition | Determine for each border entity which processor owns it |
CValueCategory | Category of type T, e.g. scalar, vector matrix, specified by a tag |
CValueCategory< std::reference_wrapper< T > > | |
CValueCategory< T, std::enable_if_t< std::is_arithmetic_v< T > > > | |
CVectorBase | CRTP base class for flat vector backends |
CVectorFacade | The basic container that stores a base vector and a corresponding basis |
CVTKSequenceWriter | Class to write pvd-files which contains a list of all collected vtk-files |
CVTKWriter | Adapter for the dune-grid VTKWriter |
CYaspGridBasis | Specialization of LagrangeBasis for Grid type Dune::YaspGrid for a given dimension |
Cand_t | |
CcanCommunicate | |
CGridFactoryInterface | |
CGridType | |
ChasBackupRestoreFacilities | |
ChasEntity | |
ChasEntityIterator | |
ChasSingleGeometryType | |
CisLeafwiseConforming | |
CisLevelwiseConforming | |
CITL_Preconditioner | |
CITL_Solver | |
CthreadSafe | |
CTraits | |
CviewThreadSafe | |