46 #ifndef MUELU_FACTORYFACTORY_DECL_HPP
47 #define MUELU_FACTORYFACTORY_DECL_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_CoordinatesTransferFactory.hpp"
92 #include "MueLu_DirectSolver.hpp"
93 #include "MueLu_DropNegativeEntriesFactory.hpp"
94 #include "MueLu_EminPFactory.hpp"
95 #include "MueLu_FilteredAFactory.hpp"
96 #include "MueLu_FineLevelInputDataFactory.hpp"
97 #include "MueLu_GeneralGeometricPFactory.hpp"
98 #include "MueLu_ReplicatePFactory.hpp"
99 #include "MueLu_CombinePFactory.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"
162 #include "MueLu_CoalesceDropFactory_kokkos.hpp"
163 #include "MueLu_GeometricInterpolationPFactory_kokkos.hpp"
164 #ifdef HAVE_MUELU_DEPRECATED_CODE
165 #include "MueLu_NullspaceFactory_kokkos.hpp"
166 #include "MueLu_SaPFactory_kokkos.hpp"
168 #include "MueLu_SemiCoarsenPFactory_kokkos.hpp"
169 #include "MueLu_StructuredAggregationFactory_kokkos.hpp"
170 #include "MueLu_TentativePFactory_kokkos.hpp"
171 #include "MueLu_MatrixFreeTentativePFactory.hpp"
172 #include "MueLu_RegionRFactory_kokkos.hpp"
174 #ifdef HAVE_MUELU_MATLAB
176 #include "../matlab/src/MueLu_SingleLevelMatlabFactory_decl.hpp"
177 #include "../matlab/src/MueLu_SingleLevelMatlabFactory_def.hpp"
178 #include "../matlab/src/MueLu_TwoLevelMatlabFactory_decl.hpp"
179 #include "../matlab/src/MueLu_TwoLevelMatlabFactory_def.hpp"
180 #include "../matlab/src/MueLu_MatlabSmoother_decl.hpp"
181 #include "../matlab/src/MueLu_MatlabSmoother_def.hpp"
184 #ifdef HAVE_MUELU_INTREPID2
185 #include "MueLu_IntrepidPCoarsenFactory.hpp"
201 #undef MUELU_FACTORYFACTORY_SHORT
204 typedef std::map<std::string, RCP<const FactoryBase> >
FactoryMap;
227 std::string factoryName;
230 factoryName = Teuchos::getValue<std::string>(param);
232 paramList = Teuchos::getValue<Teuchos::ParameterList>(param);
233 factoryName = paramList.
get<std::string>(
"factory");
237 if (factoryName ==
"AggregateQualityEstimateFactory")
return Build2<AggregateQualityEstimateFactory>(paramList, factoryMapIn, factoryManagersIn);
238 if (factoryName ==
"AggregationExportFactory")
return Build2<AggregationExportFactory>(paramList, factoryMapIn, factoryManagersIn);
239 if (factoryName ==
"AmalgamationFactory")
return Build2<AmalgamationFactory>(paramList, factoryMapIn, factoryManagersIn);
240 if (factoryName ==
"BlockedCoarseMapFactory")
return Build2<BlockedCoarseMapFactory>(paramList, factoryMapIn, factoryManagersIn);
241 if (factoryName ==
"BlockedRAPFactory")
return BuildRAPFactory<BlockedRAPFactory>(paramList, factoryMapIn, factoryManagersIn);
242 if (factoryName ==
"BrickAggregationFactory")
return Build2<BrickAggregationFactory>(paramList, factoryMapIn, factoryManagersIn);
243 if (factoryName ==
"ClassicalMapFactory")
return Build2<ClassicalMapFactory>(paramList, factoryMapIn, factoryManagersIn);
244 if (factoryName ==
"ClassicalPFactory")
return Build2<ClassicalPFactory>(paramList, factoryMapIn, factoryManagersIn);
245 if (factoryName ==
"CloneRepartitionInterface")
return Build2<CloneRepartitionInterface>(paramList, factoryMapIn, factoryManagersIn);
246 if (factoryName ==
"CoarseMapFactory")
return Build2<CoarseMapFactory>(paramList, factoryMapIn, factoryManagersIn);
247 if (factoryName ==
"CoarseningVisualizationFactory")
return Build2<CoarseningVisualizationFactory>(paramList, factoryMapIn, factoryManagersIn);
248 if (factoryName ==
"CoalesceDropFactory")
return Build2<CoalesceDropFactory>(paramList, factoryMapIn, factoryManagersIn);
249 if (factoryName ==
"SmooVecCoalesceDropFactory")
return Build2<SmooVecCoalesceDropFactory>(paramList, factoryMapIn, factoryManagersIn);
250 if (factoryName ==
"ConstraintFactory")
return Build2<ConstraintFactory>(paramList, factoryMapIn, factoryManagersIn);
251 if (factoryName ==
"CoordinatesTransferFactory")
return Build2<CoordinatesTransferFactory>(paramList, factoryMapIn, factoryManagersIn);
252 if (factoryName ==
"DirectSolver")
return BuildDirectSolver(paramList, factoryMapIn, factoryManagersIn);
253 if (factoryName ==
"DropNegativeEntriesFactory")
return Build2<DropNegativeEntriesFactory>(paramList, factoryMapIn, factoryManagersIn);
254 if (factoryName ==
"EminPFactory")
return Build2<EminPFactory>(paramList, factoryMapIn, factoryManagersIn);
255 if (factoryName ==
"FilteredAFactory")
return Build2<FilteredAFactory>(paramList, factoryMapIn, factoryManagersIn);
256 if (factoryName ==
"FineLevelInputDataFactory")
return Build2<FineLevelInputDataFactory>(paramList, factoryMapIn, factoryManagersIn);
257 if (factoryName ==
"GeneralGeometricPFactory")
return Build2<GeneralGeometricPFactory>(paramList, factoryMapIn, factoryManagersIn);
258 if (factoryName ==
"ReplicatePFactory")
return Build2<ReplicatePFactory>(paramList, factoryMapIn, factoryManagersIn);
259 if (factoryName ==
"CombinePFactory")
return Build2<CombinePFactory>(paramList, factoryMapIn, factoryManagersIn);
260 if (factoryName ==
"GenericRFactory")
return Build2<GenericRFactory>(paramList, factoryMapIn, factoryManagersIn);
261 if (factoryName ==
"GeometricInterpolationPFactory")
return Build2<GeometricInterpolationPFactory>(paramList, factoryMapIn, factoryManagersIn);
262 if (factoryName ==
"HybridAggregationFactory")
return Build2<HybridAggregationFactory>(paramList, factoryMapIn, factoryManagersIn);
263 if (factoryName ==
"InterfaceAggregationFactory")
return Build2<InterfaceAggregationFactory>(paramList, factoryMapIn, factoryManagersIn);
264 if (factoryName ==
"InterfaceMappingTransferFactory")
return Build2<InterfaceMappingTransferFactory>(paramList, factoryMapIn, factoryManagersIn);
265 if (factoryName ==
"InverseApproximationFactory")
return Build2<InverseApproximationFactory>(paramList, factoryMapIn, factoryManagersIn);
266 if (factoryName ==
"InitialBlockNumberFactory")
return Build2<InitialBlockNumberFactory>(paramList, factoryMapIn, factoryManagersIn);
267 if (factoryName ==
"LineDetectionFactory")
return Build2<LineDetectionFactory>(paramList, factoryMapIn, factoryManagersIn);
270 if (factoryName ==
"MapTransferFactory")
return Build2<MapTransferFactory>(paramList, factoryMapIn, factoryManagersIn);
271 if (factoryName ==
"MatrixAnalysisFactory")
return Build2<MatrixAnalysisFactory>(paramList, factoryMapIn, factoryManagersIn);
272 if (factoryName ==
"MultiVectorTransferFactory")
return Build2<MultiVectorTransferFactory>(paramList, factoryMapIn, factoryManagersIn);
275 if (factoryName ==
"NotayAggregationFactory")
return Build2<NotayAggregationFactory>(paramList, factoryMapIn, factoryManagersIn);
276 if (factoryName ==
"NullspaceFactory")
return Build2<NullspaceFactory>(paramList, factoryMapIn, factoryManagersIn);
277 if (factoryName ==
"NullspacePresmoothFactory")
return Build2<NullspacePresmoothFactory>(paramList, factoryMapIn, factoryManagersIn);
278 if (factoryName ==
"PatternFactory")
return Build2<PatternFactory>(paramList, factoryMapIn, factoryManagersIn);
279 if (factoryName ==
"PgPFactory")
return Build2<PgPFactory>(paramList, factoryMapIn, factoryManagersIn);
280 if (factoryName ==
"SaPFactory")
return Build2<SaPFactory>(paramList, factoryMapIn, factoryManagersIn);
281 if (factoryName ==
"RAPFactory")
return BuildRAPFactory<RAPFactory>(paramList, factoryMapIn, factoryManagersIn);
282 if (factoryName ==
"RAPShiftFactory")
return BuildRAPFactory<RAPShiftFactory>(paramList, factoryMapIn, factoryManagersIn);
283 if (factoryName ==
"RebalanceAcFactory")
return Build2<RebalanceAcFactory>(paramList, factoryMapIn, factoryManagersIn);
284 if (factoryName ==
"RebalanceTransferFactory")
return Build2<RebalanceTransferFactory>(paramList, factoryMapIn, factoryManagersIn);
285 if (factoryName ==
"RegionRFactory")
return Build2<RegionRFactory>(paramList, factoryMapIn, factoryManagersIn);
286 if (factoryName ==
"RegionRFactory_kokkos")
return Build2<RegionRFactory_kokkos>(paramList, factoryMapIn, factoryManagersIn);
287 if (factoryName ==
"ReorderBlockAFactory")
return Build2<ReorderBlockAFactory>(paramList, factoryMapIn, factoryManagersIn);
288 if (factoryName ==
"RepartitionInterface")
return Build2<RepartitionInterface>(paramList, factoryMapIn, factoryManagersIn);
289 if (factoryName ==
"ScaledNullspaceFactory")
return Build2<ScaledNullspaceFactory>(paramList, factoryMapIn, factoryManagersIn);
290 if (factoryName ==
"SegregatedAFactory")
return Build2<SegregatedAFactory>(paramList, factoryMapIn, factoryManagersIn);
291 if (factoryName ==
"SemiCoarsenPFactory")
return Build2<SemiCoarsenPFactory>(paramList, factoryMapIn, factoryManagersIn);
292 if (factoryName ==
"StructuredAggregationFactory")
return Build2<StructuredAggregationFactory>(paramList, factoryMapIn, factoryManagersIn);
293 if (factoryName ==
"StructuredLineDetectionFactory")
return Build2<StructuredLineDetectionFactory>(paramList, factoryMapIn, factoryManagersIn);
294 if (factoryName ==
"SubBlockAFactory")
return Build2<SubBlockAFactory>(paramList, factoryMapIn, factoryManagersIn);
295 if (factoryName ==
"TentativePFactory")
return Build2<TentativePFactory>(paramList, factoryMapIn, factoryManagersIn);
297 if (factoryName ==
"TogglePFactory")
return BuildTogglePFactory<TogglePFactory>(paramList, factoryMapIn, factoryManagersIn);
298 if (factoryName ==
"TransPFactory")
return Build2<TransPFactory>(paramList, factoryMapIn, factoryManagersIn);
299 if (factoryName ==
"RfromP_Or_TransP")
return Build2<RfromP_Or_TransP>(paramList, factoryMapIn, factoryManagersIn);
300 if (factoryName ==
"TrilinosSmoother")
return BuildTrilinosSmoother(paramList, factoryMapIn, factoryManagersIn);
301 if (factoryName ==
"UncoupledAggregationFactory")
return Build2<UncoupledAggregationFactory>(paramList, factoryMapIn, factoryManagersIn);
302 if (factoryName ==
"UnsmooshFactory")
return Build2<UnsmooshFactory>(paramList, factoryMapIn, factoryManagersIn);
303 if (factoryName ==
"UserAggregationFactory")
return Build2<UserAggregationFactory>(paramList, factoryMapIn, factoryManagersIn);
304 if (factoryName ==
"UserPFactory")
return Build2<UserPFactory>(paramList, factoryMapIn, factoryManagersIn);
305 if (factoryName ==
"VariableDofLaplacianFactory")
return Build2<VariableDofLaplacianFactory>(paramList, factoryMapIn, factoryManagersIn);
306 if (factoryName ==
"ZeroSubBlockAFactory")
return Build2<ZeroSubBlockAFactory>(paramList, factoryMapIn, factoryManagersIn);
307 if (factoryName ==
"CoalesceDropFactory_kokkos")
return Build2<CoalesceDropFactory_kokkos>(paramList, factoryMapIn, factoryManagersIn);
308 if (factoryName ==
"GeometricInterpolationPFactory_kokkos")
return Build2<GeometricInterpolationPFactory_kokkos>(paramList, factoryMapIn, factoryManagersIn);
309 #ifdef HAVE_MUELU_DEPRECATED_CODE
310 if (factoryName ==
"NullspaceFactory_kokkos")
return Build2<NullspaceFactory_kokkos>(paramList, factoryMapIn, factoryManagersIn);
311 if (factoryName ==
"SaPFactory_kokkos")
return Build2<SaPFactory_kokkos>(paramList, factoryMapIn, factoryManagersIn);
313 if (factoryName ==
"SemiCoarsenPFactory_kokkos")
return Build2<SemiCoarsenPFactory_kokkos>(paramList, factoryMapIn, factoryManagersIn);
314 if (factoryName ==
"StructuredAggregationFactory_kokkos")
return Build2<StructuredAggregationFactory_kokkos>(paramList, factoryMapIn, factoryManagersIn);
315 if (factoryName ==
"TentativePFactory_kokkos")
return Build2<TentativePFactory_kokkos>(paramList, factoryMapIn, factoryManagersIn);
316 if (factoryName ==
"MatrixFreeTentativePFactory")
return Build2<MatrixFreeTentativePFactory>(paramList, factoryMapIn, factoryManagersIn);
319 if (factoryName ==
"CoarseMapFactory_kokkos")
return Build2<CoarseMapFactory>(paramList, factoryMapIn, factoryManagersIn);
320 if (factoryName ==
"CoordinatesTransferFactory_kokkos")
return Build2<CoordinatesTransferFactory>(paramList, factoryMapIn, factoryManagersIn);
322 if (factoryName ==
"ZoltanInterface") {
323 #if defined(HAVE_MUELU_ZOLTAN) && defined(HAVE_MPI)
324 return Build2<ZoltanInterface>(paramList, factoryMapIn, factoryManagersIn);
327 #endif // HAVE_MUELU_ZOLTAN && HAVE_MPI
329 if (factoryName ==
"Zoltan2Interface") {
330 #if defined(HAVE_MUELU_ZOLTAN2) && defined(HAVE_MPI)
331 return Build2<Zoltan2Interface>(paramList, factoryMapIn, factoryManagersIn);
334 #endif // HAVE_MUELU_ZOLTAN2 && HAVE_MPI
336 if (factoryName ==
"IsorropiaInterface") {
337 #if defined(HAVE_MUELU_ISORROPIA) && defined(HAVE_MPI)
338 return Build2<IsorropiaInterface>(paramList, factoryMapIn, factoryManagersIn);
341 #endif // HAVE_MUELU_ZOLTAN2 && HAVE_MPI
344 if (factoryName ==
"NodePartitionInterface") {
345 #if defined(HAVE_MPI)
346 return Build2<NodePartitionInterface>(paramList, factoryMapIn, factoryManagersIn);
352 if (factoryName ==
"RepartitionFactory") {
354 return Build2<RepartitionFactory>(paramList, factoryMapIn, factoryManagersIn);
359 if (factoryName ==
"RepartitionHeuristicFactory") {
361 return Build2<RepartitionHeuristicFactory>(paramList, factoryMapIn, factoryManagersIn);
367 if (factoryName ==
"BlockedCoordinatesTransferFactory")
return BuildBlockedCoordFactory<BlockedCoordinatesTransferFactory>(paramList, factoryMapIn, factoryManagersIn);
368 if (factoryName ==
"BlockedDirectSolver")
return BuildBlockedDirectSolver(paramList, factoryMapIn, factoryManagersIn);
369 if (factoryName ==
"BlockedGaussSeidelSmoother")
return BuildBlockedSmoother<BlockedGaussSeidelSmoother>(paramList, factoryMapIn, factoryManagersIn);
370 if (factoryName ==
"BlockedJacobiSmoother")
return BuildBlockedSmoother<BlockedJacobiSmoother>(paramList, factoryMapIn, factoryManagersIn);
371 if (factoryName ==
"BlockedPFactory")
return BuildBlockedFactory<BlockedPFactory>(paramList, factoryMapIn, factoryManagersIn);
372 if (factoryName ==
"BraessSarazinSmoother")
return BuildBlockedSmoother<BraessSarazinSmoother>(paramList, factoryMapIn, factoryManagersIn);
373 if (factoryName ==
"IndefiniteBlockDiagonalSmoother")
return BuildBlockedSmoother<IndefBlockedDiagonalSmoother>(paramList, factoryMapIn, factoryManagersIn);
374 if (factoryName ==
"SimpleSmoother")
return BuildBlockedSmoother<SimpleSmoother>(paramList, factoryMapIn, factoryManagersIn);
375 if (factoryName ==
"SchurComplementFactory")
return Build2<SchurComplementFactory>(paramList, factoryMapIn, factoryManagersIn);
376 if (factoryName ==
"RebalanceBlockRestrictionFactory")
return BuildBlockedFactory<RebalanceBlockRestrictionFactory>(paramList, factoryMapIn, factoryManagersIn);
377 if (factoryName ==
"RebalanceBlockAcFactory")
return BuildBlockedFactory<RebalanceBlockAcFactory>(paramList, factoryMapIn, factoryManagersIn);
378 if (factoryName ==
"RebalanceBlockInterpolationFactory")
return BuildBlockedFactory<RebalanceBlockInterpolationFactory>(paramList, factoryMapIn, factoryManagersIn);
380 if (factoryName ==
"RepartitionBlockDiagonalFactory")
return Build2<RepartitionBlockDiagonalFactory>(paramList, factoryMapIn, factoryManagersIn);
382 #ifdef HAVE_MUELU_TEKO
383 if (factoryName ==
"TekoSmoother")
return BuildTekoSmoother(paramList, factoryMapIn, factoryManagersIn);
385 if (factoryName ==
"UzawaSmoother")
return BuildBlockedSmoother<UzawaSmoother>(paramList, factoryMapIn, factoryManagersIn);
388 #ifdef HAVE_MUELU_MATLAB
389 if (factoryName ==
"TwoLevelMatlabFactory")
return Build2<TwoLevelMatlabFactory>(paramList, factoryMapIn, factoryManagersIn);
390 if (factoryName ==
"SingleLevelMatlabFactory")
return Build2<SingleLevelMatlabFactory>(paramList, factoryMapIn, factoryManagersIn);
391 if (factoryName ==
"MatlabSmoother")
return BuildMatlabSmoother(paramList, factoryMapIn, factoryManagersIn);
394 #ifdef HAVE_MUELU_INTREPID2
395 if (factoryName ==
"IntrepidPCoarsenFactory")
return Build2<IntrepidPCoarsenFactory>(paramList, factoryMapIn, factoryManagersIn);
399 if (factoryMapIn.find(factoryName) != factoryMapIn.end()) {
401 "MueLu::FactoryFactory: Error during the parsing of: " << std::endl
402 << paramList << std::endl
403 <<
"'" << factoryName <<
"' is not a factory name but an existing instance of a factory." << std::endl
404 <<
"Extra parameters cannot be specified after the creation of the object." << 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);
411 return factoryMapIn.find(factoryName)->second;
429 #define arraysize(ar) (sizeof(ar) / sizeof(ar[0]))
435 const char* strarray[] = {
"A",
"P",
"R",
"Graph",
"UnAmalgamationInfo",
"Aggregates",
"Nullspace",
"TransferFactory",
"DofsPerNode"};
436 std::vector<std::string> v(strarray, strarray +
arraysize(strarray));
437 for (
size_t i = 0; i < v.size(); ++i)
439 factory->SetFactory(v[i],
BuildFactory(paramList.
getEntry(v[i]), factoryMapIn, factoryManagersIn));
454 const std::string& pName = validParamList->name(param);
464 paramListWithFactories.
set(pName, generatingFact);
466 if (pName ==
"ParameterList") {
472 paramListWithFactories.
set(pName, subList);
480 factory->SetParameterList(paramListWithFactories);
488 if (paramList.
isSublist(
"TransferFactories") ==
false) {
489 factory = Build2<T>(paramList, factoryMapIn, factoryManagersIn);
495 paramListNonConst->
remove(
"TransferFactories");
497 factory = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
501 factory->AddTransferFactory(p);
511 if (paramList.
isSublist(
"TransferFactories") ==
false) {
513 factory = Build2<T>(paramList, factoryMapIn, factoryManagersIn);
519 paramListNonConst->
remove(
"TransferFactories");
522 factory = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
526 int numProlongatorFactories = 0;
527 int numPtentFactories = 0;
528 int numCoarseNspFactories = 0;
530 size_t foundNsp = transferFactories->
name(param).find(
"Nullspace");
531 if (foundNsp != std::string::npos && foundNsp == 0 && transferFactories->
name(param).length() == 10) {
532 numCoarseNspFactories++;
535 size_t foundPtent = transferFactories->
name(param).find(
"Ptent");
536 if (foundPtent != std::string::npos && foundPtent == 0 && transferFactories->
name(param).length() == 6) {
540 size_t foundP = transferFactories->
name(param).find(
"P");
541 if (foundP != std::string::npos && foundP == 0 && transferFactories->
name(param).length() == 2) {
542 numProlongatorFactories++;
548 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.");
551 std::vector<Teuchos::ParameterEntry> prolongatorFactoryNames(numProlongatorFactories);
552 std::vector<Teuchos::ParameterEntry> coarseNspFactoryNames(numProlongatorFactories);
553 std::vector<Teuchos::ParameterEntry> ptentFactoryNames(numProlongatorFactories);
556 size_t foundNsp = transferFactories->
name(param).find(
"Nullspace");
557 if (foundNsp != std::string::npos && foundNsp == 0 && transferFactories->
name(param).length() == 10) {
558 int number = atoi(&(transferFactories->
name(param).at(9)));
559 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!");
560 coarseNspFactoryNames[number - 1] = transferFactories->
entry(param);
563 size_t foundPtent = transferFactories->
name(param).find(
"Ptent");
564 if (foundPtent != std::string::npos && foundPtent == 0 && transferFactories->
name(param).length() == 6) {
565 int number = atoi(&(transferFactories->
name(param).at(5)));
566 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!");
567 ptentFactoryNames[number - 1] = transferFactories->
entry(param);
570 size_t foundP = transferFactories->
name(param).find(
"P");
571 if (foundP != std::string::npos && foundP == 0 && transferFactories->
name(param).length() == 2) {
572 int number = atoi(&(transferFactories->
name(param).at(1)));
573 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!");
574 prolongatorFactoryNames[number - 1] = transferFactories->
entry(param);
580 for (std::vector<Teuchos::ParameterEntry>::const_iterator it = prolongatorFactoryNames.begin(); it != prolongatorFactoryNames.end(); ++it) {
582 factory->AddProlongatorFactory(p);
586 for (std::vector<Teuchos::ParameterEntry>::const_iterator it = ptentFactoryNames.begin(); it != ptentFactoryNames.end(); ++it) {
588 factory->AddPtentFactory(p);
592 for (std::vector<Teuchos::ParameterEntry>::const_iterator it = coarseNspFactoryNames.begin(); it != coarseNspFactoryNames.end(); ++it) {
594 factory->AddCoarseNullspaceFactory(p);
602 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!");
606 paramListNonConst->remove(
"TransferFactories");
609 factory = Build2<ToggleCoordinatesTransferFactory>(*paramListNonConst, factoryMapIn, factoryManagersIn);
613 int numCoordTransferFactories = 0;
615 size_t foundCoordinates = transferFactories->
name(param).find(
"Coordinates");
616 if (foundCoordinates != std::string::npos && foundCoordinates == 0 && transferFactories->
name(param).length() == 12) {
617 numCoordTransferFactories++;
621 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.");
624 std::vector<Teuchos::ParameterEntry> coarseCoordsFactoryNames(numCoordTransferFactories);
627 size_t foundCoords = transferFactories->
name(param).find(
"Coordinates");
628 if (foundCoords != std::string::npos && foundCoords == 0 && transferFactories->
name(param).length() == 12) {
629 int number = atoi(&(transferFactories->
name(param).at(11)));
630 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!");
631 coarseCoordsFactoryNames[number - 1] = transferFactories->
entry(param);
637 for (std::vector<Teuchos::ParameterEntry>::const_iterator it = coarseCoordsFactoryNames.begin(); it != coarseCoordsFactoryNames.end(); ++it) {
639 factory->AddCoordTransferFactory(p);
656 if (paramList.
begin() == paramList.
end())
664 std::string type =
"";
665 if (paramList.
isParameter(
"type")) type = paramList.
get<std::string>(
"type");
667 if (paramList.
isParameter(
"overlap")) overlap = paramList.
get<
int>(
"overlap");
681 if (paramList.
isParameter(
"LineDetection_Layers")) {
683 trilSmoo->SetFactory(
"LineDetection_Layers", generatingFact);
685 if (paramList.
isParameter(
"LineDetection_VertLineIds")) {
687 trilSmoo->SetFactory(
"LineDetection_Layers", generatingFact);
691 trilSmoo->SetFactory(
"CoarseNumZLayers", generatingFact);
697 smooFact->SetParameterList(smooFactParams);
698 smooFact->SetSmootherPrototypes(trilSmoo);
702 #ifdef HAVE_MUELU_MATLAB
715 if (paramList.
begin() == paramList.
end())
731 if (paramList.
begin() == paramList.
end())
737 if (paramList.
isParameter(
"type")) type = paramList.
get<std::string>(
"type");
751 std::vector<RCP<FactoryManager> > facManagers;
755 bool blockExists =
true;
756 while (blockExists ==
true) {
757 std::stringstream ss;
758 ss <<
"block" << blockid;
760 if (paramList.
isSublist(ss.str()) ==
true) {
766 if (b->isParameter(
"group")) {
768 std::string facManagerName = b->
get<std::string>(
"group");
778 M->SetFactory(b->name(param), p);
783 M->SetIgnoreUserData(
true);
784 facManagers.push_back(M);
785 paramListNonConst->remove(ss.str());
794 RCP<T> bs = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
802 for (
int i = 0; i < Teuchos::as<int>(facManagers.size()); i++) {
803 bs->AddFactoryManager(facManagers[i], i);
809 #ifdef HAVE_MUELU_TEKO
814 paramListNonConst->remove(
"Inverse Factory Library");
817 RCP<TekoSmoother> bs = Build2<TekoSmoother>(*paramListNonConst, factoryMapIn, factoryManagersIn);
826 bs->SetTekoParameters(tekoParams);
839 if (paramList.
isParameter(
"type")) type = paramList.
get<std::string>(
"type");
852 RCP<T> pfac = Teuchos::null;
858 std::vector<RCP<FactoryManager> > facManagers;
862 bool blockExists =
true;
863 while (blockExists ==
true) {
864 std::stringstream ss;
865 ss <<
"block" << blockid;
867 if (paramList.
isSublist(ss.str()) ==
true) {
873 if (b->isParameter(
"group")) {
875 std::string facManagerName = b->
get<std::string>(
"group");
885 M->SetFactory(b->name(param), p);
890 M->SetIgnoreUserData(
true);
891 facManagers.push_back(M);
892 paramListNonConst->remove(ss.str());
901 pfac = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
904 for (
size_t i = 0; i < facManagers.size(); i++) {
905 pfac->AddFactoryManager(facManagers[i]);
913 RCP<T> pfac = Teuchos::null;
919 std::vector<RCP<const FactoryBase> > facBase;
923 bool blockExists =
true;
924 while (blockExists ==
true) {
925 std::stringstream ss;
926 ss <<
"block" << blockid;
928 if (paramList.
isSublist(ss.str()) ==
true) {
935 facBase.push_back(p);
939 paramListNonConst->remove(ss.str());
948 pfac = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
951 for (
size_t i = 0; i < facBase.size(); i++) {
952 pfac->AddFactory(facBase[i]);
961 #define MUELU_FACTORYFACTORY_SHORT
962 #endif // MUELU_FACTORYFACTORY_DECL_HPP
Generic Smoother Factory for generating the smoothers of the MG hierarchy.
RCP< FactoryBase > BuildDirectSolver(const Teuchos::ParameterList ¶mList, const FactoryMap &, const FactoryManagerMap &) const
const std::string & name() const
This class specifies the default factory that should generate some data on a Level if the data does n...
RCP< T > Build(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
ParameterList & setEntry(const std::string &name, U &&entry)
ConstIterator end() const
RCP< FactoryBase > BuildTekoSmoother(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
MueLu::DefaultLocalOrdinal LocalOrdinal
Tpetra::KokkosClassic::DefaultNode::DefaultNodeType DefaultNode
Factory that can generate other factories from.
T & get(const std::string &name, T def_value)
RCP< T > Build2(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
Class that encapsulates external library smoothers.
ParameterList & set(std::string const &name, T const &value, std::string const &docString="", RCP< const ParameterEntryValidator > const &validator=null)
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
RCP< ToggleCoordinatesTransferFactory > BuildToggleCoordinatesTransferFactory(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
Ordinal numParams() const
RCP< FactoryBase > BuildMatlabSmoother(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
MatlabSmoother.
virtual RCP< const FactoryBase > BuildFactory(const Teuchos::ParameterEntry ¶m, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
: Interpret Factory parameter list and build new factory
Class that encapsulates direct solvers. Autoselection of AmesosSmoother or Amesos2Smoother according ...
RCP< T > BuildTogglePFactory(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
bool isParameter(const std::string &name) const
std::map< std::string, RCP< FactoryManagerBase > > FactoryManagerMap
bool remove(std::string const &name, bool throwIfNotExists=true)
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
MueLu::DefaultScalar Scalar
Tpetra::Details::DefaultTypes::scalar_type DefaultScalar
MueLu::DefaultGlobalOrdinal GlobalOrdinal
std::map< std::string, RCP< const FactoryBase > > FactoryMap
bool isSublist(const std::string &name) const
RCP< T > BuildBlockedFactory(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
params_t::ConstIterator ConstIterator
RCP< FactoryBase > BuildBlockedDirectSolver(const Teuchos::ParameterList ¶mList, const FactoryMap &, const FactoryManagerMap &) const
ConstIterator begin() const
RCP< FactoryBase > BuildTrilinosSmoother(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
TrilinosSmoother.
RCP< T > BuildRAPFactory(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
direct solver for nxn blocked matrices
const ParameterEntry & entry(ConstIterator i) const
Base class for MueLu classes.
Class that encapsulates Matlab smoothers.
#define TEUCHOS_UNREACHABLE_RETURN(dummyReturnVal)
RCP< T > BuildBlockedCoordFactory(const Teuchos::ParameterList ¶mList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
Exception throws to report errors in the internal logical of the program.
ParameterEntry & getEntry(const std::string &name)
static const RCP< const NoFactory > getRCP()
Static Get() functions.