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