MueLu Version of the Day
Loading...
Searching...
No Matches
MueLu_UseShortNamesScalar.hpp
Go to the documentation of this file.
1// @HEADER
2// *****************************************************************************
3// MueLu: A package for multigrid based preconditioning
4//
5// Copyright 2012 NTESS and the MueLu contributors.
6// SPDX-License-Identifier: BSD-3-Clause
7// *****************************************************************************
8// @HEADER
9
10// New definition of types using the types Scalar, LocalOrdinal, GlobalOrdinal, Node of the current context.
11
12#include <Xpetra_UseShortNamesScalar.hpp>
13
14#ifdef MUELU_ADAPTIVESAMLPARAMETERLISTINTERPRETER_SHORT
15using AdaptiveSaMLParameterListInterpreter [[maybe_unused]] = MueLu::AdaptiveSaMLParameterListInterpreter<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
16#endif
17#ifdef MUELU_AGGREGATIONEXPORTFACTORY_SHORT
18using AggregationExportFactory [[maybe_unused]] = MueLu::AggregationExportFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
19#endif
20#ifdef MUELU_AGGREGATEQUALITYESTIMATEFACTORY_SHORT
21using AggregateQualityEstimateFactory [[maybe_unused]] = MueLu::AggregateQualityEstimateFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
22#endif
23#ifdef MUELU_AMALGAMATIONFACTORY_SHORT
24using AmalgamationFactory [[maybe_unused]] = MueLu::AmalgamationFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
25#endif
26#ifdef MUELU_AMESOS2SMOOTHER_SHORT
27using Amesos2Smoother [[maybe_unused]] = MueLu::Amesos2Smoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
28#endif
29#ifdef MUELU_AMGXOPERATOR_SHORT
30using AMGXOperator [[maybe_unused]] = MueLu::AMGXOperator<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
31#endif
32#ifdef MUELU_ALGEBRAICPERMUTATIONSTRATEGY_SHORT
33using AlgebraicPermutationStrategy [[maybe_unused]] = MueLu::AlgebraicPermutationStrategy<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
34#endif
35#ifdef MUELU_BELOSSMOOTHER_SHORT
36using BelosSmoother [[maybe_unused]] = MueLu::BelosSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
37#endif
38#ifdef MUELU_BLACKBOXPFACTORY_SHORT
39using BlackBoxPFactory [[maybe_unused]] = MueLu::BlackBoxPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
40#endif
41#ifdef MUELU_BLOCKEDCOARSEMAPFACTORY_SHORT
42using BlockedCoarseMapFactory [[maybe_unused]] = MueLu::BlockedCoarseMapFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
43#endif
44#ifdef MUELU_BLOCKEDCOORDINATESTRANSFERFACTORY_SHORT
45using BlockedCoordinatesTransferFactory [[maybe_unused]] = MueLu::BlockedCoordinatesTransferFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
46#endif
47#ifdef MUELU_BLOCKEDDIRECTSOLVER_SHORT
48using BlockedDirectSolver [[maybe_unused]] = MueLu::BlockedDirectSolver<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
49#endif
50#ifdef MUELU_BLOCKEDGAUSSSEIDELSMOOTHER_SHORT
51using BlockedGaussSeidelSmoother [[maybe_unused]] = MueLu::BlockedGaussSeidelSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
52#endif
53#ifdef MUELU_BLOCKEDJACOBISMOOTHER_SHORT
54using BlockedJacobiSmoother [[maybe_unused]] = MueLu::BlockedJacobiSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
55#endif
56#ifdef MUELU_BLOCKEDPFACTORY_SHORT
57using BlockedPFactory [[maybe_unused]] = MueLu::BlockedPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
58#endif
59#ifdef MUELU_BLOCKEDRAPFACTORY_SHORT
60using BlockedRAPFactory [[maybe_unused]] = MueLu::BlockedRAPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
61#endif
62#ifdef MUELU_BRICKAGGREGATIONFACTORY_SHORT
63using BrickAggregationFactory [[maybe_unused]] = MueLu::BrickAggregationFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
64#endif
65#ifdef MUELU_BRAESSSARAZINSMOOTHER_SHORT
66using BraessSarazinSmoother [[maybe_unused]] = MueLu::BraessSarazinSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
67#endif
68#ifdef MUELU_CGSOLVER_SHORT
69using CGSolver [[maybe_unused]] = MueLu::CGSolver<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
70#endif
71#ifdef MUELU_CLASSICALMAPFACTORY_SHORT
72using ClassicalMapFactory [[maybe_unused]] = MueLu::ClassicalMapFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
73#endif
74#ifdef MUELU_CLASSICALPFACTORY_SHORT
75using ClassicalPFactory [[maybe_unused]] = MueLu::ClassicalPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
76#endif
77#ifdef MUELU_CLONEREPARTITIONINTERFACE_SHORT
78using CloneRepartitionInterface [[maybe_unused]] = MueLu::CloneRepartitionInterface<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
79#endif
80#ifdef MUELU_COALESCEDROPFACTORY_SHORT
81using CoalesceDropFactory [[maybe_unused]] = MueLu::CoalesceDropFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
82#endif
83#ifdef MUELU_COALESCEDROPFACTORY_KOKKOS_SHORT
84using CoalesceDropFactory_kokkos [[maybe_unused]] = MueLu::CoalesceDropFactory_kokkos<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
85#endif
86#ifdef MUELU_COARSEMAPFACTORY_SHORT
87using CoarseMapFactory [[maybe_unused]] = MueLu::CoarseMapFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
88#endif
89#ifdef MUELU_COARSENINGVISUALIZATIONFACTORY_SHORT
90using CoarseningVisualizationFactory [[maybe_unused]] = MueLu::CoarseningVisualizationFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
91#endif
92#ifdef MUELU_COMBINEPFACTORY_SHORT
93using CombinePFactory [[maybe_unused]] = MueLu::CombinePFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
94#endif
95#ifdef MUELU_CONSTRAINT_SHORT
96using Constraint [[maybe_unused]] = MueLu::Constraint<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
97#endif
98#ifdef MUELU_CONSTRAINTFACTORY_SHORT
99using ConstraintFactory [[maybe_unused]] = MueLu::ConstraintFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
100#endif
101#ifdef MUELU_COORDINATESTRANSFERFACTORY_SHORT
102using CoordinatesTransferFactory [[maybe_unused]] = MueLu::CoordinatesTransferFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
103#endif
104#ifdef MUELU_COUPLEDRBMFACTORY_SHORT
105using CoupledRBMFactory [[maybe_unused]] = MueLu::CoupledRBMFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
106#endif
107#ifdef MUELU_DEMOFACTORY_SHORT
108using DemoFactory [[maybe_unused]] = MueLu::DemoFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
109#endif
110#ifdef MUELU_DIRECTSOLVER_SHORT
111using DirectSolver [[maybe_unused]] = MueLu::DirectSolver<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
112#endif
113#ifdef MUELU_DROPNEGATIVEENTRIESFACTORY_SHORT
114using DropNegativeEntriesFactory [[maybe_unused]] = MueLu::DropNegativeEntriesFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
115#endif
116#ifdef MUELU_EMINPFACTORY_SHORT
117using EminPFactory [[maybe_unused]] = MueLu::EminPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
118#endif
119#ifdef MUELU_FACADEBGS2X2_SHORT
120using FacadeBGS2x2 [[maybe_unused]] = MueLu::FacadeBGS2x2<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
121#endif
122#ifdef MUELU_FACADECLASSBASE_SHORT
123using FacadeClassBase [[maybe_unused]] = MueLu::FacadeClassBase<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
124#endif
125#ifdef MUELU_FACADECLASSFACTORY_SHORT
126using FacadeClassFactory [[maybe_unused]] = MueLu::FacadeClassFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
127#endif
128#ifdef MUELU_FACADESIMPLE_SHORT
129using FacadeSimple [[maybe_unused]] = MueLu::FacadeSimple<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
130#endif
131#ifdef MUELU_FACTORYFACTORY_SHORT
132using FactoryFactory [[maybe_unused]] = MueLu::FactoryFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
133#endif
134#ifdef MUELU_FACTORYMANAGER_SHORT
135using FactoryManager [[maybe_unused]] = MueLu::FactoryManager<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
136#endif
137#ifdef MUELU_FAKESMOOTHERPROTOTYPE_SHORT
138using FakeSmootherPrototype [[maybe_unused]] = MueLu::FakeSmootherPrototype<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
139#endif
140#ifdef MUELU_FILTEREDAFACTORY_SHORT
141using FilteredAFactory [[maybe_unused]] = MueLu::FilteredAFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
142#endif
143#ifdef MUELU_FINELEVELINPUTDATAFACTORY_SHORT
144using FineLevelInputDataFactory [[maybe_unused]] = MueLu::FineLevelInputDataFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
145#endif
146#ifdef MUELU_GENERALGEOMETRICPFACTORY_SHORT
147using GeneralGeometricPFactory [[maybe_unused]] = MueLu::GeneralGeometricPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
148#endif
149#ifdef MUELU_GENERICRFACTORY_SHORT
150using GenericRFactory [[maybe_unused]] = MueLu::GenericRFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
151#endif
152#ifdef MUELU_GEOMETRICINTERPOLATIONPFACTORY_SHORT
153using GeometricInterpolationPFactory [[maybe_unused]] = MueLu::GeometricInterpolationPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
154#endif
155#ifdef MUELU_GEOMETRICINTERPOLATIONPFACTORY_KOKKOS_SHORT
156using GeometricInterpolationPFactory_kokkos [[maybe_unused]] = MueLu::GeometricInterpolationPFactory_kokkos<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
157#endif
158#ifdef MUELU_GMRESSOLVER_SHORT
159using GMRESSolver [[maybe_unused]] = MueLu::GMRESSolver<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
160#endif
161#ifdef MUELU_HIERARCHY_SHORT
162using Hierarchy [[maybe_unused]] = MueLu::Hierarchy<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
163#endif
164#ifdef MUELU_HIERARCHYMANAGER_SHORT
165using HierarchyManager [[maybe_unused]] = MueLu::HierarchyManager<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
166#endif
167#ifdef MUELU_HIERARCHYFACTORY_SHORT
168using HierarchyFactory [[maybe_unused]] = MueLu::HierarchyFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
169#endif
170#ifdef MUELU_HIERARCHYUTILS_SHORT
171using HierarchyUtils [[maybe_unused]] = MueLu::HierarchyUtils<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
172#endif
173#ifdef MUELU_INTERFACEAGGREGATIONFACTORY_SHORT
174using InterfaceAggregationFactory [[maybe_unused]] = MueLu::InterfaceAggregationFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
175#endif
176#ifdef MUELU_IFPACK2SMOOTHER_SHORT
177using Ifpack2Smoother [[maybe_unused]] = MueLu::Ifpack2Smoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
178#endif
179#ifdef MUELU_INDEFBLOCKEDDIAGONALSMOOTHER_SHORT
180using IndefBlockedDiagonalSmoother [[maybe_unused]] = MueLu::IndefBlockedDiagonalSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
181#endif
182#ifdef MUELU_INITIALBLOCKNUMBERFACTORY_SHORT
183using InitialBlockNumberFactory [[maybe_unused]] = MueLu::InitialBlockNumberFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
184#endif
185#ifdef MUELU_INTREPIDPCOARSENFACTORY_SHORT
186using IntrepidPCoarsenFactory [[maybe_unused]] = MueLu::IntrepidPCoarsenFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
187#endif
188#ifdef MUELU_INVERSEAPPROXIMATIONFACTORY_SHORT
189using InverseApproximationFactory [[maybe_unused]] = MueLu::InverseApproximationFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
190#endif
191#ifdef MUELU_LINEDETECTIONFACTORY_SHORT
192using LineDetectionFactory [[maybe_unused]] = MueLu::LineDetectionFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
193#endif
194#ifdef MUELU_LOCALPERMUTATIONSTRATEGY_SHORT
195using LocalPermutationStrategy [[maybe_unused]] = MueLu::LocalPermutationStrategy<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
196#endif
197#ifdef MUELU_LOWPRECISIONFACTORY_SHORT
198using LowPrecisionFactory [[maybe_unused]] = MueLu::LowPrecisionFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
199#endif
200#ifdef MUELU_MAPTRANSFERFACTORY_SHORT
201using MapTransferFactory [[maybe_unused]] = MueLu::MapTransferFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
202#endif
203#ifdef MUELU_MATRIXANALYSISFACTORY_SHORT
204using MatrixAnalysisFactory [[maybe_unused]] = MueLu::MatrixAnalysisFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
205#endif
206#ifdef MUELU_MERGEDBLOCKEDMATRIXFACTORY_SHORT
207using MergedBlockedMatrixFactory [[maybe_unused]] = MueLu::MergedBlockedMatrixFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
208#endif
209#ifdef MUELU_MERGEDSMOOTHER_SHORT
210using MergedSmoother [[maybe_unused]] = MueLu::MergedSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
211#endif
212#ifdef MUELU_MULTIVECTORTRANSFERFACTORY_SHORT
213using MultiVectorTransferFactory [[maybe_unused]] = MueLu::MultiVectorTransferFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
214#endif
215#ifdef MUELU_NOTAYAGGREGATIONFACTORY_SHORT
216using NotayAggregationFactory [[maybe_unused]] = MueLu::NotayAggregationFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
217#endif
218#ifdef MUELU_NULLSPACEFACTORY_SHORT
219using NullspaceFactory [[maybe_unused]] = MueLu::NullspaceFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
220#endif
221#ifdef MUELU_NULLSPACEPRESMOOTHFACTORY_SHORT
222using NullspacePresmoothFactory [[maybe_unused]] = MueLu::NullspacePresmoothFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
223#endif
224#ifdef MUELU_PARAMETERLISTINTERPRETER_SHORT
225using ParameterListInterpreter [[maybe_unused]] = MueLu::ParameterListInterpreter<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
226#endif
227#ifdef MUELU_PATTERNFACTORY_SHORT
228using PatternFactory [[maybe_unused]] = MueLu::PatternFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
229#endif
230#ifdef MUELU_PERFUTILS_SHORT
231using PerfUtils [[maybe_unused]] = MueLu::PerfUtils<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
232#endif
233#ifdef MUELU_PERFMODELS_SHORT
234using PerfModels [[maybe_unused]] = MueLu::PerfModels<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
235#endif
236#ifdef MUELU_PERMUTATIONFACTORY_SHORT
237using PermutationFactory [[maybe_unused]] = MueLu::PermutationFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
238#endif
239#ifdef MUELU_PERMUTINGSMOOTHER_SHORT
240using PermutingSmoother [[maybe_unused]] = MueLu::PermutingSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
241#endif
242#ifdef MUELU_PGPFACTORY_SHORT
243using PgPFactory [[maybe_unused]] = MueLu::PgPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
244#endif
245#ifdef MUELU_PREDROPFUNCTIONBASECLASS_SHORT
246using PreDropFunctionBaseClass [[maybe_unused]] = MueLu::PreDropFunctionBaseClass<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
247#endif
248#ifdef MUELU_PREDROPFUNCTIONCONSTVAL_SHORT
249using PreDropFunctionConstVal [[maybe_unused]] = MueLu::PreDropFunctionConstVal<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
250#endif
251#ifdef MUELU_PROJECTORSMOOTHER_SHORT
252using ProjectorSmoother [[maybe_unused]] = MueLu::ProjectorSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
253#endif
254#ifdef MUELU_RAPFACTORY_SHORT
255using RAPFactory [[maybe_unused]] = MueLu::RAPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
256#endif
257#ifdef MUELU_RAPSHIFTFACTORY_SHORT
258using RAPShiftFactory [[maybe_unused]] = MueLu::RAPShiftFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
259#endif
260#ifdef MUELU_REBALANCEACFACTORY_SHORT
261using RebalanceAcFactory [[maybe_unused]] = MueLu::RebalanceAcFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
262#endif
263#ifdef MUELU_REBALANCEBLOCKACFACTORY_SHORT
264using RebalanceBlockAcFactory [[maybe_unused]] = MueLu::RebalanceBlockAcFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
265#endif
266#ifdef MUELU_REBALANCEBLOCKINTERPOLATIONFACTORY_SHORT
267using RebalanceBlockInterpolationFactory [[maybe_unused]] = MueLu::RebalanceBlockInterpolationFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
268#endif
269#ifdef MUELU_REBALANCEBLOCKRESTRICTIONFACTORY_SHORT
270using RebalanceBlockRestrictionFactory [[maybe_unused]] = MueLu::RebalanceBlockRestrictionFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
271#endif
272#ifdef MUELU_REBALANCETRANSFERFACTORY_SHORT
273using RebalanceTransferFactory [[maybe_unused]] = MueLu::RebalanceTransferFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
274#endif
275#ifdef MUELU_REFMAXWELLSMOOTHER_SHORT
276using RefMaxwellSmoother [[maybe_unused]] = MueLu::RefMaxwellSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
277#endif
278#ifdef MUELU_REGIONRFACTORY_SHORT
279using RegionRFactory [[maybe_unused]] = MueLu::RegionRFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
280#endif
281#ifdef MUELU_REGIONRFACTORY_KOKKOS_SHORT
282using RegionRFactory_kokkos [[maybe_unused]] = MueLu::RegionRFactory_kokkos<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
283#endif
284#ifdef MUELU_REITZINGERPFACTORY_SHORT
285using ReitzingerPFactory [[maybe_unused]] = MueLu::ReitzingerPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
286#endif
287#ifdef MUELU_REORDERBLOCKAFACTORY_SHORT
288using ReorderBlockAFactory [[maybe_unused]] = MueLu::ReorderBlockAFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
289#endif
290#ifdef MUELU_REPARTITIONFACTORY_SHORT
291using RepartitionFactory [[maybe_unused]] = MueLu::RepartitionFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
292#endif
293#ifdef MUELU_REPARTITIONBLOCKDIAGONALFACTORY_SHORT
294using RepartitionBlockDiagonalFactory [[maybe_unused]] = MueLu::RepartitionBlockDiagonalFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
295#endif
296#ifdef MUELU_REPARTITIONHEURISTICFACTORY_SHORT
297using RepartitionHeuristicFactory [[maybe_unused]] = MueLu::RepartitionHeuristicFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
298#endif
299#ifdef MUELU_REPLICATEPFACTORY_SHORT
300using ReplicatePFactory [[maybe_unused]] = MueLu::ReplicatePFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
301#endif
302#ifdef MUELU_RIGIDBODYMODEFACTORY_SHORT
303using RigidBodyModeFactory [[maybe_unused]] = MueLu::RigidBodyModeFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
304#endif
305#ifdef MUELU_SAPFACTORY_SHORT
306using SaPFactory [[maybe_unused]] = MueLu::SaPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
307#endif
308#ifdef MUELU_SAPFACTORY_KOKKOS_SHORT
309using SaPFactory_kokkos [[maybe_unused]] = MueLu::SaPFactory_kokkos<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
310#endif
311#ifdef MUELU_SCALEDNULLSPACEFACTORY_SHORT
312using ScaledNullspaceFactory [[maybe_unused]] = MueLu::ScaledNullspaceFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
313#endif
314#ifdef MUELU_SCHURCOMPLEMENTFACTORY_SHORT
315using SchurComplementFactory [[maybe_unused]] = MueLu::SchurComplementFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
316#endif
317#ifdef MUELU_SEGREGATEDAFACTORY_SHORT
318using SegregatedAFactory [[maybe_unused]] = MueLu::SegregatedAFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
319#endif
320#ifdef MUELU_SHIFTEDLAPLACIAN_SHORT
321using ShiftedLaplacian [[maybe_unused]] = MueLu::ShiftedLaplacian<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
322#endif
323#ifdef MUELU_SHIFTEDLAPLACIANOPERATOR_SHORT
324using ShiftedLaplacianOperator [[maybe_unused]] = MueLu::ShiftedLaplacianOperator<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
325#endif
326#ifdef MUELU_SIMPLESMOOTHER_SHORT
327using SimpleSmoother [[maybe_unused]] = MueLu::SimpleSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
328#endif
329#ifdef MUELU_SMOOTHER_SHORT
330using Smoother [[maybe_unused]] = MueLu::Smoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
331#endif
332#ifdef MUELU_SMOOTHERBASE_SHORT
333using SmootherBase [[maybe_unused]] = MueLu::SmootherBase<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
334#endif
335#ifdef MUELU_SMOOTHERFACTORY_SHORT
336using SmootherFactory [[maybe_unused]] = MueLu::SmootherFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
337#endif
338#ifdef MUELU_SMOOTHERPROTOTYPE_SHORT
339using SmootherPrototype [[maybe_unused]] = MueLu::SmootherPrototype<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
340#endif
341#ifdef MUELU_SMOOVECCOALESCEDROPFACTORY_SHORT
342using SmooVecCoalesceDropFactory [[maybe_unused]] = MueLu::SmooVecCoalesceDropFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
343#endif
344#ifdef MUELU_SOLVERBASE_SHORT
345using SolverBase [[maybe_unused]] = MueLu::SolverBase<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
346#endif
347#ifdef MUELU_STEEPESTDESCENTSOLVER_SHORT
348using SteepestDescentSolver [[maybe_unused]] = MueLu::SteepestDescentSolver<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
349#endif
350#ifdef MUELU_STRATIMIKOSSMOOTHER_SHORT
351using StratimikosSmoother [[maybe_unused]] = MueLu::StratimikosSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
352#endif
353#ifdef MUELU_STRUCTUREDAGGREGATIONFACTORY_SHORT
354using StructuredAggregationFactory [[maybe_unused]] = MueLu::StructuredAggregationFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
355#endif
356#ifdef MUELU_STRUCTUREDLINEDETECTIONFACTORY_SHORT
357using StructuredLineDetectionFactory [[maybe_unused]] = MueLu::StructuredLineDetectionFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
358#endif
359#ifdef MUELU_SUBBLOCKAFACTORY_SHORT
360using SubBlockAFactory [[maybe_unused]] = MueLu::SubBlockAFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
361#endif
362#ifdef MUELU_TEKOSMOOTHER_SHORT
363using TekoSmoother [[maybe_unused]] = MueLu::TekoSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
364#endif
365#ifdef MUELU_TENTATIVEPFACTORY_SHORT
366using TentativePFactory [[maybe_unused]] = MueLu::TentativePFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
367#endif
368#ifdef MUELU_TENTATIVEPFACTORY_KOKKOS_SHORT
369using TentativePFactory_kokkos [[maybe_unused]] = MueLu::TentativePFactory_kokkos<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
370#endif
371#ifdef MUELU_MATRIXFREETENTATIVEP_SHORT
372using MatrixFreeTentativeP [[maybe_unused]] = MueLu::MatrixFreeTentativeP<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
373#endif
374#ifdef MUELU_MATRIXFREETENTATIVEPFACTORY_SHORT
375using MatrixFreeTentativePFactory [[maybe_unused]] = MueLu::MatrixFreeTentativePFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
376#endif
377#ifdef MUELU_THRESHOLDAFILTERFACTORY_SHORT
378using ThresholdAFilterFactory [[maybe_unused]] = MueLu::ThresholdAFilterFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
379#endif
380#ifdef MUELU_TOGGLECOORDINATESTRANSFERFACTORY_SHORT
381using ToggleCoordinatesTransferFactory [[maybe_unused]] = MueLu::ToggleCoordinatesTransferFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
382#endif
383#ifdef MUELU_TOGGLEPFACTORY_SHORT
384using TogglePFactory [[maybe_unused]] = MueLu::TogglePFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
385#endif
386#ifdef MUELU_TOPRAPFACTORY_SHORT
387using TopRAPFactory [[maybe_unused]] = MueLu::TopRAPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
388#endif
389#ifdef MUELU_TOPSMOOTHERFACTORY_SHORT
390using TopSmootherFactory [[maybe_unused]] = MueLu::TopSmootherFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
391#endif
392#ifdef MUELU_TPETRAOPERATOR_SHORT
393using TpetraOperator [[maybe_unused]] = MueLu::TpetraOperator<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
394#endif
395#ifdef MUELU_TRANSPFACTORY_SHORT
396using TransPFactory [[maybe_unused]] = MueLu::TransPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
397#endif
398#ifdef MUELU_RFROMP_OR_TRANSP_SHORT
399using RfromP_Or_TransP [[maybe_unused]] = MueLu::RfromP_Or_TransP<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
400#endif
401#ifdef MUELU_TRILINOSSMOOTHER_SHORT
402using TrilinosSmoother [[maybe_unused]] = MueLu::TrilinosSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
403#endif
404#ifdef MUELU_UNSMOOSHFACTORY_SHORT
405using UnsmooshFactory [[maybe_unused]] = MueLu::UnsmooshFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
406#endif
407#ifdef MUELU_USERPFACTORY_SHORT
408using UserPFactory [[maybe_unused]] = MueLu::UserPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
409#endif
410#ifdef MUELU_UTILITIES_SHORT
411using Utilities [[maybe_unused]] = MueLu::Utilities<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
412#endif
413#ifdef MUELU_UTILITIESBASE_SHORT
414using UtilitiesBase [[maybe_unused]] = MueLu::UtilitiesBase<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
415#endif
416#ifdef MUELU_VARIABLEDOFLAPLACIANFACTORY_SHORT
417using VariableDofLaplacianFactory [[maybe_unused]] = MueLu::VariableDofLaplacianFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
418#endif
419#ifdef MUELU_SEMICOARSENPFACTORY_SHORT
420using SemiCoarsenPFactory [[maybe_unused]] = MueLu::SemiCoarsenPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
421#endif
422#ifdef MUELU_SEMICOARSENPFACTORY_KOKKOS_SHORT
423using SemiCoarsenPFactory_kokkos [[maybe_unused]] = MueLu::SemiCoarsenPFactory_kokkos<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
424#endif
425#ifdef MUELU_UZAWASMOOTHER_SHORT
426using UzawaSmoother [[maybe_unused]] = MueLu::UzawaSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
427#endif
428#ifdef MUELU_VISUALIZATIONHELPERS_SHORT
429using VisualizationHelpers [[maybe_unused]] = MueLu::VisualizationHelpers<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
430#endif
431#ifdef MUELU_ZEROSUBBLOCKAFACTORY_SHORT
432using ZeroSubBlockAFactory [[maybe_unused]] = MueLu::ZeroSubBlockAFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
433#endif
434#ifdef MUELU_ZOLTANINTERFACE_SHORT
435using ZoltanInterface [[maybe_unused]] = MueLu::ZoltanInterface<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
436#endif
437#ifdef MUELU_ZOLTAN2INTERFACE_SHORT
438using Zoltan2Interface [[maybe_unused]] = MueLu::Zoltan2Interface<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
439#endif
440#ifdef MUELU_NODEPARTITIONINTERFACE_SHORT
441using NodePartitionInterface [[maybe_unused]] = MueLu::NodePartitionInterface<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
442#endif
443#ifdef MUELU_XPETRAOPERATOR_SHORT
444using XpetraOperator [[maybe_unused]] = MueLu::XpetraOperator<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
445#endif
446#ifdef MUELU_REFMAXWELL_SHORT
447using RefMaxwell [[maybe_unused]] = MueLu::RefMaxwell<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
448#endif
449#ifdef MUELU_MAXWELL1_SHORT
450using Maxwell1 [[maybe_unused]] = MueLu::Maxwell1<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
451#endif
452#ifdef MUELU_MULTIPHYS_SHORT
453using MultiPhys [[maybe_unused]] = MueLu::MultiPhys<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
454#endif
455#ifdef MUELU_MAXWELL_UTILS_SHORT
456using Maxwell_Utils [[maybe_unused]] = MueLu::Maxwell_Utils<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
457#endif
458#ifdef MUELU_SINGLELEVELMATLABFACTORY_SHORT
459using SingleLevelMatlabFactory [[maybe_unused]] = MueLu::SingleLevelMatlabFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
460#endif
461#ifdef MUELU_TWOLEVELMATLABFACTORY_SHORT
462using TwoLevelMatlabFactory [[maybe_unused]] = MueLu::TwoLevelMatlabFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
463#endif
464#ifdef MUELU_MATLABSMOOTHER_SHORT
465using MatlabSmoother [[maybe_unused]] = MueLu::MatlabSmoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
466#endif
AlgebraicPermutationStrategy
Class which defines local permutations of matrix columns.
BrickAggregationFactory
Aggregation method for generating "brick" aggregates. It also does "hotdogs" and "pancakes....
Constraint
Class which contains the constraint space details.
LocalPermutationStrategy
Class which defines local permutations of matrix columns which correspond to DOFs of the same node.
MueLu::AMGXOperator
Adapter for AmgX library from Nvidia.
Definition MueLu_AMGXOperator_decl.hpp:44
MueLu::AggregateQualityEstimateFactory
An factory which assigns each aggregate a quality estimate. Originally developed by Napov and Notay i...
Definition MueLu_AggregateQualityEstimateFactory_decl.hpp:48
MueLu::AggregationExportFactory
Factory to export aggregation info or visualize aggregates using VTK.
Definition MueLu_AggregationExportFactory_decl.hpp:73
MueLu::AmalgamationFactory
AmalgamationFactory for subblocks of strided map based amalgamation data.
Definition MueLu_AmalgamationFactory_decl.hpp:42
MueLu::Amesos2Smoother
Class that encapsulates Amesos2 direct solvers.
Definition MueLu_Amesos2Smoother_decl.hpp:59
MueLu::BelosSmoother
Class that encapsulates Belos smoothers.
Definition MueLu_BelosSmoother_decl.hpp:52
MueLu::BlackBoxPFactory
Prolongator factory performing geometric coarsening.
Definition MueLu_BlackBoxPFactory_decl.hpp:84
MueLu::BlockedCoarseMapFactory
Factory for generating coarse level map. Used by BlockedPFactory.
Definition MueLu_BlockedCoarseMapFactory_decl.hpp:59
MueLu::BlockedCoordinatesTransferFactory
Class for transferring coordinates from a finer level to a coarser one for BlockedCrsMatrices....
Definition MueLu_BlockedCoordinatesTransferFactory_decl.hpp:57
MueLu::BlockedDirectSolver
direct solver for nxn blocked matrices
Definition MueLu_BlockedDirectSolver_decl.hpp:46
MueLu::BlockedGaussSeidelSmoother
block Gauss-Seidel method for blocked matrices
Definition MueLu_BlockedGaussSeidelSmoother_decl.hpp:77
MueLu::BlockedJacobiSmoother
block Jacobi method for blocked matrices
Definition MueLu_BlockedJacobiSmoother_decl.hpp:79
MueLu::BlockedPFactory
Factory for building blocked, segregated prolongation operators.
Definition MueLu_BlockedPFactory_decl.hpp:86
MueLu::BlockedRAPFactory
Factory for building coarse matrices.
Definition MueLu_BlockedRAPFactory_decl.hpp:35
MueLu::BraessSarazinSmoother
BraessSarazin smoother for 2x2 block matrices.
Definition MueLu_BraessSarazinSmoother_decl.hpp:43
MueLu::CGSolver
Implements conjugate gradient algorithm for energy-minimization.
Definition MueLu_CGSolver_decl.hpp:43
MueLu::ClassicalMapFactory
Factory for generating F/C-splitting and a coarse level map. Used by ClassicalPFactory.
Definition MueLu_ClassicalMapFactory_decl.hpp:62
MueLu::CloneRepartitionInterface
Helper class which transforms an "Partition" array generated from a block in a blocked operator to a ...
Definition MueLu_CloneRepartitionInterface_decl.hpp:60
MueLu::CoalesceDropFactory_kokkos
Factory for creating a graph based on a given matrix.
Definition MueLu_CoalesceDropFactory_kokkos_decl.hpp:97
MueLu::CoalesceDropFactory
Factory for creating a graph based on a given matrix.
Definition MueLu_CoalesceDropFactory_decl.hpp:98
MueLu::CoarseMapFactory
Factory for generating coarse level map. Used by TentativePFactory.
Definition MueLu_CoarseMapFactory_decl.hpp:77
MueLu::CoarseningVisualizationFactory
Factory to visualize coarsening information using prolongation operators.
Definition MueLu_CoarseningVisualizationFactory_decl.hpp:55
MueLu::CombinePFactory
Prolongator factory that replicates 'Psubblock' matrix to create new prolongator suitable for PDE sys...
Definition MueLu_CombinePFactory_decl.hpp:94
MueLu::ConstraintFactory
Factory for building the constraint operator.
Definition MueLu_ConstraintFactory_decl.hpp:33
MueLu::Constraint
Constraint space information for the potential prolongator.
Definition MueLu_Constraint_decl.hpp:69
MueLu::CoordinatesTransferFactory
Class for transferring coordinates from a finer level to a coarser one.
Definition MueLu_CoordinatesTransferFactory_decl.hpp:65
MueLu::CoupledRBMFactory
Nullspace Factory for coupled acoustic-elastic problems.
Definition MueLu_CoupledRBMFactory_decl.hpp:38
MueLu::DemoFactory
empty factory for demonstration
Definition MueLu_DemoFactory_decl.hpp:28
MueLu::DirectSolver
Class that encapsulates direct solvers. Autoselection of AmesosSmoother or Amesos2Smoother according ...
Definition MueLu_DirectSolver_decl.hpp:43
MueLu::DropNegativeEntriesFactory
Application-specific filtering for A. Can be used in context of graph coarsening and aggregation.
Definition MueLu_DropNegativeEntriesFactory_decl.hpp:33
MueLu::EminPFactory
Factory for building Energy Minimization prolongators.
Definition MueLu_EminPFactory_decl.hpp:41
MueLu::FactoryFactory
Factory that can generate other factories from.
Definition MueLu_FactoryFactory_decl.hpp:159
MueLu::FactoryManager
This class specifies the default factory that should generate some data on a Level if the data does n...
Definition MueLu_FactoryManager_decl.hpp:70
MueLu::FilteredAFactory
Factory for building filtered matrices using filtered graphs.
Definition MueLu_FilteredAFactory_decl.hpp:34
MueLu::GMRESSolver
Implements conjugate gradient algorithm for energy-minimization.
Definition MueLu_GMRESSolver_decl.hpp:43
MueLu::GeneralGeometricPFactory
Prolongator factory performing geometric coarsening.
Definition MueLu_GeneralGeometricPFactory_decl.hpp:83
MueLu::GenericRFactory
Factory for building restriction operators using a prolongator factory.
Definition MueLu_GenericRFactory_decl.hpp:38
MueLu::GeometricInterpolationPFactory_kokkos
Definition MueLu_GeometricInterpolationPFactory_kokkos_decl.hpp:27
MueLu::Hierarchy
Provides methods to build a multigrid hierarchy and apply multigrid cycles.
Definition MueLu_Hierarchy_decl.hpp:63
MueLu::Ifpack2Smoother
Class that encapsulates Ifpack2 smoothers.
Definition MueLu_Ifpack2Smoother_decl.hpp:55
MueLu::IndefBlockedDiagonalSmoother
Cheap Blocked diagonal smoother for indefinite 2x2 block matrices.
Definition MueLu_IndefBlockedDiagonalSmoother_decl.hpp:55
MueLu::InitialBlockNumberFactory
Class for generating an initial LocalOrdinal-type BlockNumber vector, based on an input paraemter for...
Definition MueLu_InitialBlockNumberFactory_decl.hpp:33
MueLu::InterfaceAggregationFactory
Factory for building aggregates for Lagrange multipliers in surface-coupled problems.
Definition MueLu_InterfaceAggregationFactory_decl.hpp:88
MueLu::IntrepidPCoarsenFactory
Factory for building transfer operators based on coarsening in polynomial degree, following the Intre...
Definition MueLu_IntrepidPCoarsenFactory_decl.hpp:77
MueLu::InverseApproximationFactory
Factory for building the approximate inverse of a matrix.
Definition MueLu_InverseApproximationFactory_decl.hpp:63
MueLu::LineDetectionFactory
Factory for building line detection information.
Definition MueLu_LineDetectionFactory_decl.hpp:35
MueLu::LowPrecisionFactory
Factory for converting matrices to half precision operators.
Definition MueLu_LowPrecisionFactory_decl.hpp:29
MueLu::MapTransferFactory
Factory to transfer a map from a fine to a coarse level.
Definition MueLu_MapTransferFactory_decl.hpp:57
MueLu::MatlabSmoother
Class that encapsulates Matlab smoothers.
Definition MueLu_MatlabSmoother_decl.hpp:38
MueLu::MatrixAnalysisFactory
This class checks matrix properties of A on current level. This factory can be plugged in everywhere ...
Definition MueLu_MatrixAnalysisFactory_decl.hpp:57
MueLu::MatrixFreeTentativePFactory
Factory for building the matrix-free tentative restrictor.
Definition MueLu_MatrixFreeTentativePFactory_decl.hpp:66
MueLu::MatrixFreeTentativeP
Matrix-free tentative restrictor operator.
Definition MueLu_MatrixFreeTentativeP_decl.hpp:37
MueLu::Maxwell1
Preconditioner (wrapped as a Xpetra::Operator) for Maxwell's equations in curl-curl form.
Definition MueLu_Maxwell1_decl.hpp:46
MueLu::Maxwell_Utils
Utility functions for Maxwell.
Definition MueLu_Maxwell_Utils_decl.hpp:36
MueLu::MultiPhys
Preconditioner (wrapped as a Xpetra::Operator) for solving MultiPhysics PDEs.
Definition MueLu_MultiPhys_decl.hpp:46
MueLu::MultiVectorTransferFactory
Class for restricting a MultiVector from a finer to a coarser level.
Definition MueLu_MultiVectorTransferFactory_decl.hpp:35
MueLu::NullspaceFactory
Factory for generating nullspace.
Definition MueLu_NullspaceFactory_decl.hpp:69
MueLu::PatternFactory
Factory for building nonzero patterns for energy minimization.
Definition MueLu_PatternFactory_decl.hpp:31
MueLu::PermutationFactory
factory generates a row- and column permutation operators P and Q such that P*A*Q^T is a (hopefully) ...
Definition MueLu_PermutationFactory_decl.hpp:42
MueLu::PermutingSmoother
This class first calculates row- and column permutation operators and applies a smoother to the permu...
Definition MueLu_PermutingSmoother_decl.hpp:47
MueLu::PgPFactory
Factory for building Petrov-Galerkin Smoothed Aggregation prolongators.
Definition MueLu_PgPFactory_decl.hpp:46
MueLu::ProjectorSmoother
This class enables the elimination of the nullspace component of the solution through the use of proj...
Definition MueLu_ProjectorSmoother_decl.hpp:43
MueLu::RAPFactory
Factory for building coarse matrices.
Definition MueLu_RAPFactory_decl.hpp:38
MueLu::RAPShiftFactory
Factory for building coarse grid matrices, when the matrix is of the form K+a*M. Useful when you want...
Definition MueLu_RAPShiftFactory_decl.hpp:40
MueLu::RebalanceAcFactory
Factory for building coarse matrices.
Definition MueLu_RebalanceAcFactory_decl.hpp:34
MueLu::RebalanceTransferFactory
Applies permutation to grid transfer operators.
Definition MueLu_RebalanceTransferFactory_decl.hpp:42
MueLu::RefMaxwellSmoother
Class that encapsulates Operator smoothers.
Definition MueLu_RefMaxwellSmoother_decl.hpp:38
MueLu::RefMaxwell
Preconditioner (wrapped as a Xpetra::Operator) for Maxwell's equations in curl-curl form.
Definition MueLu_RefMaxwell_decl.hpp:220
MueLu::RegionRFactory_kokkos
Factory that builds a restriction operator for region multigrid.
Definition MueLu_RegionRFactory_kokkos_decl.hpp:33
MueLu::RegionRFactory
Factory that builds a restriction operator for region multigrid.
Definition MueLu_RegionRFactory_decl.hpp:29
MueLu::ReitzingerPFactory
Factory for building tentative prolongator.
Definition MueLu_ReitzingerPFactory_decl.hpp:69
MueLu::ReorderBlockAFactory
Factory for building a reordered (nested) block operator.
Definition MueLu_ReorderBlockAFactory_decl.hpp:38
MueLu::RepartitionBlockDiagonalFactory
Factory which rebalances a map on current level using the Importer object generated by the Repartitio...
Definition MueLu_RepartitionBlockDiagonalFactory_decl.hpp:32
MueLu::RepartitionFactory
Factory for building permutation matrix that can be be used to shuffle data (matrices,...
Definition MueLu_RepartitionFactory_decl.hpp:79
MueLu::RepartitionHeuristicFactory
Factory for determing the number of partitions for rebalancing.
Definition MueLu_RepartitionHeuristicFactory_decl.hpp:77
MueLu::ReplicatePFactory
Prolongator factory that replicates 'Psubblock' matrix to create new prolongator suitable for PDE sys...
Definition MueLu_ReplicatePFactory_decl.hpp:75
MueLu::RfromP_Or_TransP
Factory for building restriction operators.
Definition MueLu_RfromP_Or_TransP_decl.hpp:37
MueLu::RigidBodyModeFactory
Nullspace Factory for building rigid body modes.
Definition MueLu_RigidBodyModeFactory_decl.hpp:35
MueLu::SaPFactory_kokkos
Definition MueLu_SaPFactory_kokkos_decl.hpp:18
MueLu::SaPFactory
Factory for building Smoothed Aggregation prolongators.
Definition MueLu_SaPFactory_decl.hpp:62
MueLu::ScaledNullspaceFactory
Factory for generating a very special nullspace.
Definition MueLu_ScaledNullspaceFactory_decl.hpp:73
MueLu::SchurComplementFactory
Factory for building the Schur Complement for a 2x2 block matrix.
Definition MueLu_SchurComplementFactory_decl.hpp:70
MueLu::SegregatedAFactory
Factory for building a new "segregated" A operator. Here, "segregated" means that the user provides s...
Definition MueLu_SegregatedAFactory_decl.hpp:75
MueLu::SemiCoarsenPFactory_kokkos
Prolongator factory performing semi-coarsening.
Definition MueLu_SemiCoarsenPFactory_kokkos_decl.hpp:61
MueLu::SemiCoarsenPFactory
Prolongator factory performing semi-coarsening.
Definition MueLu_SemiCoarsenPFactory_decl.hpp:74
MueLu::ShiftedLaplacianOperator
Wraps an existing MueLu::Hierarchy as a Tpetra::Operator, with an optional two-level correction....
Definition MueLu_ShiftedLaplacianOperator_decl.hpp:33
MueLu::ShiftedLaplacian
Shifted Laplacian Helmholtz solver.
Definition MueLu_ShiftedLaplacian_decl.hpp:71
MueLu::SimpleSmoother
SIMPLE smoother for 2x2 block matrices.
Definition MueLu_SimpleSmoother_decl.hpp:45
MueLu::SmooVecCoalesceDropFactory
Factory for creating a graph base on a given matrix.
Definition MueLu_SmooVecCoalesceDropFactory_decl.hpp:85
MueLu::SmootherBase
Base class for smoothers.
Definition MueLu_SmootherBase.hpp:32
MueLu::SmootherFactory
Generic Smoother Factory for generating the smoothers of the MG hierarchy.
Definition MueLu_SmootherFactory_decl.hpp:54
MueLu::SmootherPrototype
Base class for smoother prototypes.
Definition MueLu_SmootherPrototype_decl.hpp:39
MueLu::Smoother
Base class for smoother factories.
Definition MueLu_Smoother_fwd.hpp:15
MueLu::SolverBase
Base class for energy-minimization iterative solvers.
Definition MueLu_SolverBase.hpp:31
MueLu::SteepestDescentSolver
Implements steepest descent algorithm for energy-minimization.
Definition MueLu_SteepestDescentSolver_decl.hpp:33
MueLu::StructuredAggregationFactory
Factory for building aggregates on structured grids.
Definition MueLu_StructuredAggregationFactory_decl.hpp:69
MueLu::StructuredLineDetectionFactory
Factory building line detection information on structured meshes.
Definition MueLu_StructuredLineDetectionFactory_decl.hpp:30
MueLu::SubBlockAFactory
Factory for building a thresholded operator.
Definition MueLu_SubBlockAFactory_decl.hpp:57
MueLu::TekoSmoother
Interface to block smoothers in Teko package.
Definition MueLu_TekoSmoother_decl.hpp:46
MueLu::TentativePFactory_kokkos
Definition MueLu_TentativePFactory_kokkos_decl.hpp:70
MueLu::TentativePFactory
Factory for building tentative prolongator.
Definition MueLu_TentativePFactory_decl.hpp:85
MueLu::ThresholdAFilterFactory
Factory for building a thresholded operator.
Definition MueLu_ThresholdAFilterFactory_decl.hpp:37
MueLu::ToggleCoordinatesTransferFactory
Class for transferring coordinates from a finer level to a coarser one.
Definition MueLu_ToggleCoordinatesTransferFactory_decl.hpp:29
MueLu::TogglePFactory
Prolongator factory which allows switching between two different prolongator strategies.
Definition MueLu_TogglePFactory_decl.hpp:58
MueLu::TpetraOperator
Wraps an existing MueLu::Hierarchy as a Tpetra::Operator.
Definition MueLu_TpetraOperator_decl.hpp:28
MueLu::TransPFactory
Factory for building restriction operators.
Definition MueLu_TransPFactory_decl.hpp:37
MueLu::TrilinosSmoother
Class that encapsulates external library smoothers.
Definition MueLu_TrilinosSmoother_decl.hpp:53
MueLu::TwoLevelMatlabFactory
Factory for interacting with Matlab.
Definition MueLu_TwoLevelMatlabFactory_decl.hpp:42
MueLu::UnsmooshFactory
Factory for building "unsmooshed" transfer operators from transfer operators associated with a scalar...
Definition MueLu_UnsmooshFactory_decl.hpp:60
MueLu::Utilities
MueLu utility class.
Definition MueLu_Utilities_decl.hpp:102
MueLu::UzawaSmoother
Block triangle Uzawa smoother for 2x2 block matrices.
Definition MueLu_UzawaSmoother_decl.hpp:44
MueLu::VariableDofLaplacianFactory
Factory for building scalar Laplace operator (that is used as fake operator for variable dof size pro...
Definition MueLu_VariableDofLaplacianFactory_decl.hpp:66
MueLu::VisualizationHelpers
Base class providing routines to visualize aggregates and coarsening information.
Definition MueLu_VisualizationHelpers_decl.hpp:87
MueLu::XpetraOperator
Wraps an existing MueLu::Hierarchy as a Xpetra::Operator.
Definition MueLu_XpetraOperator_decl.hpp:28
MueLu::ZeroSubBlockAFactory
Factory for extracting a zero block from a BlockedCrsMatrix.
Definition MueLu_ZeroSubBlockAFactory_decl.hpp:34
MueLu::Zoltan2Interface
Interface to Zoltan2 library.
Definition MueLu_Zoltan2Interface_decl.hpp:79
MueLu::ZoltanInterface
Interface to Zoltan library.
Definition MueLu_ZoltanInterface_decl.hpp:77