46#ifndef MUELU_FACTORYFACTORY_DECL_HPP
47#define MUELU_FACTORYFACTORY_DECL_HPP
52#include <Teuchos_ParameterEntry.hpp>
53#include <Teuchos_Array.hpp>
61#include "MueLu_FactoryManager.hpp"
70#include "MueLu_AggregateQualityEstimateFactory.hpp"
71#include "MueLu_AggregationExportFactory.hpp"
72#include "MueLu_AmalgamationFactory.hpp"
73#include "MueLu_BlackBoxPFactory.hpp"
74#include "MueLu_BlockedCoarseMapFactory.hpp"
75#include "MueLu_BlockedCoordinatesTransferFactory.hpp"
76#include "MueLu_BlockedDirectSolver.hpp"
77#include "MueLu_BlockedGaussSeidelSmoother.hpp"
78#include "MueLu_BlockedJacobiSmoother.hpp"
79#include "MueLu_BlockedPFactory.hpp"
80#include "MueLu_BlockedRAPFactory.hpp"
81#include "MueLu_BraessSarazinSmoother.hpp"
82#include "MueLu_BrickAggregationFactory.hpp"
83#include "MueLu_ClassicalMapFactory.hpp"
84#include "MueLu_ClassicalPFactory.hpp"
85#include "MueLu_CloneRepartitionInterface.hpp"
86#include "MueLu_CoalesceDropFactory.hpp"
87#include "MueLu_SmooVecCoalesceDropFactory.hpp"
88#include "MueLu_CoarseMapFactory.hpp"
89#include "MueLu_CoarseningVisualizationFactory.hpp"
90#include "MueLu_ConstraintFactory.hpp"
91#include "MueLu_CoupledAggregationFactory.hpp"
92#include "MueLu_CoordinatesTransferFactory.hpp"
93#include "MueLu_DirectSolver.hpp"
94#include "MueLu_DropNegativeEntriesFactory.hpp"
95#include "MueLu_EminPFactory.hpp"
96#include "MueLu_FilteredAFactory.hpp"
97#include "MueLu_FineLevelInputDataFactory.hpp"
98#include "MueLu_GeneralGeometricPFactory.hpp"
99#include "MueLu_ReplicatePFactory.hpp"
100#include "MueLu_GenericRFactory.hpp"
101#include "MueLu_GeometricInterpolationPFactory.hpp"
102#include "MueLu_InterfaceAggregationFactory.hpp"
103#include "MueLu_InterfaceMappingTransferFactory.hpp"
104#include "MueLu_InitialBlockNumberFactory.hpp"
105#include "MueLu_IndefBlockedDiagonalSmoother.hpp"
106#include "MueLu_InverseApproximationFactory.hpp"
107#include "MueLu_IsorropiaInterface.hpp"
108#include "MueLu_LineDetectionFactory.hpp"
109#include "MueLu_LocalOrdinalTransferFactory.hpp"
110#include "MueLu_RepartitionInterface.hpp"
111#include "MueLu_RepartitionBlockDiagonalFactory.hpp"
112#include "MueLu_MapTransferFactory.hpp"
113#include "MueLu_MatrixAnalysisFactory.hpp"
114#include "MueLu_MultiVectorTransferFactory.hpp"
115#include "MueLu_NotayAggregationFactory.hpp"
116#include "MueLu_NullspaceFactory.hpp"
117#include "MueLu_NullspacePresmoothFactory.hpp"
118#include "MueLu_PatternFactory.hpp"
119#include "MueLu_PgPFactory.hpp"
120#include "MueLu_RebalanceBlockInterpolationFactory.hpp"
121#include "MueLu_RebalanceBlockRestrictionFactory.hpp"
122#include "MueLu_RebalanceBlockAcFactory.hpp"
123#include "MueLu_RebalanceTransferFactory.hpp"
124#include "MueLu_RegionRFactory.hpp"
125#include "MueLu_RepartitionFactory.hpp"
126#include "MueLu_RepartitionHeuristicFactory.hpp"
127#include "MueLu_RAPFactory.hpp"
128#include "MueLu_RAPShiftFactory.hpp"
129#include "MueLu_RebalanceAcFactory.hpp"
130#include "MueLu_ReorderBlockAFactory.hpp"
131#include "MueLu_SaPFactory.hpp"
132#include "MueLu_ScaledNullspaceFactory.hpp"
133#include "MueLu_SegregatedAFactory.hpp"
134#include "MueLu_SemiCoarsenPFactory.hpp"
135#include "MueLu_SchurComplementFactory.hpp"
136#include "MueLu_SimpleSmoother.hpp"
137#include "MueLu_SmootherFactory.hpp"
138#include "MueLu_StructuredAggregationFactory.hpp"
139#include "MueLu_StructuredLineDetectionFactory.hpp"
140#include "MueLu_SubBlockAFactory.hpp"
141#ifdef HAVE_MUELU_TEKO
142#include "MueLu_TekoSmoother.hpp"
144#include "MueLu_TentativePFactory.hpp"
145#include "MueLu_ToggleCoordinatesTransferFactory.hpp"
146#include "MueLu_TogglePFactory.hpp"
147#include "MueLu_TrilinosSmoother.hpp"
148#include "MueLu_TransPFactory.hpp"
149#include "MueLu_RfromP_Or_TransP.hpp"
150#include "MueLu_UncoupledAggregationFactory.hpp"
151#include "MueLu_HybridAggregationFactory.hpp"
152#include "MueLu_UnsmooshFactory.hpp"
153#include "MueLu_UserAggregationFactory.hpp"
154#include "MueLu_UserPFactory.hpp"
155#include "MueLu_UzawaSmoother.hpp"
156#include "MueLu_VariableDofLaplacianFactory.hpp"
157#include "MueLu_ZeroSubBlockAFactory.hpp"
158#include "MueLu_ZoltanInterface.hpp"
159#include "MueLu_Zoltan2Interface.hpp"
160#include "MueLu_NodePartitionInterface.hpp"
163#include "MueLu_AmalgamationFactory_kokkos.hpp"
164#include "MueLu_CoalesceDropFactory_kokkos.hpp"
165#include "MueLu_CoarseMapFactory_kokkos.hpp"
166#include "MueLu_CoordinatesTransferFactory_kokkos.hpp"
167#include "MueLu_GeometricInterpolationPFactory_kokkos.hpp"
168#include "MueLu_NullspaceFactory_kokkos.hpp"
169#include "MueLu_SaPFactory_kokkos.hpp"
170#include "MueLu_SemiCoarsenPFactory_kokkos.hpp"
171#include "MueLu_StructuredAggregationFactory_kokkos.hpp"
172#include "MueLu_TentativePFactory_kokkos.hpp"
173#include "MueLu_MatrixFreeTentativePFactory_kokkos.hpp"
174#include "MueLu_UncoupledAggregationFactory_kokkos.hpp"
175#include "MueLu_RegionRFactory_kokkos.hpp"
177#ifdef HAVE_MUELU_MATLAB
179#include "../matlab/src/MueLu_SingleLevelMatlabFactory_decl.hpp"
180#include "../matlab/src/MueLu_SingleLevelMatlabFactory_def.hpp"
181#include "../matlab/src/MueLu_TwoLevelMatlabFactory_decl.hpp"
182#include "../matlab/src/MueLu_TwoLevelMatlabFactory_def.hpp"
183#include "../matlab/src/MueLu_MatlabSmoother_decl.hpp"
184#include "../matlab/src/MueLu_MatlabSmoother_def.hpp"
187#ifdef HAVE_MUELU_INTREPID2
188#include "MueLu_IntrepidPCoarsenFactory.hpp"
204#undef MUELU_FACTORYFACTORY_SHORT
207 typedef std::map<std::string, RCP<const FactoryBase> >
FactoryMap;
231 std::string factoryName;
232 Teuchos::ParameterList paramList;
233 if (!param.isList()) {
234 factoryName = Teuchos::getValue<std::string>(param);
236 paramList = Teuchos::getValue<Teuchos::ParameterList>(param);
237 factoryName = paramList.get<std::string>(
"factory");
241 if (factoryName ==
"AggregateQualityEstimateFactory")
return Build2<AggregateQualityEstimateFactory> (paramList, factoryMapIn, factoryManagersIn);
242 if (factoryName ==
"AggregationExportFactory")
return Build2<AggregationExportFactory> (paramList, factoryMapIn, factoryManagersIn);
243 if (factoryName ==
"AmalgamationFactory")
return Build2<AmalgamationFactory> (paramList, factoryMapIn, factoryManagersIn);
244 if (factoryName ==
"BlockedCoarseMapFactory")
return Build2<BlockedCoarseMapFactory> (paramList, factoryMapIn, factoryManagersIn);
245 if (factoryName ==
"BlockedRAPFactory")
return BuildRAPFactory<BlockedRAPFactory> (paramList, factoryMapIn, factoryManagersIn);
246 if (factoryName ==
"BrickAggregationFactory")
return Build2<BrickAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
247 if (factoryName ==
"ClassicalMapFactory")
return Build2<ClassicalMapFactory> (paramList, factoryMapIn, factoryManagersIn);
248 if (factoryName ==
"ClassicalPFactory")
return Build2<ClassicalPFactory> (paramList, factoryMapIn, factoryManagersIn);
249 if (factoryName ==
"CloneRepartitionInterface")
return Build2<CloneRepartitionInterface> (paramList, factoryMapIn, factoryManagersIn);
250 if (factoryName ==
"CoarseMapFactory")
return Build2<CoarseMapFactory> (paramList, factoryMapIn, factoryManagersIn);
251 if (factoryName ==
"CoarseningVisualizationFactory")
return Build2<CoarseningVisualizationFactory> (paramList, factoryMapIn, factoryManagersIn);
252 if (factoryName ==
"CoalesceDropFactory")
return Build2<CoalesceDropFactory> (paramList, factoryMapIn, factoryManagersIn);
253 if (factoryName ==
"SmooVecCoalesceDropFactory")
return Build2<SmooVecCoalesceDropFactory> (paramList, factoryMapIn, factoryManagersIn);
254 if (factoryName ==
"ConstraintFactory")
return Build2<ConstraintFactory> (paramList, factoryMapIn, factoryManagersIn);
256 if (factoryName ==
"CoordinatesTransferFactory")
return Build2<CoordinatesTransferFactory> (paramList, factoryMapIn, factoryManagersIn);
257 if (factoryName ==
"DirectSolver")
return BuildDirectSolver (paramList, factoryMapIn, factoryManagersIn);
258 if (factoryName ==
"DropNegativeEntriesFactory")
return Build2<DropNegativeEntriesFactory> (paramList, factoryMapIn, factoryManagersIn);
259 if (factoryName ==
"EminPFactory")
return Build2<EminPFactory> (paramList, factoryMapIn, factoryManagersIn);
260 if (factoryName ==
"FilteredAFactory")
return Build2<FilteredAFactory> (paramList, factoryMapIn, factoryManagersIn);
261 if (factoryName ==
"FineLevelInputDataFactory")
return Build2<FineLevelInputDataFactory> (paramList, factoryMapIn, factoryManagersIn);
262 if (factoryName ==
"GeneralGeometricPFactory")
return Build2<GeneralGeometricPFactory> (paramList, factoryMapIn, factoryManagersIn);
263 if (factoryName ==
"ReplicatePFactory")
return Build2<ReplicatePFactory> (paramList, factoryMapIn, factoryManagersIn);
264 if (factoryName ==
"GenericRFactory")
return Build2<GenericRFactory> (paramList, factoryMapIn, factoryManagersIn);
265 if (factoryName ==
"GeometricInterpolationPFactory")
return Build2<GeometricInterpolationPFactory> (paramList, factoryMapIn, factoryManagersIn);
266 if (factoryName ==
"HybridAggregationFactory")
return Build2<HybridAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
267 if (factoryName ==
"InterfaceAggregationFactory")
return Build2<InterfaceAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
268 if (factoryName ==
"InterfaceMappingTransferFactory")
return Build2<InterfaceMappingTransferFactory> (paramList, factoryMapIn, factoryManagersIn);
269 if (factoryName ==
"InverseApproximationFactory")
return Build2<InverseApproximationFactory> (paramList, factoryMapIn, factoryManagersIn);
270 if (factoryName ==
"InitialBlockNumberFactory")
return Build2<InitialBlockNumberFactory> (paramList, factoryMapIn, factoryManagersIn);
271 if (factoryName ==
"LineDetectionFactory")
return Build2<LineDetectionFactory> (paramList, factoryMapIn, factoryManagersIn);
274 if (factoryName ==
"MapTransferFactory")
return Build2<MapTransferFactory> (paramList, factoryMapIn, factoryManagersIn);
275 if (factoryName ==
"MatrixAnalysisFactory")
return Build2<MatrixAnalysisFactory> (paramList, factoryMapIn, factoryManagersIn);
276 if (factoryName ==
"MultiVectorTransferFactory")
return Build2<MultiVectorTransferFactory> (paramList, factoryMapIn, factoryManagersIn);
278 if (factoryName ==
"NoSmoother")
return rcp(
new SmootherFactory(Teuchos::null));
279 if (factoryName ==
"NotayAggregationFactory")
return Build2<NotayAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
280 if (factoryName ==
"NullspaceFactory")
return Build2<NullspaceFactory> (paramList, factoryMapIn, factoryManagersIn);
281 if (factoryName ==
"NullspacePresmoothFactory")
return Build2<NullspacePresmoothFactory> (paramList, factoryMapIn, factoryManagersIn);
282 if (factoryName ==
"PatternFactory")
return Build2<PatternFactory> (paramList, factoryMapIn, factoryManagersIn);
283 if (factoryName ==
"PgPFactory")
return Build2<PgPFactory> (paramList, factoryMapIn, factoryManagersIn);
284 if (factoryName ==
"SaPFactory")
return Build2<SaPFactory> (paramList, factoryMapIn, factoryManagersIn);
285 if (factoryName ==
"RAPFactory")
return BuildRAPFactory<RAPFactory> (paramList, factoryMapIn, factoryManagersIn);
286 if (factoryName ==
"RAPShiftFactory")
return BuildRAPFactory<RAPShiftFactory> (paramList, factoryMapIn, factoryManagersIn);
287 if (factoryName ==
"RebalanceAcFactory")
return Build2<RebalanceAcFactory> (paramList, factoryMapIn, factoryManagersIn);
288 if (factoryName ==
"RebalanceTransferFactory")
return Build2<RebalanceTransferFactory> (paramList, factoryMapIn, factoryManagersIn);
289 if (factoryName ==
"RegionRFactory")
return Build2<RegionRFactory> (paramList, factoryMapIn, factoryManagersIn);
290 if (factoryName ==
"RegionRFactory_kokkos")
return Build2<RegionRFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
291 if (factoryName ==
"ReorderBlockAFactory")
return Build2<ReorderBlockAFactory> (paramList, factoryMapIn, factoryManagersIn);
292 if (factoryName ==
"RepartitionInterface")
return Build2<RepartitionInterface> (paramList, factoryMapIn, factoryManagersIn);
293 if (factoryName ==
"ScaledNullspaceFactory")
return Build2<ScaledNullspaceFactory> (paramList, factoryMapIn, factoryManagersIn);
294 if (factoryName ==
"SegregatedAFactory")
return Build2<SegregatedAFactory> (paramList, factoryMapIn, factoryManagersIn);
295 if (factoryName ==
"SemiCoarsenPFactory")
return Build2<SemiCoarsenPFactory> (paramList, factoryMapIn, factoryManagersIn);
296 if (factoryName ==
"StructuredAggregationFactory")
return Build2<StructuredAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
297 if (factoryName ==
"StructuredLineDetectionFactory")
return Build2<StructuredLineDetectionFactory> (paramList, factoryMapIn, factoryManagersIn);
298 if (factoryName ==
"SubBlockAFactory")
return Build2<SubBlockAFactory> (paramList, factoryMapIn, factoryManagersIn);
299 if (factoryName ==
"TentativePFactory")
return Build2<TentativePFactory> (paramList, factoryMapIn, factoryManagersIn);
301 if (factoryName ==
"TogglePFactory")
return BuildTogglePFactory<TogglePFactory> (paramList, factoryMapIn, factoryManagersIn);
302 if (factoryName ==
"TransPFactory")
return Build2<TransPFactory> (paramList, factoryMapIn, factoryManagersIn);
303 if (factoryName ==
"RfromP_Or_TransP")
return Build2<RfromP_Or_TransP> (paramList, factoryMapIn, factoryManagersIn);
304 if (factoryName ==
"TrilinosSmoother")
return BuildTrilinosSmoother (paramList, factoryMapIn, factoryManagersIn);
305 if (factoryName ==
"UncoupledAggregationFactory")
return Build2<UncoupledAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
306 if (factoryName ==
"UnsmooshFactory")
return Build2<UnsmooshFactory> (paramList, factoryMapIn, factoryManagersIn);
307 if (factoryName ==
"UserAggregationFactory")
return Build2<UserAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
308 if (factoryName ==
"UserPFactory")
return Build2<UserPFactory> (paramList, factoryMapIn, factoryManagersIn);
309 if (factoryName ==
"VariableDofLaplacianFactory")
return Build2<VariableDofLaplacianFactory> (paramList, factoryMapIn, factoryManagersIn);
310 if (factoryName ==
"ZeroSubBlockAFactory")
return Build2<ZeroSubBlockAFactory> (paramList, factoryMapIn, factoryManagersIn);
311 if (factoryName ==
"AmalgamationFactory_kokkos")
return Build2<AmalgamationFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
312 if (factoryName ==
"CoalesceDropFactory_kokkos")
return Build2<CoalesceDropFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
313 if (factoryName ==
"CoarseMapFactory_kokkos")
return Build2<CoarseMapFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
314 if (factoryName ==
"CoordinatesTransferFactory_kokkos")
return Build2<CoordinatesTransferFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
315 if (factoryName ==
"GeometricInterpolationPFactory_kokkos")
return Build2<GeometricInterpolationPFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
316 if (factoryName ==
"NullspaceFactory_kokkos")
return Build2<NullspaceFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
317 if (factoryName ==
"SaPFactory_kokkos")
return Build2<SaPFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
318 if (factoryName ==
"SemiCoarsenPFactory_kokkos")
return Build2<SemiCoarsenPFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
319 if (factoryName ==
"StructuredAggregationFactory_kokkos")
return Build2<StructuredAggregationFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
320 if (factoryName ==
"TentativePFactory_kokkos")
return Build2<TentativePFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
321 if (factoryName ==
"MatrixFreeTentativePFactory_kokkos")
return Build2<MatrixFreeTentativePFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
322 if (factoryName ==
"UncoupledAggregationFactory_kokkos")
return Build2<UncoupledAggregationFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
324 if (factoryName ==
"ZoltanInterface") {
325#if defined(HAVE_MUELU_ZOLTAN) && defined(HAVE_MPI)
326 return Build2<ZoltanInterface>(paramList, factoryMapIn, factoryManagersIn);
328 TEUCHOS_TEST_FOR_EXCEPTION(
true,
Exceptions::RuntimeError,
"MueLu::FactoryFactory:BuildFactory(): Cannot create a ZoltanInterface object: Zoltan is disabled: HAVE_MUELU_ZOLTAN && HAVE_MPI == false.");
331 if (factoryName ==
"Zoltan2Interface") {
332#if defined(HAVE_MUELU_ZOLTAN2) && defined(HAVE_MPI)
333 return Build2<Zoltan2Interface>(paramList, factoryMapIn, factoryManagersIn);
335 TEUCHOS_TEST_FOR_EXCEPTION(
true,
Exceptions::RuntimeError,
"MueLu::FactoryFactory:BuildFactory(): Cannot create a Zoltan2Interface object: Zoltan2 is disabled: HAVE_MUELU_ZOLTAN2 && HAVE_MPI == false.");
338 if (factoryName ==
"IsorropiaInterface") {
339#if defined(HAVE_MUELU_ISORROPIA) && defined(HAVE_MPI)
340 return Build2<IsorropiaInterface>(paramList, factoryMapIn, factoryManagersIn);
342 TEUCHOS_TEST_FOR_EXCEPTION(
true,
Exceptions::RuntimeError,
"MueLu::FactoryFactory:BuildFactory(): Cannot create a IsorropiaInterface object: Isorropia is disabled: HAVE_MUELU_ISORROPIA && HAVE_MPI == false.");
346 if (factoryName ==
"NodePartitionInterface") {
348 return Build2<NodePartitionInterface>(paramList, factoryMapIn, factoryManagersIn);
350 TEUCHOS_TEST_FOR_EXCEPTION(
true,
Exceptions::RuntimeError,
"MueLu::FactoryFactory:BuildFactory(): Cannot create a NodePartitionInterface object: HAVE_MPI == false.");
354 if (factoryName ==
"RepartitionFactory") {
356 return Build2<RepartitionFactory>(paramList, factoryMapIn, factoryManagersIn);
358 TEUCHOS_TEST_FOR_EXCEPTION(
true,
Exceptions::RuntimeError,
"MueLu::FactoryFactory:BuildFactory(): Cannot create a RepartitionFactory object: HAVE_MPI == false.");
361 if (factoryName ==
"RepartitionHeuristicFactory") {
363 return Build2<RepartitionHeuristicFactory>(paramList, factoryMapIn, factoryManagersIn);
365 TEUCHOS_TEST_FOR_EXCEPTION(
true,
Exceptions::RuntimeError,
"MueLu::FactoryFactory:BuildFactory(): Cannot create a RepartitionHeuristicFactory object: HAVE_MPI == false.");
369 if (factoryName ==
"BlockedCoordinatesTransferFactory")
return BuildBlockedCoordFactory<BlockedCoordinatesTransferFactory> (paramList, factoryMapIn, factoryManagersIn);
370 if (factoryName ==
"BlockedDirectSolver")
return BuildBlockedDirectSolver(paramList, factoryMapIn, factoryManagersIn);
371 if (factoryName ==
"BlockedGaussSeidelSmoother")
return BuildBlockedSmoother<BlockedGaussSeidelSmoother>(paramList, factoryMapIn, factoryManagersIn);
372 if (factoryName ==
"BlockedJacobiSmoother")
return BuildBlockedSmoother<BlockedJacobiSmoother>(paramList, factoryMapIn, factoryManagersIn);
373 if (factoryName ==
"BlockedPFactory")
return BuildBlockedFactory<BlockedPFactory>(paramList, factoryMapIn, factoryManagersIn);
374 if (factoryName ==
"BraessSarazinSmoother")
return BuildBlockedSmoother<BraessSarazinSmoother>(paramList, factoryMapIn, factoryManagersIn);
375 if (factoryName ==
"IndefiniteBlockDiagonalSmoother")
return BuildBlockedSmoother<IndefBlockedDiagonalSmoother>(paramList, factoryMapIn, factoryManagersIn);
376 if (factoryName ==
"SimpleSmoother")
return BuildBlockedSmoother<SimpleSmoother>(paramList, factoryMapIn, factoryManagersIn);
377 if (factoryName ==
"SchurComplementFactory")
return Build2<SchurComplementFactory> (paramList, factoryMapIn, factoryManagersIn);
378 if (factoryName ==
"RebalanceBlockRestrictionFactory")
return BuildBlockedFactory<RebalanceBlockRestrictionFactory>(paramList, factoryMapIn, factoryManagersIn);
379 if (factoryName ==
"RebalanceBlockAcFactory")
return BuildBlockedFactory<RebalanceBlockAcFactory>(paramList, factoryMapIn, factoryManagersIn);
380 if (factoryName ==
"RebalanceBlockInterpolationFactory")
return BuildBlockedFactory<RebalanceBlockInterpolationFactory>(paramList, factoryMapIn, factoryManagersIn);
382 if (factoryName ==
"RepartitionBlockDiagonalFactory")
return Build2<RepartitionBlockDiagonalFactory> (paramList, factoryMapIn, factoryManagersIn);
384#ifdef HAVE_MUELU_TEKO
385 if (factoryName ==
"TekoSmoother")
return BuildTekoSmoother(paramList, factoryMapIn, factoryManagersIn);
387 if (factoryName ==
"UzawaSmoother")
return BuildBlockedSmoother<UzawaSmoother>(paramList, factoryMapIn, factoryManagersIn);
390#ifdef HAVE_MUELU_MATLAB
391 if (factoryName ==
"TwoLevelMatlabFactory")
return Build2<TwoLevelMatlabFactory> (paramList, factoryMapIn, factoryManagersIn);
392 if (factoryName ==
"SingleLevelMatlabFactory")
return Build2<SingleLevelMatlabFactory> (paramList, factoryMapIn, factoryManagersIn);
393 if (factoryName ==
"MatlabSmoother")
return BuildMatlabSmoother (paramList, factoryMapIn, factoryManagersIn);
396#ifdef HAVE_MUELU_INTREPID2
397 if (factoryName ==
"IntrepidPCoarsenFactory")
return Build2<IntrepidPCoarsenFactory> (paramList, factoryMapIn, factoryManagersIn);
401 if (factoryMapIn.find(factoryName) != factoryMapIn.end()) {
403 "MueLu::FactoryFactory: Error during the parsing of: " << std::endl << paramList << std::endl
404 <<
"'" << factoryName <<
"' is not a factory name but an existing instance of a factory." << std::endl
405 <<
"Extra parameters cannot be specified after the creation of the object." << std::endl << std::endl
406 <<
"Correct syntaxes includes:" << std::endl
407 <<
" <Parameter name=\"...\" type=\"string\" value=\"" << factoryName <<
"\"/>" << std::endl
409 <<
" <ParameterList name=\"...\"><Parameter name=\"factory\" type=\"string\" value=\"" << factoryName <<
"\"/></ParameterList>" << std::endl
412 return factoryMapIn.find(factoryName)->second;
415 TEUCHOS_TEST_FOR_EXCEPTION(
true,
Exceptions::RuntimeError,
"MueLu::FactoryFactory: unknown factory name : " << factoryName);
417 TEUCHOS_UNREACHABLE_RETURN(Teuchos::null);
430#define arraysize(ar) (sizeof(ar) / sizeof(ar[0]))
434 RCP<T> factory = rcp(
new T());
436 const char* strarray[] = {
"A",
"P",
"R",
"Graph",
"UnAmalgamationInfo",
"Aggregates",
"Nullspace",
"TransferFactory",
"DofsPerNode"};
437 std::vector<std::string> v(strarray, strarray +
arraysize(strarray));
438 for (
size_t i = 0; i < v.size(); ++i)
439 if (paramList.isParameter(v[i]))
440 factory->SetFactory(v[i],
BuildFactory(paramList.getEntry(v[i]), factoryMapIn, factoryManagersIn));
447 RCP<T> factory = rcp(
new T());
449 ParameterList paramListWithFactories;
452 RCP<const ParameterList> validParamList = factory->GetValidParameterList();
453 TEUCHOS_TEST_FOR_EXCEPTION(validParamList == Teuchos::null,
Exceptions::RuntimeError,
"FactoryFactory::Build2: default parameter list is null. Please fix this.");
454 for (ParameterList::ConstIterator param = validParamList->begin(); param != validParamList->end(); ++param) {
455 const std::string& pName = validParamList->name(param);
457 if (!paramList.isParameter(pName)) {
462 if (validParamList->isType< RCP<const FactoryBase> >(pName)) {
464 RCP<const FactoryBase> generatingFact =
BuildFactory(paramList.getEntry(pName), factoryMapIn, factoryManagersIn);
465 paramListWithFactories.set(pName, generatingFact);
466 }
else if (validParamList->isType<RCP<const ParameterList> >(pName)) {
467 if (pName ==
"ParameterList") {
472 RCP<const ParameterList> subList = Teuchos::sublist(rcp(
new ParameterList(paramList)), pName);
473 paramListWithFactories.set(pName, subList);
476 paramListWithFactories.setEntry(pName, paramList.getEntry(pName));
481 factory->SetParameterList(paramListWithFactories);
489 if (paramList.isSublist(
"TransferFactories") ==
false) {
490 factory = Build2<T>(paramList, factoryMapIn, factoryManagersIn);
493 RCP<Teuchos::ParameterList> paramListNonConst = rcp(
new Teuchos::ParameterList(paramList));
494 RCP<const Teuchos::ParameterList> transferFactories = rcp(
new Teuchos::ParameterList(*sublist(paramListNonConst,
"TransferFactories")));
496 paramListNonConst->remove(
"TransferFactories");
498 factory = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
500 for (Teuchos::ParameterList::ConstIterator param = transferFactories->begin(); param != transferFactories->end(); ++param) {
501 RCP<const FactoryBase> p =
BuildFactory(transferFactories->entry(param), factoryMapIn, factoryManagersIn);
502 factory->AddTransferFactory(p);
512 if (paramList.isSublist(
"TransferFactories") ==
false) {
514 factory = Build2<T>(paramList, factoryMapIn, factoryManagersIn);
517 RCP<Teuchos::ParameterList> paramListNonConst = rcp(
new Teuchos::ParameterList(paramList));
518 RCP<const Teuchos::ParameterList> transferFactories = rcp(
new Teuchos::ParameterList(*sublist(paramListNonConst,
"TransferFactories")));
520 paramListNonConst->remove(
"TransferFactories");
523 factory = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
527 int numProlongatorFactories = 0;
528 int numPtentFactories = 0;
529 int numCoarseNspFactories = 0;
530 for (Teuchos::ParameterList::ConstIterator param = transferFactories->begin(); param != transferFactories->end(); ++param) {
531 size_t foundNsp = transferFactories->name(param).find(
"Nullspace");
532 if (foundNsp != std::string::npos && foundNsp == 0 && transferFactories->name(param).length()==10) {
533 numCoarseNspFactories++;
536 size_t foundPtent = transferFactories->name(param).find(
"Ptent");
537 if (foundPtent != std::string::npos && foundPtent == 0 && transferFactories->name(param).length()==6) {
541 size_t foundP = transferFactories->name(param).find(
"P");
542 if (foundP != std::string::npos && foundP == 0 && transferFactories->name(param).length()==2) {
543 numProlongatorFactories++;
547 TEUCHOS_TEST_FOR_EXCEPTION(numProlongatorFactories!=numCoarseNspFactories,
Exceptions::RuntimeError,
"FactoryFactory::BuildToggleP: The user has to provide the same number of prolongator and coarse nullspace factories!");
548 TEUCHOS_TEST_FOR_EXCEPTION(numPtentFactories!=numCoarseNspFactories,
Exceptions::RuntimeError,
"FactoryFactory::BuildToggleP: The user has to provide the same number of ptent and coarse nullspace factories!");
549 TEUCHOS_TEST_FOR_EXCEPTION(numProlongatorFactories < 2,
Exceptions::RuntimeError,
"FactoryFactory::BuildToggleP: The TogglePFactory needs at least two different prolongation operators. The factories have to be provided using the names P%i and Nullspace %i, where %i denotes a number between 1 and 9.");
552 std::vector<Teuchos::ParameterEntry> prolongatorFactoryNames(numProlongatorFactories);
553 std::vector<Teuchos::ParameterEntry> coarseNspFactoryNames(numProlongatorFactories);
554 std::vector<Teuchos::ParameterEntry> ptentFactoryNames(numProlongatorFactories);
556 for (Teuchos::ParameterList::ConstIterator param = transferFactories->begin(); param != transferFactories->end(); ++param) {
557 size_t foundNsp = transferFactories->name(param).find(
"Nullspace");
558 if (foundNsp != std::string::npos && foundNsp == 0 && transferFactories->name(param).length()==10) {
559 int number = atoi(&(transferFactories->name(param).at(9)));
560 TEUCHOS_TEST_FOR_EXCEPTION(number < 1 || number > numProlongatorFactories,
Exceptions::RuntimeError,
"FactoryFactory::BuildToggleP: Please use the format Nullspace%i with %i an integer between 1 and the maximum number of prolongation operators in TogglePFactory!");
561 coarseNspFactoryNames[number-1] = transferFactories->entry(param);
564 size_t foundPtent = transferFactories->name(param).find(
"Ptent");
565 if (foundPtent != std::string::npos && foundPtent == 0 && transferFactories->name(param).length()==6) {
566 int number = atoi(&(transferFactories->name(param).at(5)));
567 TEUCHOS_TEST_FOR_EXCEPTION(number < 1 || number > numPtentFactories,
Exceptions::RuntimeError,
"FactoryFactory::BuildToggleP: Please use the format Ptent%i with %i an integer between 1 and the maximum number of prolongation operators in TogglePFactory!");
568 ptentFactoryNames[number-1] = transferFactories->entry(param);
571 size_t foundP = transferFactories->name(param).find(
"P");
572 if (foundP != std::string::npos && foundP == 0 && transferFactories->name(param).length()==2) {
573 int number = atoi(&(transferFactories->name(param).at(1)));
574 TEUCHOS_TEST_FOR_EXCEPTION(number < 1 || number > numProlongatorFactories,
Exceptions::RuntimeError,
"FactoryFactory::BuildToggleP: Please use the format P%i with %i an integer between 1 and the maximum number of prolongation operators in TogglePFactory!");
575 prolongatorFactoryNames[number-1] = transferFactories->entry(param);
581 for (std::vector<Teuchos::ParameterEntry>::const_iterator it = prolongatorFactoryNames.begin(); it != prolongatorFactoryNames.end(); ++it) {
582 RCP<const FactoryBase> p =
BuildFactory(*it, factoryMapIn, factoryManagersIn);
583 factory->AddProlongatorFactory(p);
587 for (std::vector<Teuchos::ParameterEntry>::const_iterator it = ptentFactoryNames.begin(); it != ptentFactoryNames.end(); ++it) {
588 RCP<const FactoryBase> p =
BuildFactory(*it, factoryMapIn, factoryManagersIn);
589 factory->AddPtentFactory(p);
593 for (std::vector<Teuchos::ParameterEntry>::const_iterator it = coarseNspFactoryNames.begin(); it != coarseNspFactoryNames.end(); ++it) {
594 RCP<const FactoryBase> p =
BuildFactory(*it, factoryMapIn, factoryManagersIn);
595 factory->AddCoarseNullspaceFactory(p);
602 RCP<ToggleCoordinatesTransferFactory> factory;
603 TEUCHOS_TEST_FOR_EXCEPTION(paramList.isSublist(
"TransferFactories") ==
false,
Exceptions::RuntimeError,
"FactoryFactory::BuildToggleCoordinatesTransferFactory: the ToggleCoordinatesTransferFactory needs a sublist 'TransferFactories' containing information about the subfactories for coordinate transfer!");
605 RCP<Teuchos::ParameterList> paramListNonConst = rcp(
new Teuchos::ParameterList(paramList));
606 RCP<const Teuchos::ParameterList> transferFactories = rcp(
new Teuchos::ParameterList(*sublist(paramListNonConst,
"TransferFactories")));
607 paramListNonConst->remove(
"TransferFactories");
610 factory = Build2<ToggleCoordinatesTransferFactory>(*paramListNonConst, factoryMapIn, factoryManagersIn);
614 int numCoordTransferFactories = 0;
615 for (Teuchos::ParameterList::ConstIterator param = transferFactories->begin(); param != transferFactories->end(); ++param) {
616 size_t foundCoordinates = transferFactories->name(param).find(
"Coordinates");
617 if (foundCoordinates != std::string::npos && foundCoordinates == 0 && transferFactories->name(param).length()==12) {
618 numCoordTransferFactories++;
622 TEUCHOS_TEST_FOR_EXCEPTION(numCoordTransferFactories != 2,
Exceptions::RuntimeError,
"FactoryFactory::BuildToggleCoordinatesTransfer: The ToggleCoordinatesTransferFactory needs two (different) coordinate transfer factories. The factories have to be provided using the names Coordinates%i, where %i denotes a number between 1 and 9.");
625 std::vector<Teuchos::ParameterEntry> coarseCoordsFactoryNames(numCoordTransferFactories);
627 for (Teuchos::ParameterList::ConstIterator param = transferFactories->begin(); param != transferFactories->end(); ++param) {
628 size_t foundCoords = transferFactories->name(param).find(
"Coordinates");
629 if (foundCoords != std::string::npos && foundCoords == 0 && transferFactories->name(param).length()==12) {
630 int number = atoi(&(transferFactories->name(param).at(11)));
631 TEUCHOS_TEST_FOR_EXCEPTION(number < 1 || number > numCoordTransferFactories,
Exceptions::RuntimeError,
"FactoryFactory::BuildToggleCoordinatesTransfer: Please use the format Coordinates%i with %i an integer between 1 and the maximum number of coordinate transfer factories in ToggleCoordinatesTransferFactory!");
632 coarseCoordsFactoryNames[number-1] = transferFactories->entry(param);
638 for (std::vector<Teuchos::ParameterEntry>::const_iterator it = coarseCoordsFactoryNames.begin(); it != coarseCoordsFactoryNames.end(); ++it) {
639 RCP<const FactoryBase> p =
BuildFactory(*it, factoryMapIn, factoryManagersIn);
640 factory->AddCoordTransferFactory(p);
648 RCP<CoupledAggregationFactory> factory = Build<CoupledAggregationFactory>(paramList, factoryMapIn, factoryManagersIn);
650 if (paramList.isParameter(
"aggregation: ordering"))
651 factory->SetOrdering(paramList.get<std::string>(
"aggregation: ordering"));
653 if (paramList.isParameter(
"aggregation: max selected neighbors"))
654 factory->SetMaxNeighAlreadySelected(paramList.get<
int>(
"aggregation: max selected neighbors"));
656 if (paramList.isParameter(
"Phase3AggCreation"))
657 factory->SetPhase3AggCreation(paramList.get<
double>(
"Phase3AggCreation"));
659 if(paramList.isParameter(
"aggregation: min agg size"))
660 factory->SetMinNodesPerAggregate(paramList.get<
int>(
"aggregation: min agg size"));
676 if (paramList.begin() == paramList.end())
679 TEUCHOS_TEST_FOR_EXCEPTION(paramList.get<std::string>(
"factory") !=
"TrilinosSmoother",
Exceptions::RuntimeError,
"");
684 std::string type=
"";
if(paramList.isParameter(
"type")) type = paramList.get<std::string>(
"type");
685 int overlap=0;
if(paramList.isParameter(
"overlap")) overlap = paramList.get<
int> (
"overlap");
687 Teuchos::ParameterList params;
if(paramList.isParameter(
"ParameterList")) params = paramList.get<Teuchos::ParameterList>(
"ParameterList");
696 Teuchos::RCP<TrilinosSmoother> trilSmoo = Teuchos::rcp(
new TrilinosSmoother(type, params, overlap));
698 if (paramList.isParameter(
"LineDetection_Layers")) {
699 RCP<const FactoryBase> generatingFact =
BuildFactory(paramList.getEntry(
"LineDetection_Layers"), factoryMapIn, factoryManagersIn);
700 trilSmoo->SetFactory(
"LineDetection_Layers", generatingFact);
702 if (paramList.isParameter(
"LineDetection_VertLineIds")) {
703 RCP<const FactoryBase> generatingFact =
BuildFactory(paramList.getEntry(
"LineDetection_Layers"), factoryMapIn, factoryManagersIn);
704 trilSmoo->SetFactory(
"LineDetection_Layers", generatingFact);
706 if (paramList.isParameter(
"CoarseNumZLayers")) {
707 RCP<const FactoryBase> generatingFact =
BuildFactory(paramList.getEntry(
"CoarseNumZLayers"), factoryMapIn, factoryManagersIn);
708 trilSmoo->SetFactory(
"CoarseNumZLayers", generatingFact);
711 RCP<SmootherFactory> smooFact = rcp(
new SmootherFactory(Teuchos::null));
712 Teuchos::ParameterList smooFactParams;
714 smooFact->SetParameterList(smooFactParams);
715 smooFact->SetSmootherPrototypes(trilSmoo);
719#ifdef HAVE_MUELU_MATLAB
732 if (paramList.begin() == paramList.end())
735 TEUCHOS_TEST_FOR_EXCEPTION(paramList.get<std::string>(
"factory") !=
"MatlabSmoother",
Exceptions::RuntimeError,
"");
741 Teuchos::RCP<MatlabSmoother> matSmoo = Teuchos::rcp(
new MatlabSmoother(paramList));
748 if (paramList.begin() == paramList.end())
753 std::string type;
if(paramList.isParameter(
"type")) type = paramList.get<std::string>(
"type");
755 Teuchos::ParameterList params;
if(paramList.isParameter(
"ParameterList")) params = paramList.get<Teuchos::ParameterList>(
"ParameterList");
763 RCP<ParameterList> paramListNonConst = rcp(
new ParameterList(paramList));
766 std::vector<RCP<FactoryManager> > facManagers;
770 bool blockExists =
true;
771 while (blockExists ==
true) {
772 std::stringstream ss;
773 ss <<
"block" << blockid;
775 if(paramList.isSublist(ss.str()) ==
true) {
777 RCP<const ParameterList> b = rcp(
new ParameterList(*sublist(paramListNonConst, ss.str())));
779 RCP<FactoryManager> M = Teuchos::null;
781 if (b->isParameter(
"group")) {
783 std::string facManagerName = b->get< std::string >(
"group");
784 TEUCHOS_TEST_FOR_EXCEPTION(factoryManagersIn.count(facManagerName) != 1,
Exceptions::RuntimeError,
"Factory manager has not been found. Please check the spelling of the factory managers in your xml file.");
785 RCP<FactoryManagerBase> Mb = factoryManagersIn.find(facManagerName)->second;
786 M = Teuchos::rcp_dynamic_cast<FactoryManager>(Mb);
787 TEUCHOS_TEST_FOR_EXCEPTION(M==Teuchos::null,
Exceptions::RuntimeError,
"Failed to cast FactoryManagerBase object to FactoryManager.");
791 for (ParameterList::ConstIterator param = b->begin(); param != b->end(); ++param) {
792 RCP<const FactoryBase> p =
BuildFactory(b->entry(param), factoryMapIn, factoryManagersIn);
793 M->SetFactory(b->name(param),p);
798 M->SetIgnoreUserData(
true);
799 facManagers.push_back(M);
800 paramListNonConst->remove(ss.str());
810 RCP<T> bs = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
818 for (
int i = 0; i<Teuchos::as<int>(facManagers.size()); i++) {
819 bs->AddFactoryManager(facManagers[i],i);
825#ifdef HAVE_MUELU_TEKO
828 RCP<ParameterList> paramListNonConst = rcp(
new ParameterList(paramList));
829 RCP<ParameterList> tekoParams = rcp(
new ParameterList(paramListNonConst->sublist(
"Inverse Factory Library")));
830 paramListNonConst->remove(
"Inverse Factory Library");
833 RCP<TekoSmoother> bs = Build2<TekoSmoother>(*paramListNonConst, factoryMapIn, factoryManagersIn);
842 bs->SetTekoParameters(tekoParams);
866 RCP<T> pfac = Teuchos::null;
869 RCP<ParameterList> paramListNonConst = rcp(
new ParameterList(paramList));
872 std::vector<RCP<FactoryManager> > facManagers;
876 bool blockExists =
true;
877 while (blockExists ==
true) {
878 std::stringstream ss;
879 ss <<
"block" << blockid;
881 if(paramList.isSublist(ss.str()) ==
true) {
883 RCP<const ParameterList> b = rcp(
new ParameterList(*sublist(paramListNonConst, ss.str())));
885 RCP<FactoryManager> M = Teuchos::null;
887 if (b->isParameter(
"group")) {
889 std::string facManagerName = b->get< std::string >(
"group");
890 TEUCHOS_TEST_FOR_EXCEPTION(factoryManagersIn.count(facManagerName) != 1,
Exceptions::RuntimeError,
"Factory manager has not been found. Please check the spelling of the factory managers in your xml file.");
891 RCP<FactoryManagerBase> Mb = factoryManagersIn.find(facManagerName)->second;
892 M = Teuchos::rcp_dynamic_cast<FactoryManager>(Mb);
893 TEUCHOS_TEST_FOR_EXCEPTION(M==Teuchos::null,
Exceptions::RuntimeError,
"Failed to cast FactoryManagerBase object to FactoryManager.");
897 for (ParameterList::ConstIterator param = b->begin(); param != b->end(); ++param) {
898 RCP<const FactoryBase> p =
BuildFactory(b->entry(param), factoryMapIn, factoryManagersIn);
899 M->SetFactory(b->name(param),p);
904 M->SetIgnoreUserData(
true);
905 facManagers.push_back(M);
906 paramListNonConst->remove(ss.str());
916 pfac = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
919 for(
size_t i = 0; i<facManagers.size(); i++) {
920 pfac->AddFactoryManager(facManagers[i]);
929 RCP<T> pfac = Teuchos::null;
932 RCP<ParameterList> paramListNonConst = rcp(
new ParameterList(paramList));
935 std::vector<RCP<const FactoryBase> > facBase;
939 bool blockExists =
true;
940 while (blockExists ==
true) {
941 std::stringstream ss;
942 ss <<
"block" << blockid;
944 if(paramList.isSublist(ss.str()) ==
true) {
946 RCP<const ParameterList> b = rcp(
new ParameterList(*sublist(paramListNonConst, ss.str())));
949 for (ParameterList::ConstIterator param = b->begin(); param != b->end(); ++param) {
950 RCP<const FactoryBase> p =
BuildFactory(b->entry(param), factoryMapIn, factoryManagersIn);
951 facBase.push_back(p);
955 paramListNonConst->remove(ss.str());
965 pfac = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
968 for(
size_t i = 0; i<facBase.size(); i++) {
969 pfac->AddFactory(facBase[i]);
978#define MUELU_FACTORYFACTORY_SHORT
MueLu::DefaultLocalOrdinal LocalOrdinal
MueLu::DefaultScalar Scalar
MueLu::DefaultGlobalOrdinal GlobalOrdinal
Base class for MueLu classes.
direct solver for nxn blocked matrices
Class that encapsulates direct solvers. Autoselection of AmesosSmoother or Amesos2Smoother according ...
Exception throws to report errors in the internal logical of the program.
Factory that can generate other factories from.
RCP< FactoryBase > BuildBlockedDirectSolver(const Teuchos::ParameterList &, const FactoryMap &, const FactoryManagerMap &) const
std::map< std::string, RCP< const FactoryBase > > FactoryMap
std::map< std::string, RCP< FactoryManagerBase > > FactoryManagerMap
RCP< ToggleCoordinatesTransferFactory > BuildToggleCoordinatesTransferFactory(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
RCP< T > BuildBlockedFactory(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
RCP< FactoryBase > BuildBlockedSmoother(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
RCP< FactoryBase > BuildTekoSmoother(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
RCP< FactoryBase > BuildCoupledAggregationFactory(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
CoupledAggregationFactory.
RCP< T > BuildTogglePFactory(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
RCP< T > BuildRAPFactory(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
RCP< T > BuildBlockedCoordFactory(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
RCP< FactoryBase > BuildDirectSolver(const Teuchos::ParameterList ¶mList, const FactoryMap &, const FactoryManagerMap &) const
RCP< T > Build(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
virtual RCP< const FactoryBase > BuildFactory(const Teuchos::ParameterEntry ¶m, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
: Interpret Factory parameter list and build new factory
RCP< T > Build2(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
RCP< FactoryBase > BuildTrilinosSmoother(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
TrilinosSmoother.
RCP< FactoryBase > BuildMatlabSmoother(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
MatlabSmoother.
This class specifies the default factory that should generate some data on a Level if the data does n...
static const RCP< const NoFactory > getRCP()
Static Get() functions.
Generic Smoother Factory for generating the smoothers of the MG hierarchy.
Class that encapsulates external library smoothers.
Namespace for MueLu classes and methods.
KokkosClassic::DefaultNode::DefaultNodeType DefaultNode
Tpetra::Details::DefaultTypes::scalar_type DefaultScalar