| NAmesos2 | |
| CSolver | |
| NBelos | |
| CMueLuOp | MueLuOp derives from Belos::OperatorT and administrates a MueLu::Hierarchy. It implements the apply call which represents the effect of the multigrid preconditioner on a given vector. Note, in contrast to Belos::XpetraOp this operator has the multigrid hierarchy |
| CMueLuOpFailure | MueLuOpFailure is thrown when a return value from an MueLu call on an Xpetra::Operator or MueLu::Hierarchy is non-zero |
| CStatusTestGenResSubNorm< Scalar, Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node >, Belos::OperatorT< Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > > | Template specialization of Belos::StatusTestGenResSubNorm class using the Xpetra::MultiVector and Belos::OperatorT MueLu adapter class |
| NMueLu | Namespace for MueLu classes and methods |
| NBoundaryDetection | |
| CPointDirichletFunctor | Functor for marking nodes as Dirichlet |
| CVectorDirichletFunctor | Functor for marking nodes as Dirichlet in a block operator |
| CRowSumFunctor | Functor for marking nodes as Dirichlet based on rowsum |
| CBoundaryFunctor | Functor that serially applies sub-functors to rows |
| CBoundaryFunctor< local_matrix_type, Functor > | |
| NClassicalDropping | |
| CDropFunctor | Classical dropping criterion |
| NCutDrop | |
| CUnscaledComparison | Orders entries of row \(i\) by \(|A_{ij}|^2\) |
| CComparator | |
| CScaledComparison | Orders entries of row \(i\) by \(\frac{|A_{ij}|^2}{|A_{ii}| |A_{jj}|}\) |
| CComparator | |
| CUnscaledDistanceLaplacianComparison | |
| CComparator | |
| CScaledDistanceLaplacianComparison | Orders entries of row \(i\) by \(\frac{|d_{ij}|^2}{|d_{ii}| |d_{jj}|}\) where \(d_ij\) is the distance Laplacian |
| CComparator | |
| CCutDropFunctor | Order each row by a criterion, compare the ratio of values and drop all entries once the ratio is below the threshold |
| NDetails | |
| CDropTol | |
| CLinearSolver | |
| CLinearSolver< Tpetra::MultiVector< Scalar, LO, GO, Node >, Tpetra::Operator< Scalar, LO, GO, Node >, typename Teuchos::ScalarTraits< Scalar >::magnitudeType > | |
| CLinearSolverFactory | Interface for a "factory" that creates MueLu solvers |
| NDistanceLaplacian | |
| CUnweightedDistanceFunctor | Computes the unscaled distance Laplacian |
| CWeightedDistanceFunctor | Computes the weighted distance Laplacian |
| CBlockWeightedDistanceFunctor | Computes the weighted distance Laplacian |
| CScalarMaterialDistanceFunctor | |
| CTensorInversion | |
| CTensorMaterialDistanceFunctor | |
| CDropFunctor | Drops entries the unscaled distance Laplacian |
| CVectorDropFunctor | |
| NExceptions | |
| CBadCast | Exception indicating invalid cast attempted |
| CNotImplemented | Exception throws when you call an unimplemented method of MueLu |
| CRuntimeError | Exception throws to report errors in the internal logical of the program |
| COverflow | Exception throws to report overflows |
| CIncompatible | Exception throws to report incompatible objects (like maps) |
| CDependencyError | Exception throws to report data dependency problems between factories |
| CInvalidArgument | Exception throws to report invalid user entry |
| NMatrixConstruction | |
| CPointwiseCountingFunctor | Functor that executes a sequence of sub-functors on each row for a problem with blockSize == 1 |
| CPointwiseCountingFunctor< local_matrix_type, functor_type > | |
| CPointwiseFillReuseFunctor | Functor that fills the filtered matrix while reusing the graph of the matrix before dropping, blockSize == 1 |
| CPointwiseFillNoReuseFunctor | Functor does not reuse the graph of the matrix for a problem with blockSize == 1 |
| CBlockRowComparison | |
| CComparator | |
| CVectorCountingFunctor | Functor that executes a sequence of sub-functors on each block of rows |
| CVectorCountingFunctor< local_matrix_type, functor_type > | |
| CVectorFillFunctor | |
| CMergeCountFunctor | |
| CMergeFillFunctor | |
| CGraphConstruction | |
| NMisc | |
| CNoOpFunctor | |
| CPointwiseDropBoundaryFunctor | Functor that drops boundary nodes for a blockSize == 1 problem |
| CPointwiseSymmetricDropBoundaryFunctor | Functor that drops boundary nodes for a blockSize == 1 problem |
| CVectorDropBoundaryFunctor | Functor that drops boundary nodes for a blockSize > 1 problem |
| CVectorSymmetricDropBoundaryFunctor | Functor that drops boundary nodes for a blockSize > 1 problem |
| CKeepDiagonalFunctor | Functor that marks diagonal as kept, unless the are already marked as boundary |
| CDropOffRankFunctor | Functor that drops off-rank entries |
| CMarkSingletonFunctor | Functor that marks singletons (all off-diagonal entries in a row are dropped) as boundary |
| CMarkSingletonVectorFunctor | Functor that marks singletons (all off-diagonal entries in a row are dropped) as boundary |
| CBlockDiagonalizeFunctor | Functor that drops all entries that are not on the block diagonal |
| CBlockDiagonalizeVectorFunctor | Functor that drops all entries that are not on the block diagonal |
| CDebugFunctor | Functor that checks that all entries have been marked |
| CSymmetrizeFunctor | Functor that symmetrizes the dropping decisions |
| CAdaptiveSaMLParameterListInterpreter | |
| CAdvSmootherPrototype | |
| CAggregateQualityEstimateFactory | An factory which assigns each aggregate a quality estimate. Originally developed by Napov and Notay in the context of plain aggregation, while this quality estimate does not correspond to a robust convergence guarentee (as it does for plain aggregation), we find empirically that it is a good way of discovering poorly constructed aggregates even in the smoothed aggregation context |
| CAggregates | Container class for aggregation information |
| CAggregationAlgorithmBase | Pure virtual base class for all MueLu aggregation algorithms |
| CAggregationExportFactory | Factory to export aggregation info or visualize aggregates using VTK |
| CAggregationPhase1Algorithm | Algorithm for coarsening a graph with uncoupled aggregation |
| CAggregationPhase2aAlgorithm | Among unaggregated points, see if we can make a reasonable size aggregate out of it |
| CAggregationPhase2bAlgorithm | Add leftovers to existing aggregates |
| CAggregationPhase3Algorithm | Handle leftover nodes. Try to avoid singleton nodes |
| CAggregationStructuredAlgorithm | Algorithm for coarsening a graph with structured aggregation |
| CfillAggregatesFunctor | |
| CcomputeGraphDataConstantFunctor | |
| CcomputeGraphRowPtrFunctor | |
| CcomputeGraphDataLinearFunctor | |
| CAlgebraicPermutationStrategy | Algebraic permutation strategy |
| CAmalgamationFactory | AmalgamationFactory for subblocks of strided map based amalgamation data |
| CAmalgamationInfo | Minimal container class for storing amalgamation information |
| CAmesos2Smoother | Class that encapsulates Amesos2 direct solvers |
| CAmesosSmoother | |
| CAMGXOperator | Adapter for AmgX library from Nvidia |
| CAMGXOperator< double, int, int, Node > | |
| CAppendTrait | |
| CAppendTrait< Kokkos::View< DataType, Pack... >, T > | |
| CBaseClass | Base class for MueLu classes |
| CBelosSmoother | Class that encapsulates Belos smoothers |
| CBlackBoxPFactory | Prolongator factory performing geometric coarsening |
| CNodesIDs | |
| CNodeID | |
| CBlockedCoarseMapFactory | Factory for generating coarse level map. Used by BlockedPFactory |
| CBlockedCoordinatesTransferFactory | Class for transferring coordinates from a finer level to a coarser one for BlockedCrsMatrices. This basically combines the Coordinates generated by each separate block |
| CBlockedDirectSolver | Direct solver for nxn blocked matrices |
| CBlockedGaussSeidelSmoother | Block Gauss-Seidel method for blocked matrices |
| CBlockedJacobiSmoother | Block Jacobi method for blocked matrices |
| CBlockedPFactory | Factory for building blocked, segregated prolongation operators |
| CBlockedRAPFactory | Factory for building coarse matrices |
| CBraessSarazinSmoother | BraessSarazin smoother for 2x2 block matrices |
| CBrickAggregationFactory | |
| Ccompare | |
| CCGSolver | Implements conjugate gradient algorithm for energy-minimization |
| CClassicalMapFactory | Factory for generating F/C-splitting and a coarse level map. Used by ClassicalPFactory |
| CClassicalPFactory | |
| CCloneRepartitionInterface | Helper class which transforms an "Partition" array generated from a block in a blocked operator to a new "Partition" vector for another compatible block in the blocked operator |
| CCoalesceDropFactory | Factory for creating a graph based on a given matrix |
| CCoalesceDropFactory_kokkos | Factory for creating a graph based on a given matrix |
| CCoarseMapFactory | Factory for generating coarse level map. Used by TentativePFactory |
| CCoarseningVisualizationFactory | Factory to visualize coarsening information using prolongation operators |
| CCombineMemoryTraits | |
| CCombineMemoryTraits< Kokkos::MemoryTraits< U >, T > | |
| CCombinePFactory | Prolongator factory that replicates 'Psubblock' matrix to create new prolongator suitable for PDE systems |
| CCompPairs | |
| CConstraint | Constraint space information for the potential prolongator |
| CConstraintFactory | Factory for building the constraint operator |
| CconstraintKernel | |
| CCoordinatesTransferFactory | Class for transferring coordinates from a finer level to a coarser one |
| CCountUnggregatedByColor | |
| CCoupledRBMFactory | Nullspace Factory for coupled acoustic-elastic problems |
| CDefaultProblemStrings | Helper class to initialize DefaultProblemTypeLists_ in class MasterList |
| CDemoFactory | Empty factory for demonstration |
| CDescribable | Base class for MueLu classes |
| CDirectSolver | Class that encapsulates direct solvers. Autoselection of AmesosSmoother or Amesos2Smoother according to the compile time configuration of Trilinos |
| CDisableMultipleCallCheck | An exception safe way to call the method TwoLevelFactoryBase::DisableMultipleCallCheck |
| CDropNegativeEntriesFactory | Application-specific filtering for A. Can be used in context of graph coarsening and aggregation |
| CEminPFactory | Factory for building Energy Minimization prolongators |
| CExpansionFunctor | |
| CFacadeBGS2x2 | |
| CFacadeClassBase | |
| CFacadeClassFactory | |
| CFacadeSimple | |
| CFactory | |
| CFactoryAcceptor | |
| CFactoryBase | Base class for factories (e.g., R, P, and A_coarse) |
| CFactoryFactory | Factory that can generate other factories from |
| CFactoryManager | This class specifies the default factory that should generate some data on a Level if the data does not exist and the generating factory has not been specified |
| CFactoryManagerBase | Class that provides default factories within Needs class |
| CFactoryMonitor | Timer to be used in factories. Similar to Monitor but with additional timers |
| CFakeSmootherPrototype | |
| CFilteredAFactory | Factory for building filtered matrices using filtered graphs |
| CFineLevelInputDataFactory | |
| CFormattingHelper | |
| CGeneralGeometricPFactory | Prolongator factory performing geometric coarsening |
| CGeometricData | |
| CNodesIDs | |
| CNodeID | |
| CGenericRFactory | Factory for building restriction operators using a prolongator factory |
| CGeoInterpFactory | Factory for GMG Q2-Q1-Q2 interpolation |
| CGeometricInterpolationPFactory | |
| CGeometricInterpolationPFactory_kokkos | |
| CcoarseCoordinatesBuilderFunctor | |
| CGlobalLexicographicIndexManager | |
| CGMRESSolver | Implements conjugate gradient algorithm for energy-minimization |
| CGraph | |
| CGraphBase | |
| CHierarchy | Provides methods to build a multigrid hierarchy and apply multigrid cycles |
| CConvData | Data struct for defining stopping criteria of multigrid iteration |
| CHierarchyFactory | |
| CHierarchyManager | |
| CHierarchyUtils | |
| CHybridAggregationFactory | Factory for building aggregates on meshes partly structured and partly unstructured |
| CIfpack2Smoother | Class that encapsulates Ifpack2 smoothers |
| CIfpackSmoother | |
| CImportUtils | MueLu utility class for Import-related routines |
| CIndefBlockedDiagonalSmoother | Cheap Blocked diagonal smoother for indefinite 2x2 block matrices |
| CIndexManager | Container class for mesh layout and indices calculation |
| CIndexManager_kokkos | Container class for mesh layout and indices calculation |
| CInitialBlockNumberFactory | Class for generating an initial LocalOrdinal-type BlockNumber vector, based on an input paraemter for interleaved dofs |
| CInterfaceAggregationAlgorithm | Algorithm for coarsening a graph with uncoupled aggregation. creates aggregates along an interface using specified root nodes |
| CInterfaceAggregationFactory | Factory for building aggregates for Lagrange multipliers in surface-coupled problems |
| CInterfaceMappingTransferFactory | Transfer mapping data for interface aggregation to the coarse level |
| CIntrepidPCoarsenFactory | Factory for building transfer operators based on coarsening in polynomial degree, following the Intrepid basis functions |
| CInverseApproximationFactory | Factory for building the approximate inverse of a matrix |
| CIsorropiaInterface | Interface to Isorropia |
| CIteratorOps | MueLu utility class containing iteration operators |
| CKokkosTuningInterface | |
| CLeftoverAggregationAlgorithm | |
| CLevel | Class that holds all level-specific information |
| CLineDetectionFactory | Factory for building line detection information |
| CLocalAggregationAlgorithm | |
| CLocalLexicographicIndexManager | |
| CLocalOrdinalTransferFactory | Class for transferring a vector of local ordinals from a finer level to a coarser one, where each aggregate has a unique one |
| CLocalPermutationStrategy | Local permutation strategy |
| CLowPrecisionFactory | Factory for converting matrices to half precision operators |
| CLWGraph | Lightweight MueLu representation of a compressed row storage graph |
| CLWGraph_kokkos | Lightweight MueLu representation of a compressed row storage graph |
| CLWGraphBase | |
| CMapTransferFactory | Factory to transfer a map from a fine to a coarse level |
| CMasterList | Static class that holds the complete list of valid MueLu parameters |
| CMatlabSmoother | Class that encapsulates Matlab smoothers |
| CMatlabSmootherFactory | |
| CMatrixAnalysisFactory | This class checks matrix properties of A on current level. This factory can be plugged in everywhere in the factory layout of the MueLu preconditioner. It only needs A as input and pipes it through as output |
| CMatrixFreeTentativeP | Matrix-free tentative restrictor operator |
| CMatrixFreeTentativePFactory | Factory for building the matrix-free tentative restrictor |
| CMaxwell1 | Preconditioner (wrapped as a Xpetra::Operator) for Maxwell's equations in curl-curl form |
| CMaxwell_Utils | Utility functions for Maxwell |
| CMergedBlockedMatrixFactory | |
| CMergedSmoother | |
| CMHDRAPFactory | Factory for building coarse matrices |
| CML2MueLuParameterTranslator | Class that accepts ML-style parameters and builds a MueLu parameter list (easy input deck) |
| CMonitor | Timer to be used in non-factories |
| CMueLuGraphBaseAdapter | |
| CMuemexArg | |
| CMuemexData | |
| CMultiPhys | Preconditioner (wrapped as a Xpetra::Operator) for solving MultiPhysics PDEs |
| CMultiVectorTransferFactory | Class for restricting a MultiVector from a finer to a coarser level |
| CmyTriangle | |
| CmyVec2 | |
| CmyVec3 | |
| CNodePartitionInterface | Partitioning within a node only |
| CNoFactory | NoFactory that is used for data stored in level class for that no generating factory is available/necessary |
| CNotayAggregationFactory | |
| CNullspaceFactory | Factory for generating nullspace |
| CNullspaceFunctor | |
| CNullspacePresmoothFactory | |
| COnePtAggregationAlgorithm | Algorithm for coarsening a graph with uncoupled aggregation. keep special marked nodes as singleton node aggregates over all multigrid levels |
| CoptimalSatisfyConstraintsForScalarPDEsKernel | |
| CParameterListAcceptor | Abstract interface of a class accepting parameter lists |
| CParameterListAcceptorImpl | |
| CParameterListInterpreter | |
| CPatternFactory | Factory for building nonzero patterns for energy minimization |
| CPerfModels | |
| CPerfUtils | |
| CPermutationFactory | Factory generates a row- and column permutation operators P and Q such that P*A*Q^T is a (hopefully) diagonal-dominant matrix. It's meant to be used with PermutingSmoother |
| CPermutingSmoother | This class first calculates row- and column permutation operators and applies a smoother to the permuted linear system |
| CPFactory | Factory that provides an interface for a concrete implementation of a prolongation operator |
| CPgPFactory | Factory for building Petrov-Galerkin Smoothed Aggregation prolongators |
| CPreDropFunctionBaseClass | |
| CPreDropFunctionConstVal | |
| CPreserveDirichletAggregationAlgorithm | Builds one-to-one aggregates for all Dirichlet boundary nodes. For some applications this might be necessary. (default = off) |
| CPRFactory | |
| CPrintMonitor | |
| CProjection | |
| CProjectorSmoother | This class enables the elimination of the nullspace component of the solution through the use of projection |
| CQ2Q1Q2CoarseGridFactory | Factory for GMG Q2-Q1-Q2 interpolation |
| CRAPFactory | Factory for building coarse matrices |
| CRAPShiftFactory | Factory for building coarse grid matrices, when the matrix is of the form K+a*M. Useful when you want to change the shift variable ("a") at every level. Each level must store the stiffness matrix K and mass matrix M separately |
| CRebalanceAcFactory | Factory for building coarse matrices |
| CRebalanceBlockAcFactory | |
| CRebalanceBlockInterpolationFactory | Applies permutation to prolongation operators |
| CRebalanceBlockRestrictionFactory | Applies permutation to restriction operators |
| CRebalanceMapFactory | Factory which rebalances a map on current level using the Importer object generated by the RepartitionFactory |
| CRebalanceTransferFactory | Applies permutation to grid transfer operators |
| CRefMaxwell | Preconditioner (wrapped as a Xpetra::Operator) for Maxwell's equations in curl-curl form |
| CRefMaxwellSmoother | Class that encapsulates Operator smoothers |
| CRegionRFactory | Factory that builds a restriction operator for region multigrid |
| CRegionRFactory_kokkos | Factory that builds a restriction operator for region multigrid |
| CReitzingerPFactory | Factory for building tentative prolongator |
| CReorderBlockAFactory | Factory for building a reordered (nested) block operator |
| CRepartitionBlockDiagonalFactory | Factory which rebalances a map on current level using the Importer object generated by the RepartitionFactory |
| CRepartitionFactory | Factory for building permutation matrix that can be be used to shuffle data (matrices, vectors) among processes |
| CRepartitionHeuristicFactory | Factory for determing the number of partitions for rebalancing |
| CRepartitionInterface | Helper class which transforms an "AmalgamatedPartition" array to an unamalgamated "Partition" |
| CRepartitionUtilities | |
| CReplicatePFactory | Prolongator factory that replicates 'Psubblock' matrix to create new prolongator suitable for PDE systems |
| CRfromP_Or_TransP | Factory for building restriction operators |
| CRigidBodyModeFactory | Nullspace Factory for building rigid body modes |
| CSaPFactory | Factory for building Smoothed Aggregation prolongators |
| CScalarDroppingBase | |
| CScalarDroppingClassical | |
| CScalarDroppingDistanceLaplacian | |
| CScaledNullspaceFactory | Factory for generating a very special nullspace |
| CSchurComplementFactory | Factory for building the Schur Complement for a 2x2 block matrix |
| CSegregatedAFactory | Factory for building a new "segregated" A operator. Here, "segregated" means that the user provides some map(s) (containing a subset of GIDs of the input matrix A) and the factory drops entries depending on the dropping scheme |
| CSemiCoarsenPFactory | Prolongator factory performing semi-coarsening |
| CSemiCoarsenPFactory_kokkos | Prolongator factory performing semi-coarsening |
| CSetFactoryManager | An exception safe way to call the method 'Level::SetFactoryManager()' |
| CShiftedLaplacian | Shifted Laplacian Helmholtz solver |
| CShiftedLaplacianOperator | Wraps an existing MueLu::Hierarchy as a Tpetra::Operator, with an optional two-level correction. Intended to be used with MueLu::ShiftedLaplacian |
| CSimpleSmoother | SIMPLE smoother for 2x2 block matrices |
| CSingleLevelFactoryBase | Base class for factories that use one level (currentLevel) |
| CSingleLevelMatlabFactory | Factory for interacting with Matlab |
| CSmoother | Base class for smoother factories |
| CSmootherBase | Base class for smoothers |
| CSmootherFactory | Generic Smoother Factory for generating the smoothers of the MG hierarchy |
| CSmootherFactoryBase | |
| CSmootherPrototype | Base class for smoother prototypes |
| CSmooVecCoalesceDropFactory | Factory for creating a graph base on a given matrix |
| CSolverBase | Base class for energy-minimization iterative solvers |
| CSteepestDescentSolver | Implements steepest descent algorithm for energy-minimization |
| CStructuredAggregationFactory | Factory for building aggregates on structured grids |
| CStructuredAggregationFactory_kokkos | Factory for building structured aggregates or CrsGraph for interpolation base prolongator |
| CStructuredLineDetectionFactory | Factory building line detection information on structured meshes |
| CSubBlockAFactory | Factory for building a thresholded operator |
| CSubFactoryMonitor | Timer to be used in factories. Similar to SubMonitor but adds a timer level by level |
| CSubMonitor | Timer to be used in non-factories. Similar to Monitor, but doesn't print object description |
| CTekoSmoother | Interface to block smoothers in Teko package |
| CTekoSmoother< double, int, GlobalOrdinal, Node > | |
| CTentativePFactory | Factory for building tentative prolongator |
| CTentativePFactory_kokkos | |
| CThresholdAFilterFactory | Factory for building a thresholded operator |
| CTimeMonitor | Integrates Teuchos::TimeMonitor with MueLu verbosity system |
| CToggleCoordinatesTransferFactory | Class for transferring coordinates from a finer level to a coarser one |
| CTogglePFactory | Prolongator factory which allows switching between two different prolongator strategies |
| CTopRAPFactory | |
| CTopSmootherFactory | |
| CTpetraOperator | Wraps an existing MueLu::Hierarchy as a Tpetra::Operator |
| CTpetraOperatorAsRowMatrix | |
| CTransPFactory | Factory for building restriction operators |
| CTrilinosSmoother | Class that encapsulates external library smoothers |
| CTriplet | |
| CTwoLevelFactoryBase | Base class for factories that use two levels (fineLevel and coarseLevel) |
| CTwoLevelMatlabFactory | Factory for interacting with Matlab |
| CUncoupledAggregationFactory | Factory for building uncoupled aggregates |
| CUncoupledIndexManager | |
| CUnsmooshFactory | Factory for building "unsmooshed" transfer operators from transfer operators associated with a scalar helper problem (built by the VariableDofLaplacianFactory) |
| CUserAggregationFactory | |
| CUserPFactory | |
| CUtilities | MueLu utility class |
| CUtilitiesBase | MueLu utility class |
| CUzawaSmoother | Block triangle Uzawa smoother for 2x2 block matrices |
| CVariableContainer | Class that stores all relevant data for a variable |
| CDataBase | |
| CData | |
| CGetter | |
| CChecker | |
| CGetter< Teuchos::RCP< Xpetra::Operator< Scalar, LocalOrdinal, GlobalOrdinal, Node > > > | |
| CVariableDofLaplacianFactory | Factory for building scalar Laplace operator (that is used as fake operator for variable dof size problems) |
| CVectorDroppingBase | |
| CVectorDroppingClassical | |
| CVectorDroppingDistanceLaplacian | |
| CVerboseObject | Verbose class for MueLu classes |
| CVisualizationHelpers | Base class providing routines to visualize aggregates and coarsening information |
| CXpetraOperator | Wraps an existing MueLu::Hierarchy as a Xpetra::Operator |
| CZeroSubBlockAFactory | Factory for extracting a zero block from a BlockedCrsMatrix |
| CZoltan2Interface | Interface to Zoltan2 library |
| CZoltan2Utilities | |
| CZoltanInterface | Interface to Zoltan library |
| NMueLuTests | |
| CBlackBoxPFactoryTester | |
| CCombinePFactoryTester | |
| CFineLevelInputDataFactoryTester | |
| CGeneralGeometricPFactoryTester | |
| CReplicatePFactoryTester | |
| NTeuchos | |
| CComm | |
| NThyra | |
| CMueLuTpetraQ2Q1PreconditionerFactory | Concrete preconditioner factory subclass based on MueLu |
| CXpetraLinearOp | Concrete Thyra::LinearOpBase subclass for Xpetra::Operator |
| NXpetra | |
| CCrsMatrixUtils | Xpetra utility class for CrsMatrix-related routines |
| NZoltan2 | |
| CInputTraits< MueLu::LWGraph< LocalOrdinal, GlobalOrdinal, Node > > | |
| CAdaptiveSAMLParameterListInterpreter | Class that accepts ML-style parameters and builds a MueLu preconditioner. This interpreter uses the same default values as ML. This allows to compare ML/MueLu results |
| CAlgebraicPermutationStrategy | Class which defines local permutations of matrix columns |
| CBrickAggregationFactory | Aggregation method for generating "brick" aggregates. It also does "hotdogs" and "pancakes." |
| CConstraint | Class which contains the constraint space details |
| CFineLevelInputData | Factory for piping in input data from the finest level into the MueLu data dependency system |
| CLocalPermutationStrategy | Class which defines local permutations of matrix columns which correspond to DOFs of the same node |
| CMergedBlockedMatrix | Factory provides a merged version of a blocked matrix |
| CMergedSmoother | |
| CVectorFillNoReuseFunctor | Functor does not reuse the graph of the matrix for a problem with blockSize>1 |
1.17.0