| ►NAmesos2 | |
| CSolver | |
| ►NBelos | |
| CMueLuOpFailure | MueLuOpFailure is thrown when a return value from an MueLu call on an Xpetra::Operator or MueLu::Hierarchy is non-zero |
| 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 |
| 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 |
| NEpetra_Import_Util | |
| NEpetraExt | |
| NescapeXMLfile | |
| NGLpApp | |
| NIfpack2 | |
| NMatlab | |
| ►NMueLu | Namespace for MueLu classes and methods |
| ►NDetails | |
| CDropTol | |
| CLinearSolverFactory | Interface for a "factory" that creates MueLu solvers |
| CLinearSolver | |
| CLinearSolver< Tpetra::MultiVector< Scalar, LO, GO, Node >, Tpetra::Operator< Scalar, LO, GO, Node >, typename Teuchos::ScalarTraits< Scalar >::magnitudeType > | |
| ►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 |
| NMemUtils | |
| NMueLuIntrepid | |
| ►CBrickAggregationFactory | |
| Ccompare | |
| CAggregates | Container class for aggregation information |
| CGraph | MueLu representation of a compressed row storage graph |
| CGraphBase | MueLu representation of a graph |
| CMueLu_Node_Struct | |
| CLinkedList | |
| CLWGraph | Lightweight MueLu representation of a compressed row storage graph |
| CMueLuGraphBaseAdapter | |
| CCoupledAggregationCommHelper | Helper class for providing arbitrated communication across processors |
| CCoupledAggregationFactory | Factory for coarsening a graph with uncoupled aggregation |
| CLeftoverAggregationAlgorithm | |
| CMueLu_SuperNode_Struct | |
| CLocalAggregationAlgorithm | Algorithm for coarsening a graph with uncoupled aggregation |
| CHybridAggregationFactory | Factory for building aggregates on meshes partly structured and partly unstructured |
| CAmalgamationFactory | AmalgamationFactory for subblocks of strided map based amalgamation data |
| CAmalgamationInfo | Minimal container class for storing amalgamation information |
| CCoalesceDropFactory | Factory for creating a graph based on a given matrix |
| CPreDropFunctionBaseClass | |
| CPreDropFunctionConstVal | |
| CSmooVecCoalesceDropFactory | Factory for creating a graph base on a given matrix |
| CUnsmooshFactory | Factory for building "unsmooshed" transfer operators from transfer operators associated with a scalar helper problem (built by the VariableDofLaplacianFactory) |
| CVariableDofLaplacianFactory | Factory for building scalar Laplace operator (that is used as fake operator for variable dof size problems) |
| CAggregationAlgorithmBase | Pure virtual base class for all MueLu aggregation algorithms |
| CGlobalLexicographicIndexManager | |
| CLocalLexicographicIndexManager | |
| CAggregationStructuredAlgorithm | Algorithm for coarsening a graph with structured aggregation |
| ►CAggregationStructuredAlgorithm_kokkos | |
| CcomputeGraphDataConstantFunctor | |
| CcomputeGraphDataLinearFunctor | |
| CcomputeGraphRowPtrFunctor | |
| CfillAggregatesFunctor | |
| CIndexManager | Container class for mesh layout and indices calculation |
| CStructuredAggregationFactory | Factory for building aggregates on structured grids |
| CUncoupledIndexManager | |
| 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 |
| CInterfaceAggregationAlgorithm | Algorithm for coarsening a graph with uncoupled aggregation. creates aggregates along an interface using specified root nodes |
| CIsolatedNodeAggregationAlgorithm | Ignores isolated nodes during aggregation. Marks the node to be "aggregated" without adding real aggregates for them |
| COnePtAggregationAlgorithm | Algorithm for coarsening a graph with uncoupled aggregation. keep special marked nodes as singleton node aggregates over all multigrid levels |
| CPreserveDirichletAggregationAlgorithm | Builds one-to-one aggregates for all Dirichlet boundary nodes. For some applications this might be necessary. (default = off) |
| CUncoupledAggregationFactory | Factory for building uncoupled aggregates |
| CUserAggregationFactory | |
| CFacadeBGS2x2 | |
| CFacadeSimple | |
| CFacadeClassBase | |
| CFacadeClassFactory | |
| CAdaptiveSaMLParameterListInterpreter | |
| CFactoryFactory | Factory that can generate other factories from |
| CHierarchyFactory | |
| CHierarchyManager | |
| CML2MueLuParameterTranslator | Class that accepts ML-style parameters and builds a MueLu parameter list (easy input deck) |
| CMLParameterListInterpreter | 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 |
| CParameterListInterpreter | |
| 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 |
| 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 |
| CBlockedRAPFactory | Factory for building coarse matrices |
| CCoordinatesTransferFactory | Class for transferring coordinates from a finer level to a coarser one |
| CDemoFactory | Empty factory for demonstration |
| CDropNegativeEntriesFactory | Application-specific filtering for A. Can be used in context of graph coarsening and aggregation |
| CFilteredAFactory | Factory for building filtered matrices using filtered graphs |
| CFineLevelInputDataFactory | |
| CInitialBlockNumberFactory | Class for generating an initial LocalOrdinal-type BlockNumber vector, based on an input paraemter for interleaved dofs |
| CInterfaceAggregationFactory | Factory for building aggregates for Lagrange multipliers in surface-coupled problems |
| CInterfaceMappingTransferFactory | Transfer mapping data for interface aggregation to the coarse level |
| CLineDetectionFactory | Factory for building line detection information |
| CLocalOrdinalTransferFactory | Class for transferring a vector of local ordinals from a finer level to a coarser one, where each aggregate has a unique one |
| CMapTransferFactory | Factory to transfer a map from a fine to a coarse level |
| CMergedBlockedMatrixFactory | |
| CMultiVectorTransferFactory | Class for restricting a MultiVector from a finer to a coarser level |
| 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 |
| 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 a map (containing a subset of the row gids of the input matrix A) and the factory drops the off-diagonal entries (a,b) and (b,a) in A where "a" denotes a GID entry in the provided map and "b" denotes a GID that is not contained in the provided map |
| CStructuredLineDetectionFactory | Factory building line detection information on structured meshes |
| CThresholdAFilterFactory | Factory for building a thresholded operator |
| CBaseClass | Base class for MueLu classes |
| CDescribable | Base class for MueLu classes |
| CFactory | |
| CFactoryAcceptor | |
| CFactoryBase | Base class for factories (e.g., R, P, and A_coarse) |
| 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 |
| ►CHierarchy | Provides methods to build a multigrid hierarchy and apply multigrid cycles |
| CConvData | Data struct for defining stopping criteria of multigrid iteration |
| CSetFactoryManager | An exception safe way to call the method 'Level::SetFactoryManager()' |
| CHierarchyUtils | |
| CLevel | Class that holds all level-specific information |
| CDefaultProblemStrings | Helper class to initialize DefaultProblemTypeLists_ in class MasterList |
| CMasterList | Static class that holds the complete list of valid MueLu parameters |
| CNoFactory | NoFactory that is used for data stored in level class for that no generating factory is available/necessary |
| CParameterListAcceptor | Abstract interface of a class accepting parameter lists |
| CParameterListAcceptorImpl | |
| CSingleLevelFactoryBase | Base class for factories that use one level (currentLevel) |
| CTopRAPFactory | |
| CTopSmootherFactory | |
| CTwoLevelFactoryBase | Base class for factories that use two levels (fineLevel and coarseLevel) |
| ►CVariableContainer | Class that stores all relevant data for a variable |
| CData | |
| CDataBase | |
| CGetter | |
| CGetter< Teuchos::RCP< Xpetra::Operator< Scalar, LocalOrdinal, GlobalOrdinal, Node > > > | |
| CVerboseObject | Verbose class for MueLu classes |
| 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 |
| CIsorropiaInterface | Interface to Isorropia |
| CNodePartitionInterface | Partitioning within a node only |
| 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 |
| 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 |
| CTriplet | |
| CRepartitionHeuristicFactory | Factory for determing the number of partitions for rebalancing |
| CRepartitionInterface | Helper class which transforms an "AmalgamatedPartition" array to an unamalgamated "Partition" |
| CZoltan2Interface | Interface to Zoltan2 library |
| CZoltan2Interface< double, int, int, Xpetra::EpetraNode > | |
| CZoltanInterface | Interface to Zoltan library |
| CBlockedDirectSolver | Direct solver for nxn blocked matrices |
| CBlockedGaussSeidelSmoother | Block Gauss-Seidel method for blocked matrices |
| CBlockedJacobiSmoother | Block Jacobi method for blocked matrices |
| CBraessSarazinSmoother | BraessSarazin smoother for 2x2 block matrices |
| CIndefBlockedDiagonalSmoother | Cheap Blocked diagonal smoother for indefinite 2x2 block matrices |
| CSimpleSmoother | SIMPLE smoother for 2x2 block matrices |
| CTekoSmoother | Interface to block smoothers in Teko package |
| CTekoSmoother< double, int, GlobalOrdinal, Node > | |
| CUzawaSmoother | Block triangle Uzawa smoother for 2x2 block matrices |
| CAdvSmootherPrototype | |
| CAmesos2Smoother | Class that encapsulates Amesos2 direct solvers |
| CAmesos2Smoother< double, int, int, Xpetra::EpetraNode > | |
| CAmesosSmoother | Class that encapsulates Amesos direct solvers |
| CBelosSmoother | Class that encapsulates Belos smoothers |
| CBelosSmoother< double, int, int, Xpetra::EpetraNode > | |
| CDirectSolver | Class that encapsulates direct solvers. Autoselection of AmesosSmoother or Amesos2Smoother according to the compile time configuration of Trilinos |
| CIfpack2Smoother | Class that encapsulates Ifpack2 smoothers |
| CIfpack2Smoother< double, int, int, Xpetra::EpetraNode > | |
| CIfpackSmoother | Class that encapsulates Ifpack smoothers |
| CMergedSmoother | |
| CPermutingSmoother | This class first calculates row- and column permutation operators and applies a smoother to the permuted linear system |
| CProjectorSmoother | This class enables the elimination of the nullspace component of the solution through the use of projection |
| CSmootherBase | Base class for smoothers |
| CSmootherFactory | Generic Smoother Factory for generating the smoothers of the MG hierarchy |
| CSmootherFactoryBase | |
| CSmootherPrototype | Base class for smoother prototypes |
| CTrilinosSmoother | Class that encapsulates external library smoothers |
| CPFactory | Factory that provides an interface for a concrete implementation of a prolongation operator |
| ►CBlackBoxPFactory | Prolongator factory performing geometric coarsening |
| CNodeID | |
| CNodesIDs | |
| CBlockedCoarseMapFactory | Factory for generating coarse level map. Used by BlockedPFactory |
| CBlockedPFactory | Factory for building blocked, segregated prolongation operators |
| CReorderBlockAFactory | Factory for building a reordered (nested) block operator |
| CSubBlockAFactory | Factory for building a thresholded operator |
| CZeroSubBlockAFactory | Factory for extracting a zero block from a BlockedCrsMatrix |
| CClassicalMapFactory | Factory for generating F/C-splitting and a coarse level map. Used by ClassicalPFactory |
| CClassicalPFactory | |
| CConstraint | Constraint space information for the potential prolongator |
| CConstraintFactory | Factory for building the constraint operator |
| CEminPFactory | Factory for building Energy Minimization prolongators |
| CNullspacePresmoothFactory | |
| CPatternFactory | Factory for building nonzero patterns for energy minimization |
| CCGSolver | Implements conjugate gradient algorithm for energy-minimization |
| CGMRESSolver | Implements conjugate gradient algorithm for energy-minimization |
| CSolverBase | Base class for energy-minimization iterative solvers |
| CSteepestDescentSolver | Implements steepest descent algorithm for energy-minimization |
| ►CGeneralGeometricPFactory | Prolongator factory performing geometric coarsening |
| CGeometricData | |
| CNodeID | |
| CNodesIDs | |
| CGeometricInterpolationPFactory | |
| ►CGeometricInterpolationPFactory_kokkos | |
| CcoarseCoordinatesBuilderFunctor | |
| CGenericRFactory | Factory for building restriction operators using a prolongator factory |
| CTransPFactory | Factory for building restriction operators |
| CGeoInterpFactory | Factory for GMG Q2-Q1-Q2 interpolation |
| CMHDRAPFactory | Factory for building coarse matrices |
| CQ2Q1Q2CoarseGridFactory | Factory for GMG Q2-Q1-Q2 interpolation |
| CIntrepidPCoarsenFactory | Factory for building transfer operators based on coarsening in polynomial degree, following the Intrepid basis functions |
| CPgPFactory | Factory for building Petrov-Galerkin Smoothed Aggregation prolongators |
| CSemiCoarsenPFactory | Prolongator factory performing semi-coarsening |
| CSemiCoarsenPFactory_kokkos | Prolongator factory performing semi-coarsening |
| CSemiCoarsenPFactory_kokkos< Scalar, LocalOrdinal, GlobalOrdinal, Kokkos::Compat::KokkosDeviceWrapperNode< DeviceType > > | |
| CToggleCoordinatesTransferFactory | Class for transferring coordinates from a finer level to a coarser one |
| CTogglePFactory | Prolongator factory which allows switching between two different prolongator strategies |
| CCoarseMapFactory | Factory for generating coarse level map. Used by TentativePFactory |
| CNullspaceFactory | Factory for generating nullspace |
| CReitzingerPFactory | Factory for building tentative prolongator |
| CSaPFactory | Factory for building Smoothed Aggregation prolongators |
| CScaledNullspaceFactory | Factory for generating a very special nullspace |
| CTentativePFactory | Factory for building tentative prolongator |
| CUserPFactory | |
| CAggregationExportFactory | Factory to export aggregation info or visualize aggregates using VTK |
| CAlgebraicPermutationStrategy | Algebraic permutation strategy |
| CAMGXOperator | Adapter for AmgX library from Nvidia |
| CCoarseningVisualizationFactory | Factory to visualize coarsening information using prolongation operators |
| CCoupledRBMFactory | Nullspace Factory for coupled acoustic-elastic problems |
| CFakeSmootherPrototype | |
| CLocalPermutationStrategy | Local permutation strategy |
| CMatlabSmoother | |
| 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 |
| CMaxwell_Utils | Utility functions for Maxwell |
| 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 |
| CPRFactory | |
| CRefMaxwell | Preconditioner (wrapped as a Xpetra::Operator) for Maxwell's equations in curl-curl form |
| CRigidBodyModeFactory | Nullspace Factory for building rigid body modes |
| CSingleLevelMatlabFactory | Factory for interacting with Matlab |
| CSmoother | Base class for smoother factories |
| CTpetraOperator | Wraps an existing MueLu::Hierarchy as a Tpetra::Operator |
| CTwoLevelMatlabFactory | Factory for interacting with Matlab |
| CUtilities | MueLu utility class |
| CUtilitiesBase | |
| CVisualizationHelpers | Base class providing routines to visualize aggregates and coarsening information |
| CCompPairs | |
| CDisableMultipleCallCheck | An exception safe way to call the method TwoLevelFactoryBase::DisableMultipleCallCheck |
| CFormattingHelper | |
| CPrintMonitor | |
| CMonitor | Timer to be used in non-factories |
| CSubMonitor | Timer to be used in non-factories. Similar to Monitor, but doesn't print object description |
| CFactoryMonitor | Timer to be used in factories. Similar to Monitor but with additional timers |
| CSubFactoryMonitor | Timer to be used in factories. Similar to SubMonitor but adds a timer level by level |
| CMutuallyExclusiveTime | This class wraps a Teuchos::Time and maintains a mutually exclusive property between wrapped timers |
| CTimeMonitor | Integrates Teuchos::TimeMonitor with MueLu verbosity system |
| CMutuallyExclusiveTimeMonitor | Similar to TimeMonitor, but uses MutuallyExclusiveTime objects |
| CUtilities< double, int, int, Xpetra::EpetraNode > | |
| CmyTriangle | |
| CmyVec3 | |
| CmyVec2 | |
| CAMGXOperator< double, int, int, Node > | |
| 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 |
| CMaxwell1 | Preconditioner (wrapped as a Xpetra::Operator) for Maxwell's equations in curl-curl form |
| CXpetraOperator | Wraps an existing MueLu::Hierarchy as a Xpetra::Operator |
| CMuemexArg | |
| CMuemexData | |
| ►NMueLuTests | |
| CFineLevelInputDataFactoryTester | |
| CBlackBoxPFactoryTester | |
| CGeneralGeometricPFactoryTester | |
| NStratimikos | |
| ►NTeuchos | |
| CComm | |
| ►NThyra | |
| CMueLuTpetraQ2Q1PreconditionerFactory | Concrete preconditioner factory subclass based on MueLu |
| CXpetraLinearOp | Concrete Thyra::LinearOpBase subclass for Xpetra::Operator |
| ►NZoltan2 | |
| CInputTraits< MueLu::GraphBase< LocalOrdinal, GlobalOrdinal, Node > > | |
1.9.1