►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 |
NDeprecatedAndMayDisappearAtAnyTime [external] | |
NDetails [external] | |
NEpetra_Import_Util [external] | |
NEpetraExt [external] | |
NescapeXMLfile | |
NExperimental [external] | |
NGenSQP [external] | |
NGLpApp [external] | |
NIfpack2 [external] | |
NMatlab [external] | |
►NMueLu | Namespace for MueLu classes and methods |
►NCoalesceDrop_Kokkos_Details | |
CClassicalDropFunctor | |
CDistanceFunctor | |
CDistanceLaplacianDropFunctor | |
CScalarFunctor | |
CScanFunctor | |
CStage1aVectorFunctor | |
CStage1bcVectorFunctor | |
CStage1dVectorFunctor | |
►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 |
►NExceptions | |
CBadCast | Exception indicating invalid cast attempted |
CDependencyError | Exception throws to report data dependency problems between factories |
CIncompatible | Exception throws to report incompatible objects (like maps) |
CInvalidArgument | Exception throws to report invalid user entry |
CNotImplemented | Exception throws when you call an unimplemented method of MueLu |
COverflow | Exception throws to report overflows |
CRuntimeError | Exception throws to report errors in the internal logical of the program |
NMemUtils | |
NMueLuIntrepid | |
NNotayUtils | |
NPerfDetails | |
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 |
CAggregates_kokkos | |
CAggregates_kokkos< LocalOrdinal, GlobalOrdinal, Kokkos::Compat::KokkosDeviceWrapperNode< DeviceType > > | |
CAggregationAlgorithmBase | Pure virtual base class for all MueLu aggregation algorithms |
CAggregationAlgorithmBase_kokkos | |
CAggregationExportFactory | Factory to export aggregation info or visualize aggregates using VTK |
CAggregationPhase1Algorithm | Algorithm for coarsening a graph with uncoupled aggregation |
CAggregationPhase1Algorithm_kokkos | |
CAggregationPhase2aAlgorithm | Among unaggregated points, see if we can make a reasonable size aggregate out of it |
CAggregationPhase2aAlgorithm_kokkos | |
CAggregationPhase2bAlgorithm | Add leftovers to existing aggregates |
CAggregationPhase2bAlgorithm_kokkos | |
CAggregationPhase3Algorithm | Handle leftover nodes. Try to avoid singleton nodes |
CAggregationPhase3Algorithm_kokkos | |
CAggregationStructuredAlgorithm | Algorithm for coarsening a graph with structured aggregation |
►CAggregationStructuredAlgorithm_kokkos | |
CcomputeGraphDataConstantFunctor | |
CcomputeGraphDataLinearFunctor | |
CcomputeGraphRowPtrFunctor | |
CfillAggregatesFunctor | |
CAlgebraicPermutationStrategy | Algebraic permutation strategy |
CAmalgamationFactory | AmalgamationFactory for subblocks of strided map based amalgamation data |
CAmalgamationFactory_kokkos | AmalgamationFactory_kokkos for subblocks of strided map based amalgamation data |
CAmalgamationInfo | Minimal container class for storing amalgamation information |
CAmalgamationInfo_kokkos | Minimal container class for storing amalgamation information |
CAmesos2Smoother | Class that encapsulates Amesos2 direct solvers |
CAmesos2Smoother< double, int, int, Xpetra::EpetraNode > | |
CAmesosSmoother | Class that encapsulates Amesos direct solvers |
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 |
CBelosSmoother< double, int, int, Xpetra::EpetraNode > | |
►CBlackBoxPFactory | Prolongator factory performing geometric coarsening |
CNodeID | |
CNodesIDs | |
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 |
CCoalesceDropFactory_kokkos< Scalar, LocalOrdinal, GlobalOrdinal, Kokkos::Compat::KokkosDeviceWrapperNode< DeviceType > > | |
CCoarseMapFactory | Factory for generating coarse level map. Used by TentativePFactory |
CCoarseMapFactory_kokkos | |
CCoarseMapFactory_kokkos< Scalar, LocalOrdinal, GlobalOrdinal, Kokkos::Compat::KokkosDeviceWrapperNode< DeviceType > > | |
CCoarseningVisualizationFactory | Factory to visualize coarsening information using prolongation operators |
CCombineMemoryTraits | |
CCombineMemoryTraits< Kokkos::MemoryTraits< U >, T > | |
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 |
CCoordinatesTransferFactory_kokkos | |
CCoordinatesTransferFactory_kokkos< Scalar, LocalOrdinal, GlobalOrdinal, Kokkos::Compat::KokkosDeviceWrapperNode< DeviceType > > | |
CCoupledAggregationCommHelper | Helper class for providing arbitrated communication across processors |
CCoupledAggregationFactory | Factory for coarsening a graph with uncoupled aggregation |
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 |
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 | |
CNodeID | |
CNodesIDs | |
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 | MueLu representation of a compressed row storage graph |
CGraphBase | MueLu representation of a graph |
►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 |
CIfpack2Smoother< double, int, int, Xpetra::EpetraNode > | |
CIfpackSmoother | Class that encapsulates Ifpack smoothers |
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 |
CIsolatedNodeAggregationAlgorithm | Ignores isolated nodes during aggregation. Marks the node to be "aggregated" without adding real aggregates for them |
CIsolatedNodeAggregationAlgorithm_kokkos | |
CIsorropiaInterface | Interface to Isorropia |
CLeftoverAggregationAlgorithm | |
CLevel | Class that holds all level-specific information |
CLineDetectionFactory | Factory for building line detection information |
CLinkedList | |
CLocalAggregationAlgorithm | Algorithm for coarsening a graph with uncoupled aggregation |
CLocalLexicographicIndexManager | |
CLocalLWGraph_kokkos | Lightweight MueLu representation of a compressed row storage graph |
CLocalLWGraph_kokkos< LocalOrdinal, GlobalOrdinal, Kokkos::Compat::KokkosDeviceWrapperNode< DeviceType > > | |
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 |
CLWGraph_kokkos< LocalOrdinal, GlobalOrdinal, Kokkos::Compat::KokkosDeviceWrapperNode< DeviceType > > | |
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 | |
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_kokkos | |
CMatrixFreeTentativeP_kokkos< Scalar, LocalOrdinal, GlobalOrdinal, Kokkos::Compat::KokkosDeviceWrapperNode< DeviceType > > | |
CMatrixFreeTentativePFactory_kokkos | |
CMatrixFreeTentativePFactory_kokkos< Scalar, LocalOrdinal, GlobalOrdinal, Kokkos::Compat::KokkosDeviceWrapperNode< DeviceType > > | |
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) |
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 |
CMonitor | Timer to be used in non-factories |
CMueLu_Node_Struct | |
CMueLu_SuperNode_Struct | |
CMueLuGraphBaseAdapter | |
CMuemexArg | |
CMuemexData | |
CMultiVectorTransferFactory | Class for restricting a MultiVector from a finer to a coarser level |
CMutuallyExclusiveTime | This class wraps a Teuchos::Time and maintains a mutually exclusive property between wrapped timers |
CMutuallyExclusiveTimeMonitor | Similar to TimeMonitor, but uses MutuallyExclusiveTime objects |
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 |
CNullspaceFactory_kokkos | |
CNullspaceFactory_kokkos< Scalar, LocalOrdinal, GlobalOrdinal, Kokkos::Compat::KokkosDeviceWrapperNode< DeviceType > > | |
CNullspaceFunctor | |
CNullspacePresmoothFactory | |
COnePtAggregationAlgorithm | Algorithm for coarsening a graph with uncoupled aggregation. keep special marked nodes as singleton node aggregates over all multigrid levels |
COnePtAggregationAlgorithm_kokkos | |
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) |
CPreserveDirichletAggregationAlgorithm_kokkos | |
CPRFactory | |
CPrintMonitor | |
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" |
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 |
CSaPFactory_kokkos | Factory for building Smoothed Aggregation prolongators |
CSaPFactory_kokkos< Scalar, LocalOrdinal, GlobalOrdinal, Kokkos::Compat::KokkosDeviceWrapperNode< DeviceType > > | |
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 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 |
CSemiCoarsenPFactory | Prolongator factory performing semi-coarsening |
CSemiCoarsenPFactory_kokkos | Prolongator factory performing semi-coarsening |
CSemiCoarsenPFactory_kokkos< Scalar, LocalOrdinal, GlobalOrdinal, Kokkos::Compat::KokkosDeviceWrapperNode< DeviceType > > | |
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 | |
CTentativePFactory_kokkos< Scalar, LocalOrdinal, GlobalOrdinal, Kokkos::Compat::KokkosDeviceWrapperNode< DeviceType > > | |
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 |
CUncoupledAggregationFactory_kokkos | |
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 |
CUtilities< double, int, int, Xpetra::EpetraNode > | |
CUtilities_kokkos | |
CUtilities_kokkos< double, int, int, Node > | |
CUtilitiesBase | |
CUzawaSmoother | Block triangle Uzawa smoother for 2x2 block matrices |
►CVariableContainer | Class that stores all relevant data for a variable |
CData | |
CDataBase | |
CGetter | |
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) |
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 |
CZoltan2Interface< double, int, int, Xpetra::EpetraNode > | |
CZoltanInterface | Interface to Zoltan library |
►NMueLuTests | |
CBlackBoxPFactoryTester | |
CFineLevelInputDataFactoryTester | |
CGeneralGeometricPFactoryTester | |
CReplicatePFactoryTester | |
NStokhos [external] | |
NStratimikos | |
►NTeuchos [external] | |
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 > > | |