MueLu Version of the Day
Loading...
Searching...
No Matches
MueLu_FactoryFactory_decl.hpp
Go to the documentation of this file.
1// @HEADER
2//
3// ***********************************************************************
4//
5// MueLu: A package for multigrid based preconditioning
6// Copyright 2012 Sandia Corporation
7//
8// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9// the U.S. Government retains certain rights in this software.
10//
11// Redistribution and use in source and binary forms, with or without
12// modification, are permitted provided that the following conditions are
13// met:
14//
15// 1. Redistributions of source code must retain the above copyright
16// notice, this list of conditions and the following disclaimer.
17//
18// 2. Redistributions in binary form must reproduce the above copyright
19// notice, this list of conditions and the following disclaimer in the
20// documentation and/or other materials provided with the distribution.
21//
22// 3. Neither the name of the Corporation nor the names of the
23// contributors may be used to endorse or promote products derived from
24// this software without specific prior written permission.
25//
26// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37//
38// Questions? Contact
39// Jonathan Hu (jhu@sandia.gov)
40// Andrey Prokopenko (aprokop@sandia.gov)
41// Ray Tuminaro (rstumin@sandia.gov)
42//
43// ***********************************************************************
44//
45// @HEADER
46#ifndef MUELU_FACTORYFACTORY_DECL_HPP
47#define MUELU_FACTORYFACTORY_DECL_HPP
48
49#include <string>
50#include <vector>
51
52#include <Teuchos_ParameterEntry.hpp>
53#include <Teuchos_Array.hpp>
54
55#include "MueLu_ConfigDefs.hpp"
56#include "MueLu_FactoryFactory_fwd.hpp"
57
58#include "MueLu_HierarchyFactory.hpp"
59
60#include "MueLu_FactoryBase.hpp"
61#include "MueLu_FactoryManager.hpp"
62#include "MueLu_FactoryManagerBase_fwd.hpp"
63#include "MueLu_FactoryManager_fwd.hpp"
64#include "MueLu_FactoryBase_fwd.hpp"
65#include "MueLu_Hierarchy_fwd.hpp"
66
67#include "MueLu_Monitor.hpp"
68#include "MueLu_Exceptions.hpp"
69
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"
143#endif
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"
161
162
163#include "MueLu_CoalesceDropFactory_kokkos.hpp"
164#include "MueLu_GeometricInterpolationPFactory_kokkos.hpp"
165#include "MueLu_NullspaceFactory_kokkos.hpp"
166#include "MueLu_SaPFactory_kokkos.hpp"
167#include "MueLu_SemiCoarsenPFactory_kokkos.hpp"
168#include "MueLu_StructuredAggregationFactory_kokkos.hpp"
169#include "MueLu_TentativePFactory_kokkos.hpp"
170#include "MueLu_MatrixFreeTentativePFactory.hpp"
171#include "MueLu_UncoupledAggregationFactory_kokkos.hpp"
172#include "MueLu_RegionRFactory_kokkos.hpp"
173
174#ifdef HAVE_MUELU_MATLAB
175// This is distasteful, but (sadly) neccesary due to peculiarities in MueLu's build system.
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"
182#endif
183
184#ifdef HAVE_MUELU_INTREPID2
185#include "MueLu_IntrepidPCoarsenFactory.hpp"
186#endif
187
188namespace MueLu {
189
196 template <class Scalar = DefaultScalar,
197 class LocalOrdinal = DefaultLocalOrdinal,
198 class GlobalOrdinal = DefaultGlobalOrdinal,
199 class Node = DefaultNode>
200 class FactoryFactory : public BaseClass {
201#undef MUELU_FACTORYFACTORY_SHORT
202#include "MueLu_UseShortNames.hpp"
203
204 typedef std::map<std::string, RCP<const FactoryBase> > FactoryMap; // TODO: remove
205 typedef std::map<std::string, RCP<FactoryManagerBase> > FactoryManagerMap;
206
207 public:
208
226 virtual RCP<const FactoryBase> BuildFactory(const Teuchos::ParameterEntry& param, const FactoryMap& factoryMapIn, const FactoryManagerMap& factoryManagersIn) const {
227 // Find factory
228 std::string factoryName;
229 Teuchos::ParameterList paramList;
230 if (!param.isList()) {
231 factoryName = Teuchos::getValue<std::string>(param);
232 } else {
233 paramList = Teuchos::getValue<Teuchos::ParameterList>(param);
234 factoryName = paramList.get<std::string>("factory");
235 }
236
237 // TODO: see how Teko handles this (=> register factories).
238 if (factoryName == "AggregateQualityEstimateFactory") return Build2<AggregateQualityEstimateFactory> (paramList, factoryMapIn, factoryManagersIn);
239 if (factoryName == "AggregationExportFactory") return Build2<AggregationExportFactory> (paramList, factoryMapIn, factoryManagersIn);
240 if (factoryName == "AmalgamationFactory") return Build2<AmalgamationFactory> (paramList, factoryMapIn, factoryManagersIn);
241 if (factoryName == "BlockedCoarseMapFactory") return Build2<BlockedCoarseMapFactory> (paramList, factoryMapIn, factoryManagersIn);
242 if (factoryName == "BlockedRAPFactory") return BuildRAPFactory<BlockedRAPFactory> (paramList, factoryMapIn, factoryManagersIn);
243 if (factoryName == "BrickAggregationFactory") return Build2<BrickAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
244 if (factoryName == "ClassicalMapFactory") return Build2<ClassicalMapFactory> (paramList, factoryMapIn, factoryManagersIn);
245 if (factoryName == "ClassicalPFactory") return Build2<ClassicalPFactory> (paramList, factoryMapIn, factoryManagersIn);
246 if (factoryName == "CloneRepartitionInterface") return Build2<CloneRepartitionInterface> (paramList, factoryMapIn, factoryManagersIn);
247 if (factoryName == "CoarseMapFactory") return Build2<CoarseMapFactory> (paramList, factoryMapIn, factoryManagersIn);
248 if (factoryName == "CoarseningVisualizationFactory") return Build2<CoarseningVisualizationFactory> (paramList, factoryMapIn, factoryManagersIn);
249 if (factoryName == "CoalesceDropFactory") return Build2<CoalesceDropFactory> (paramList, factoryMapIn, factoryManagersIn);
250 if (factoryName == "SmooVecCoalesceDropFactory") return Build2<SmooVecCoalesceDropFactory> (paramList, factoryMapIn, factoryManagersIn);
251 if (factoryName == "ConstraintFactory") return Build2<ConstraintFactory> (paramList, factoryMapIn, factoryManagersIn);
252 if (factoryName == "CoordinatesTransferFactory") return Build2<CoordinatesTransferFactory> (paramList, factoryMapIn, factoryManagersIn);
253 if (factoryName == "DirectSolver") return BuildDirectSolver (paramList, factoryMapIn, factoryManagersIn);
254 if (factoryName == "DropNegativeEntriesFactory") return Build2<DropNegativeEntriesFactory> (paramList, factoryMapIn, factoryManagersIn);
255 if (factoryName == "EminPFactory") return Build2<EminPFactory> (paramList, factoryMapIn, factoryManagersIn);
256 if (factoryName == "FilteredAFactory") return Build2<FilteredAFactory> (paramList, factoryMapIn, factoryManagersIn);
257 if (factoryName == "FineLevelInputDataFactory") return Build2<FineLevelInputDataFactory> (paramList, factoryMapIn, factoryManagersIn);
258 if (factoryName == "GeneralGeometricPFactory") return Build2<GeneralGeometricPFactory> (paramList, factoryMapIn, factoryManagersIn);
259 if (factoryName == "ReplicatePFactory") return Build2<ReplicatePFactory> (paramList, factoryMapIn, factoryManagersIn);
260 if (factoryName == "CombinePFactory") return Build2<CombinePFactory> (paramList, factoryMapIn, factoryManagersIn);
261 if (factoryName == "GenericRFactory") return Build2<GenericRFactory> (paramList, factoryMapIn, factoryManagersIn);
262 if (factoryName == "GeometricInterpolationPFactory") return Build2<GeometricInterpolationPFactory> (paramList, factoryMapIn, factoryManagersIn);
263 if (factoryName == "HybridAggregationFactory") return Build2<HybridAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
264 if (factoryName == "InterfaceAggregationFactory") return Build2<InterfaceAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
265 if (factoryName == "InterfaceMappingTransferFactory") return Build2<InterfaceMappingTransferFactory> (paramList, factoryMapIn, factoryManagersIn);
266 if (factoryName == "InverseApproximationFactory") return Build2<InverseApproximationFactory> (paramList, factoryMapIn, factoryManagersIn);
267 if (factoryName == "InitialBlockNumberFactory") return Build2<InitialBlockNumberFactory> (paramList, factoryMapIn, factoryManagersIn);
268 if (factoryName == "LineDetectionFactory") return Build2<LineDetectionFactory> (paramList, factoryMapIn, factoryManagersIn);
269 // LocalOrdinalTransferFactory is a utility factory that can be used for multiple things, so there is no default
270 // if (factoryName == "LocalOrdinalTransferFactory") return Build2<LocalOrdinalTransferFactory> (paramList, factoryMapIn, factoryManagersIn);
271 if (factoryName == "MapTransferFactory") return Build2<MapTransferFactory> (paramList, factoryMapIn, factoryManagersIn);
272 if (factoryName == "MatrixAnalysisFactory") return Build2<MatrixAnalysisFactory> (paramList, factoryMapIn, factoryManagersIn);
273 if (factoryName == "MultiVectorTransferFactory") return Build2<MultiVectorTransferFactory> (paramList, factoryMapIn, factoryManagersIn);
274 if (factoryName == "NoFactory") return MueLu::NoFactory::getRCP();
275 if (factoryName == "NoSmoother") return rcp(new SmootherFactory(Teuchos::null));
276 if (factoryName == "NotayAggregationFactory") return Build2<NotayAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
277 if (factoryName == "NullspaceFactory") return Build2<NullspaceFactory> (paramList, factoryMapIn, factoryManagersIn);
278 if (factoryName == "NullspacePresmoothFactory") return Build2<NullspacePresmoothFactory> (paramList, factoryMapIn, factoryManagersIn);
279 if (factoryName == "PatternFactory") return Build2<PatternFactory> (paramList, factoryMapIn, factoryManagersIn);
280 if (factoryName == "PgPFactory") return Build2<PgPFactory> (paramList, factoryMapIn, factoryManagersIn);
281 if (factoryName == "SaPFactory") return Build2<SaPFactory> (paramList, factoryMapIn, factoryManagersIn);
282 if (factoryName == "RAPFactory") return BuildRAPFactory<RAPFactory> (paramList, factoryMapIn, factoryManagersIn);
283 if (factoryName == "RAPShiftFactory") return BuildRAPFactory<RAPShiftFactory> (paramList, factoryMapIn, factoryManagersIn);
284 if (factoryName == "RebalanceAcFactory") return Build2<RebalanceAcFactory> (paramList, factoryMapIn, factoryManagersIn);
285 if (factoryName == "RebalanceTransferFactory") return Build2<RebalanceTransferFactory> (paramList, factoryMapIn, factoryManagersIn);
286 if (factoryName == "RegionRFactory") return Build2<RegionRFactory> (paramList, factoryMapIn, factoryManagersIn);
287 if (factoryName == "RegionRFactory_kokkos") return Build2<RegionRFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
288 if (factoryName == "ReorderBlockAFactory") return Build2<ReorderBlockAFactory> (paramList, factoryMapIn, factoryManagersIn);
289 if (factoryName == "RepartitionInterface") return Build2<RepartitionInterface> (paramList, factoryMapIn, factoryManagersIn);
290 if (factoryName == "ScaledNullspaceFactory") return Build2<ScaledNullspaceFactory> (paramList, factoryMapIn, factoryManagersIn);
291 if (factoryName == "SegregatedAFactory") return Build2<SegregatedAFactory> (paramList, factoryMapIn, factoryManagersIn);
292 if (factoryName == "SemiCoarsenPFactory") return Build2<SemiCoarsenPFactory> (paramList, factoryMapIn, factoryManagersIn);
293 if (factoryName == "StructuredAggregationFactory") return Build2<StructuredAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
294 if (factoryName == "StructuredLineDetectionFactory") return Build2<StructuredLineDetectionFactory> (paramList, factoryMapIn, factoryManagersIn);
295 if (factoryName == "SubBlockAFactory") return Build2<SubBlockAFactory> (paramList, factoryMapIn, factoryManagersIn);
296 if (factoryName == "TentativePFactory") return Build2<TentativePFactory> (paramList, factoryMapIn, factoryManagersIn);
297 if (factoryName == "ToggleCoordinatesTransferFactory") return BuildToggleCoordinatesTransferFactory (paramList, factoryMapIn, factoryManagersIn);
298 if (factoryName == "TogglePFactory") return BuildTogglePFactory<TogglePFactory> (paramList, factoryMapIn, factoryManagersIn);
299 if (factoryName == "TransPFactory") return Build2<TransPFactory> (paramList, factoryMapIn, factoryManagersIn);
300 if (factoryName == "RfromP_Or_TransP") return Build2<RfromP_Or_TransP> (paramList, factoryMapIn, factoryManagersIn);
301 if (factoryName == "TrilinosSmoother") return BuildTrilinosSmoother (paramList, factoryMapIn, factoryManagersIn);
302 if (factoryName == "UncoupledAggregationFactory") return Build2<UncoupledAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
303 if (factoryName == "UnsmooshFactory") return Build2<UnsmooshFactory> (paramList, factoryMapIn, factoryManagersIn);
304 if (factoryName == "UserAggregationFactory") return Build2<UserAggregationFactory> (paramList, factoryMapIn, factoryManagersIn);
305 if (factoryName == "UserPFactory") return Build2<UserPFactory> (paramList, factoryMapIn, factoryManagersIn);
306 if (factoryName == "VariableDofLaplacianFactory") return Build2<VariableDofLaplacianFactory> (paramList, factoryMapIn, factoryManagersIn);
307 if (factoryName == "ZeroSubBlockAFactory") return Build2<ZeroSubBlockAFactory> (paramList, factoryMapIn, factoryManagersIn);
308 if (factoryName == "CoalesceDropFactory_kokkos") return Build2<CoalesceDropFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
309 if (factoryName == "GeometricInterpolationPFactory_kokkos") return Build2<GeometricInterpolationPFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
310 if (factoryName == "NullspaceFactory_kokkos") return Build2<NullspaceFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
311 if (factoryName == "SaPFactory_kokkos") return Build2<SaPFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
312 if (factoryName == "SemiCoarsenPFactory_kokkos") return Build2<SemiCoarsenPFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
313 if (factoryName == "StructuredAggregationFactory_kokkos") return Build2<StructuredAggregationFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
314 if (factoryName == "TentativePFactory_kokkos") return Build2<TentativePFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
315 if (factoryName == "MatrixFreeTentativePFactory") return Build2<MatrixFreeTentativePFactory> (paramList, factoryMapIn, factoryManagersIn);
316 if (factoryName == "UncoupledAggregationFactory_kokkos") return Build2<UncoupledAggregationFactory_kokkos> (paramList, factoryMapIn, factoryManagersIn);
317
318 // Handle removed Kokkos factories
319 if (factoryName == "CoarseMapFactory_kokkos") return Build2<CoarseMapFactory> (paramList, factoryMapIn, factoryManagersIn);
320 if (factoryName == "CoordinatesTransferFactory_kokkos") return Build2<CoordinatesTransferFactory> (paramList, factoryMapIn, factoryManagersIn);
321
322 if (factoryName == "ZoltanInterface") {
323#if defined(HAVE_MUELU_ZOLTAN) && defined(HAVE_MPI)
324 return Build2<ZoltanInterface>(paramList, factoryMapIn, factoryManagersIn);
325#else
326 TEUCHOS_TEST_FOR_EXCEPTION(true, Exceptions::RuntimeError, "MueLu::FactoryFactory:BuildFactory(): Cannot create a ZoltanInterface object: Zoltan is disabled: HAVE_MUELU_ZOLTAN && HAVE_MPI == false.");
327#endif // HAVE_MUELU_ZOLTAN && HAVE_MPI
328 }
329 if (factoryName == "Zoltan2Interface") {
330#if defined(HAVE_MUELU_ZOLTAN2) && defined(HAVE_MPI)
331 return Build2<Zoltan2Interface>(paramList, factoryMapIn, factoryManagersIn);
332#else
333 TEUCHOS_TEST_FOR_EXCEPTION(true, Exceptions::RuntimeError, "MueLu::FactoryFactory:BuildFactory(): Cannot create a Zoltan2Interface object: Zoltan2 is disabled: HAVE_MUELU_ZOLTAN2 && HAVE_MPI == false.");
334#endif // HAVE_MUELU_ZOLTAN2 && HAVE_MPI
335 }
336 if (factoryName == "IsorropiaInterface") {
337#if defined(HAVE_MUELU_ISORROPIA) && defined(HAVE_MPI)
338 return Build2<IsorropiaInterface>(paramList, factoryMapIn, factoryManagersIn);
339#else
340 TEUCHOS_TEST_FOR_EXCEPTION(true, Exceptions::RuntimeError, "MueLu::FactoryFactory:BuildFactory(): Cannot create a IsorropiaInterface object: Isorropia is disabled: HAVE_MUELU_ISORROPIA && HAVE_MPI == false.");
341#endif // HAVE_MUELU_ZOLTAN2 && HAVE_MPI
342 }
343
344 if (factoryName == "NodePartitionInterface") {
345#if defined(HAVE_MPI)
346 return Build2<NodePartitionInterface>(paramList, factoryMapIn, factoryManagersIn);
347#else
348 TEUCHOS_TEST_FOR_EXCEPTION(true, Exceptions::RuntimeError, "MueLu::FactoryFactory:BuildFactory(): Cannot create a NodePartitionInterface object: HAVE_MPI == false.");
349#endif // HAVE_MPI
350 }
351
352 if (factoryName == "RepartitionFactory") {
353#ifdef HAVE_MPI
354 return Build2<RepartitionFactory>(paramList, factoryMapIn, factoryManagersIn);
355#else
356 TEUCHOS_TEST_FOR_EXCEPTION(true, Exceptions::RuntimeError, "MueLu::FactoryFactory:BuildFactory(): Cannot create a RepartitionFactory object: HAVE_MPI == false.");
357#endif // HAVE_MPI
358 }
359 if (factoryName == "RepartitionHeuristicFactory") {
360#ifdef HAVE_MPI
361 return Build2<RepartitionHeuristicFactory>(paramList, factoryMapIn, factoryManagersIn);
362#else
363 TEUCHOS_TEST_FOR_EXCEPTION(true, Exceptions::RuntimeError, "MueLu::FactoryFactory:BuildFactory(): Cannot create a RepartitionHeuristicFactory object: HAVE_MPI == false.");
364#endif // HAVE_MPI
365 }
366 // Blocked factories
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);
379#ifdef HAVE_MPI
380 if (factoryName == "RepartitionBlockDiagonalFactory") return Build2<RepartitionBlockDiagonalFactory> (paramList, factoryMapIn, factoryManagersIn);
381#endif
382#ifdef HAVE_MUELU_TEKO
383 if (factoryName == "TekoSmoother") return BuildTekoSmoother(paramList, factoryMapIn, factoryManagersIn);
384#endif
385 if (factoryName == "UzawaSmoother") return BuildBlockedSmoother<UzawaSmoother>(paramList, factoryMapIn, factoryManagersIn);
386
387 // Matlab factories
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);
392#endif
393
394#ifdef HAVE_MUELU_INTREPID2
395 if (factoryName == "IntrepidPCoarsenFactory") return Build2<IntrepidPCoarsenFactory> (paramList, factoryMapIn, factoryManagersIn);
396#endif
397
398 // Use a user defined factories (in <Factories> node)
399 if (factoryMapIn.find(factoryName) != factoryMapIn.end()) {
400 TEUCHOS_TEST_FOR_EXCEPTION((param.isList() && (++paramList.begin() != paramList.end())), Exceptions::RuntimeError,
401 "MueLu::FactoryFactory: Error during the parsing of: " << std::endl << paramList << std::endl
402 << "'" << factoryName << "' is not a factory name but an existing instance of a factory." << std::endl
403 << "Extra parameters cannot be specified after the creation of the object." << std::endl << std::endl
404 << "Correct syntaxes includes:" << std::endl
405 << " <Parameter name=\"...\" type=\"string\" value=\"" << factoryName << "\"/>" << std::endl
406 << "or" << std::endl
407 << " <ParameterList name=\"...\"><Parameter name=\"factory\" type=\"string\" value=\"" << factoryName << "\"/></ParameterList>" << std::endl
408 );
409
410 return factoryMapIn.find(factoryName)->second;
411 }
412
413 TEUCHOS_TEST_FOR_EXCEPTION(true, Exceptions::RuntimeError, "MueLu::FactoryFactory: unknown factory name : " << factoryName);
414
415 TEUCHOS_UNREACHABLE_RETURN(Teuchos::null);
416 }
417
418 //
419 //
420 //
421
422 // FOLLOWING FUNCTIONS SHOULD LIVE WITH THE CORRESPONDING CLASS
423
424 //
425 //
426 //
427
428#define arraysize(ar) (sizeof(ar) / sizeof(ar[0]))
429
430 template <class T> // T must implement the Factory interface
431 RCP<T> Build(const Teuchos::ParameterList& paramList, const FactoryMap& factoryMapIn, const FactoryManagerMap& factoryManagersIn) const {
432 RCP<T> factory = rcp(new T());
433
434 const char* strarray[] = {"A", "P", "R", "Graph", "UnAmalgamationInfo", "Aggregates", "Nullspace", "TransferFactory", "DofsPerNode"};
435 std::vector<std::string> v(strarray, strarray + arraysize(strarray));
436 for (size_t i = 0; i < v.size(); ++i)
437 if (paramList.isParameter(v[i]))
438 factory->SetFactory(v[i], BuildFactory(paramList.getEntry(v[i]), factoryMapIn, factoryManagersIn));
439
440 return factory;
441 }
442
443 template <class T> // T must implement the Factory interface
444 RCP<T> Build2(const Teuchos::ParameterList& paramList, const FactoryMap& factoryMapIn, const FactoryManagerMap& factoryManagersIn) const {
445 RCP<T> factory = rcp(new T());
446
447 ParameterList paramListWithFactories;
448
449 // Read the RCP<Factory> parameters of the class T
450 RCP<const ParameterList> validParamList = factory->GetValidParameterList(); // TODO check for Teuchos::null (no parameter list validation)
451 TEUCHOS_TEST_FOR_EXCEPTION(validParamList == Teuchos::null, Exceptions::RuntimeError, "FactoryFactory::Build2: default parameter list is null. Please fix this.");
452 for (ParameterList::ConstIterator param = validParamList->begin(); param != validParamList->end(); ++param) {
453 const std::string& pName = validParamList->name(param);
454
455 if (!paramList.isParameter(pName)) {
456 // Ignore unknown parameters
457 continue;
458 }
459
460 if (validParamList->isType< RCP<const FactoryBase> >(pName)) {
461 // Generate or get factory described by param
462 RCP<const FactoryBase> generatingFact = BuildFactory(paramList.getEntry(pName), factoryMapIn, factoryManagersIn);
463 paramListWithFactories.set(pName, generatingFact);
464 } else if (validParamList->isType<RCP<const ParameterList> >(pName)) {
465 if (pName == "ParameterList") {
466 // NOTE: we cannot use
467 // subList = sublist(rcpFromRef(paramList), pName)
468 // here as that would result in sublist also being a reference to a temporary object.
469 // The resulting dereferencing in the corresponding factory would then segfault
470 RCP<const ParameterList> subList = Teuchos::sublist(rcp(new ParameterList(paramList)), pName);
471 paramListWithFactories.set(pName, subList);
472 }
473 } else {
474 paramListWithFactories.setEntry(pName, paramList.getEntry(pName));
475 }
476 }
477
478 // Configure the factory
479 factory->SetParameterList(paramListWithFactories);
480
481 return factory;
482 }
483
484 template <class T> // T must implement the Factory interface
485 RCP<T> BuildRAPFactory(const Teuchos::ParameterList & paramList, const FactoryMap& factoryMapIn, const FactoryManagerMap& factoryManagersIn) const {
486 RCP<T> factory;
487 if (paramList.isSublist("TransferFactories") == false) {
488 factory = Build2<T>(paramList, factoryMapIn, factoryManagersIn);
489
490 } else {
491 RCP<Teuchos::ParameterList> paramListNonConst = rcp(new Teuchos::ParameterList(paramList));
492 RCP<const Teuchos::ParameterList> transferFactories = rcp(new Teuchos::ParameterList(*sublist(paramListNonConst, "TransferFactories")));
493
494 paramListNonConst->remove("TransferFactories");
495
496 factory = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
497
498 for (Teuchos::ParameterList::ConstIterator param = transferFactories->begin(); param != transferFactories->end(); ++param) {
499 RCP<const FactoryBase> p = BuildFactory(transferFactories->entry(param), factoryMapIn, factoryManagersIn);
500 factory->AddTransferFactory(p);
501 }
502 }
503
504 return factory;
505 }
506
507 template <class T> // T must implement the Factory interface
508 RCP<T> BuildTogglePFactory(const Teuchos::ParameterList & paramList, const FactoryMap& factoryMapIn, const FactoryManagerMap& factoryManagersIn) const {
509 RCP<T> factory;
510 if (paramList.isSublist("TransferFactories") == false) {
511 //TODO put in an error message: the TogglePFactory needs a TransferFactories sublist!
512 factory = Build2<T>(paramList, factoryMapIn, factoryManagersIn);
513
514 } else {
515 RCP<Teuchos::ParameterList> paramListNonConst = rcp(new Teuchos::ParameterList(paramList));
516 RCP<const Teuchos::ParameterList> transferFactories = rcp(new Teuchos::ParameterList(*sublist(paramListNonConst, "TransferFactories")));
517
518 paramListNonConst->remove("TransferFactories");
519
520 // build TogglePFactory
521 factory = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
522
523 // count how many prolongation factories and how many coarse null space factories have been declared.
524 // the numbers must match!
525 int numProlongatorFactories = 0;
526 int numPtentFactories = 0;
527 int numCoarseNspFactories = 0;
528 for (Teuchos::ParameterList::ConstIterator param = transferFactories->begin(); param != transferFactories->end(); ++param) {
529 size_t foundNsp = transferFactories->name(param).find("Nullspace");
530 if (foundNsp != std::string::npos && foundNsp == 0 && transferFactories->name(param).length()==10) {
531 numCoarseNspFactories++;
532 continue;
533 }
534 size_t foundPtent = transferFactories->name(param).find("Ptent");
535 if (foundPtent != std::string::npos && foundPtent == 0 && transferFactories->name(param).length()==6) {
536 numPtentFactories++;
537 continue;
538 }
539 size_t foundP = transferFactories->name(param).find("P");
540 if (foundP != std::string::npos && foundP == 0 && transferFactories->name(param).length()==2) {
541 numProlongatorFactories++;
542 continue;
543 }
544 }
545 TEUCHOS_TEST_FOR_EXCEPTION(numProlongatorFactories!=numCoarseNspFactories, Exceptions::RuntimeError, "FactoryFactory::BuildToggleP: The user has to provide the same number of prolongator and coarse nullspace factories!");
546 TEUCHOS_TEST_FOR_EXCEPTION(numPtentFactories!=numCoarseNspFactories, Exceptions::RuntimeError, "FactoryFactory::BuildToggleP: The user has to provide the same number of ptent and coarse nullspace factories!");
547 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.");
548
549 // create empty vectors with data
550 std::vector<Teuchos::ParameterEntry> prolongatorFactoryNames(numProlongatorFactories);
551 std::vector<Teuchos::ParameterEntry> coarseNspFactoryNames(numProlongatorFactories);
552 std::vector<Teuchos::ParameterEntry> ptentFactoryNames(numProlongatorFactories);
553
554 for (Teuchos::ParameterList::ConstIterator param = transferFactories->begin(); param != transferFactories->end(); ++param) {
555 size_t foundNsp = transferFactories->name(param).find("Nullspace");
556 if (foundNsp != std::string::npos && foundNsp == 0 && transferFactories->name(param).length()==10) {
557 int number = atoi(&(transferFactories->name(param).at(9)));
558 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!");
559 coarseNspFactoryNames[number-1] = transferFactories->entry(param);
560 continue;
561 }
562 size_t foundPtent = transferFactories->name(param).find("Ptent");
563 if (foundPtent != std::string::npos && foundPtent == 0 && transferFactories->name(param).length()==6) {
564 int number = atoi(&(transferFactories->name(param).at(5)));
565 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!");
566 ptentFactoryNames[number-1] = transferFactories->entry(param);
567 continue;
568 }
569 size_t foundP = transferFactories->name(param).find("P");
570 if (foundP != std::string::npos && foundP == 0 && transferFactories->name(param).length()==2) {
571 int number = atoi(&(transferFactories->name(param).at(1)));
572 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!");
573 prolongatorFactoryNames[number-1] = transferFactories->entry(param);
574 continue;
575 }
576 }
577
578 // register all prolongation factories in TogglePFactory
579 for (std::vector<Teuchos::ParameterEntry>::const_iterator it = prolongatorFactoryNames.begin(); it != prolongatorFactoryNames.end(); ++it) {
580 RCP<const FactoryBase> p = BuildFactory(*it, factoryMapIn, factoryManagersIn);
581 factory->AddProlongatorFactory(p);
582 }
583
584 // register all tentative prolongation factories in TogglePFactory
585 for (std::vector<Teuchos::ParameterEntry>::const_iterator it = ptentFactoryNames.begin(); it != ptentFactoryNames.end(); ++it) {
586 RCP<const FactoryBase> p = BuildFactory(*it, factoryMapIn, factoryManagersIn);
587 factory->AddPtentFactory(p);
588 }
589
590 // register all coarse nullspace factories in TogglePFactory
591 for (std::vector<Teuchos::ParameterEntry>::const_iterator it = coarseNspFactoryNames.begin(); it != coarseNspFactoryNames.end(); ++it) {
592 RCP<const FactoryBase> p = BuildFactory(*it, factoryMapIn, factoryManagersIn);
593 factory->AddCoarseNullspaceFactory(p);
594 }
595 }
596 return factory;
597 }
598
599 RCP<ToggleCoordinatesTransferFactory> BuildToggleCoordinatesTransferFactory(const Teuchos::ParameterList & paramList, const FactoryMap& factoryMapIn, const FactoryManagerMap& factoryManagersIn) const {
600 RCP<ToggleCoordinatesTransferFactory> factory;
601 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!");
602
603 RCP<Teuchos::ParameterList> paramListNonConst = rcp(new Teuchos::ParameterList(paramList));
604 RCP<const Teuchos::ParameterList> transferFactories = rcp(new Teuchos::ParameterList(*sublist(paramListNonConst, "TransferFactories")));
605 paramListNonConst->remove("TransferFactories");
606
607 // build CoordinatesTransferFactory
608 factory = Build2<ToggleCoordinatesTransferFactory>(*paramListNonConst, factoryMapIn, factoryManagersIn);
609
610 // count how many coordinate transfer factories have been declared.
611 // the numbers must match!
612 int numCoordTransferFactories = 0;
613 for (Teuchos::ParameterList::ConstIterator param = transferFactories->begin(); param != transferFactories->end(); ++param) {
614 size_t foundCoordinates = transferFactories->name(param).find("Coordinates");
615 if (foundCoordinates != std::string::npos && foundCoordinates == 0 && transferFactories->name(param).length()==12) {
616 numCoordTransferFactories++;
617 continue;
618 }
619 }
620 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.");
621
622 // create empty vectors with data
623 std::vector<Teuchos::ParameterEntry> coarseCoordsFactoryNames(numCoordTransferFactories);
624
625 for (Teuchos::ParameterList::ConstIterator param = transferFactories->begin(); param != transferFactories->end(); ++param) {
626 size_t foundCoords = transferFactories->name(param).find("Coordinates");
627 if (foundCoords != std::string::npos && foundCoords == 0 && transferFactories->name(param).length()==12) {
628 int number = atoi(&(transferFactories->name(param).at(11)));
629 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!");
630 coarseCoordsFactoryNames[number-1] = transferFactories->entry(param);
631 continue;
632 }
633 }
634
635 // register all coarse nullspace factories in TogglePFactory
636 for (std::vector<Teuchos::ParameterEntry>::const_iterator it = coarseCoordsFactoryNames.begin(); it != coarseCoordsFactoryNames.end(); ++it) {
637 RCP<const FactoryBase> p = BuildFactory(*it, factoryMapIn, factoryManagersIn);
638 factory->AddCoordTransferFactory(p);
639 }
640
641 return factory;
642 }
643
645 // Parameter List Parsing:
646 // <ParameterList name="smootherFact1">
647 // <Parameter name="factory" type="string" value="TrilinosSmoother"/>
648 // <Parameter name="verbose" type="string" value="Warnings"/>
649 // <Parameter name="type" type="string" value="RELAXATION"/>
650 // <ParameterList name="ParameterList">
651 // ...
652 // </ParameterList>
653 // </ParameterList>
654 RCP<FactoryBase> BuildTrilinosSmoother(const Teuchos::ParameterList & paramList, const FactoryMap & factoryMapIn, const FactoryManagerMap& factoryManagersIn) const {
655 if (paramList.begin() == paramList.end())
656 return rcp(new SmootherFactory(rcp(new TrilinosSmoother())));
657
658 TEUCHOS_TEST_FOR_EXCEPTION(paramList.get<std::string>("factory") != "TrilinosSmoother", Exceptions::RuntimeError, "");
659
660 // Is it true? TEUCHOS_TEST_FOR_EXCEPTION(!paramList.isParameter("type"), Exceptions::RuntimeError, "TrilinosSmoother: parameter 'type' is mandatory");
661 // type="" is default in TrilinosSmoother, but what happen then?
662
663 std::string type=""; if(paramList.isParameter("type")) type = paramList.get<std::string>("type");
664 int overlap=0; if(paramList.isParameter("overlap")) overlap = paramList.get<int> ("overlap");
665 // std::string verbose; if(paramList.isParameter("verbose")) verbose = paramList.get<std::string>("verbose");
666 Teuchos::ParameterList params; if(paramList.isParameter("ParameterList")) params = paramList.get<Teuchos::ParameterList>("ParameterList");
667
668 // parameters from SmootherFactory
669 //bool bKeepSmootherData = false; if(paramList.isParameter("keep smoother data")) bKeepSmootherData = paramList.get<bool>("keep smoother data");
670
671 // Read in factory information for smoothers (if available...)
672 // NOTE: only a selected number of factories can be used with the Trilinos smoother
673 // smoothers usually work with the global data available (which is A and the transfers P and R)
674
675 Teuchos::RCP<TrilinosSmoother> trilSmoo = Teuchos::rcp(new TrilinosSmoother(type, params, overlap));
676
677 if (paramList.isParameter("LineDetection_Layers")) {
678 RCP<const FactoryBase> generatingFact = BuildFactory(paramList.getEntry("LineDetection_Layers"), factoryMapIn, factoryManagersIn);
679 trilSmoo->SetFactory("LineDetection_Layers", generatingFact);
680 }
681 if (paramList.isParameter("LineDetection_VertLineIds")) {
682 RCP<const FactoryBase> generatingFact = BuildFactory(paramList.getEntry("LineDetection_Layers"), factoryMapIn, factoryManagersIn);
683 trilSmoo->SetFactory("LineDetection_Layers", generatingFact);
684 }
685 if (paramList.isParameter("CoarseNumZLayers")) {
686 RCP<const FactoryBase> generatingFact = BuildFactory(paramList.getEntry("CoarseNumZLayers"), factoryMapIn, factoryManagersIn);
687 trilSmoo->SetFactory("CoarseNumZLayers", generatingFact);
688 }
689
690 RCP<SmootherFactory> smooFact = rcp(new SmootherFactory(Teuchos::null));
691 Teuchos::ParameterList smooFactParams;
692 //smooFactParams.setEntry("keep smoother data", paramList.getEntry("keep smoother data"));
693 smooFact->SetParameterList(smooFactParams);
694 smooFact->SetSmootherPrototypes(trilSmoo);
695 return smooFact;
696 }
697
698#ifdef HAVE_MUELU_MATLAB
700 // Parameter List Parsing:
701 // <ParameterList name="smootherFact1">
702 // <Parameter name="factory" type="string" value="MatlabSmoother"/>
703 // <Parameter name="Setup Function" type="string" value="mySmootherSetup.m"/>
704 // <Parameter name="Solve Function" type="string" value="mySmootherSolve.m"/>
705 // <!--A is implicitly included in this list and nothing else is needed to get diagonal-->
706 // <Parameter name="Needs" type="string" value=""/>
707 // <!--A,x,b are also assumed inputs to the solver: only one additional arg then (diag)-->
708 // <Parameter name="Number of Solver Args" type="int" value="1"/>
709 // </ParameterList>
710 RCP<FactoryBase> BuildMatlabSmoother(const Teuchos::ParameterList & paramList, const FactoryMap & factoryMapIn, const FactoryManagerMap& factoryManagersIn) const {
711 if (paramList.begin() == paramList.end())
712 return rcp(new SmootherFactory(rcp(new MatlabSmoother())));
713
714 TEUCHOS_TEST_FOR_EXCEPTION(paramList.get<std::string>("factory") != "MatlabSmoother", Exceptions::RuntimeError, "");
715
716 // Read in factory information for smoothers (if available...)
717 // NOTE: only a selected number of factories can be used with the Trilinos smoother
718 // smoothers usually work with the global data available (which is A and the transfers P and R)
719
720 Teuchos::RCP<MatlabSmoother> matSmoo = Teuchos::rcp(new MatlabSmoother(paramList));
721
722 return rcp(new SmootherFactory(matSmoo));
723 }
724#endif
725
726 RCP<FactoryBase> BuildDirectSolver(const Teuchos::ParameterList& paramList, const FactoryMap& /* factoryMapIn */, const FactoryManagerMap& /* factoryManagersIn */) const {
727 if (paramList.begin() == paramList.end())
728 return rcp(new SmootherFactory(rcp(new DirectSolver()), Teuchos::null));
729
730 TEUCHOS_TEST_FOR_EXCEPTION(paramList.get<std::string>("factory") != "DirectSolver", Exceptions::RuntimeError, "");
731
732 std::string type; if(paramList.isParameter("type")) type = paramList.get<std::string>("type");
733 // std::string verbose; if(paramList.isParameter("verbose")) verbose = paramList.get<std::string>("verbose");
734 Teuchos::ParameterList params; if(paramList.isParameter("ParameterList")) params = paramList.get<Teuchos::ParameterList>("ParameterList");
735
736 return rcp(new SmootherFactory(rcp(new DirectSolver(type, params)), Teuchos::null));
737 }
738
739 template <class T> // T must implement the Factory interface
740 RCP<FactoryBase> BuildBlockedSmoother(const Teuchos::ParameterList& paramList, const FactoryMap& factoryMapIn, const FactoryManagerMap& factoryManagersIn) const {
741 // read in sub lists
742 RCP<ParameterList> paramListNonConst = rcp(new ParameterList(paramList));
743
744 // internal vector of factory managers
745 std::vector<RCP<FactoryManager> > facManagers;
746
747 // loop over all "block%i" sublists in parameter list
748 int blockid = 1;
749 bool blockExists = true;
750 while (blockExists == true) {
751 std::stringstream ss;
752 ss << "block" << blockid;
753
754 if(paramList.isSublist(ss.str()) == true) {
755 // we either have a parameter group or we have a list of factories in here
756 RCP<const ParameterList> b = rcp(new ParameterList(*sublist(paramListNonConst, ss.str())));
757
758 RCP<FactoryManager> M = Teuchos::null;
759
760 if (b->isParameter("group")) {
761 // use a factory manager
762 std::string facManagerName = b->get< std::string >("group");
763 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.");
764 RCP<FactoryManagerBase> Mb = factoryManagersIn.find(facManagerName)->second;
765 M = Teuchos::rcp_dynamic_cast<FactoryManager>(Mb);
766 TEUCHOS_TEST_FOR_EXCEPTION(M==Teuchos::null, Exceptions::RuntimeError, "Failed to cast FactoryManagerBase object to FactoryManager.");
767 } else {
768 // read in the list of factories
769 M = rcp(new FactoryManager());
770 for (ParameterList::ConstIterator param = b->begin(); param != b->end(); ++param) {
771 RCP<const FactoryBase> p = BuildFactory(b->entry(param), factoryMapIn, factoryManagersIn);
772 M->SetFactory(b->name(param),p);
773 }
774 }
775
776 // add factory manager to internal vector of factory managers
777 M->SetIgnoreUserData(true);
778 facManagers.push_back(M);
779 paramListNonConst->remove(ss.str());
780 blockid++;
781 } else {
782 blockExists = false;
783 break;
784 }
785
786 }
787
788 // create a new blocked smoother
789 RCP<T> bs = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
790
791 // important: set block factory for A here!
792 // TAW: 7/6/2016: We should not need to set/hardcode the blocked operator here.
793 // The user might want to overwrite this in the xml file, so just
794 // use what is declared as "A"
795 //bs->SetFactory("A", MueLu::NoFactory::getRCP());
796
797 for (int i = 0; i<Teuchos::as<int>(facManagers.size()); i++) {
798 bs->AddFactoryManager(facManagers[i],i);
799 }
800
801 return rcp(new SmootherFactory(bs));
802 }
803
804#ifdef HAVE_MUELU_TEKO
805 RCP<FactoryBase> BuildTekoSmoother(const Teuchos::ParameterList& paramList, const FactoryMap& factoryMapIn, const FactoryManagerMap& factoryManagersIn) const {
806 // read in sub lists
807 RCP<ParameterList> paramListNonConst = rcp(new ParameterList(paramList));
808 RCP<ParameterList> tekoParams = rcp(new ParameterList(paramListNonConst->sublist("Inverse Factory Library")));
809 paramListNonConst->remove("Inverse Factory Library");
810
811 // create a new blocked smoother
812 RCP<TekoSmoother> bs = Build2<TekoSmoother>(*paramListNonConst, factoryMapIn, factoryManagersIn);
813
814 // important: set block factory for A here!
815 // TAW: 7/6/2016: We should not need to set/hardcode the blocked operator here.
816 // The user might want to overwrite this in the xml file, so just
817 // use what is declared as "A"
818 //bs->SetFactory("A", MueLu::NoFactory::getRCP());
819
820 // Set Teko parameters ("Inverse Factory Library")
821 bs->SetTekoParameters(tekoParams);
822
823 return rcp(new SmootherFactory(bs));
824 }
825#endif
826
827 RCP<FactoryBase> BuildBlockedDirectSolver(const Teuchos::ParameterList& paramList, const FactoryMap& /* factoryMapIn */, const FactoryManagerMap& /* factoryManagersIn */) const {
828 if (paramList.numParams() == 0)
829 return rcp(new SmootherFactory(rcp(new BlockedDirectSolver())));
830
831 TEUCHOS_TEST_FOR_EXCEPTION(paramList.get<std::string>("factory") != "BlockedDirectSolver", Exceptions::RuntimeError, "FactoryFactory::BuildBlockedDirectSolver: Generating factory needs to be a BlockedDirectSolver.");
832
833 std::string type; if(paramList.isParameter("type")) type = paramList.get<std::string>("type");
834 // std::string verbose; if(paramList.isParameter("verbose")) verbose = paramList.get<std::string>("verbose");
835 Teuchos::ParameterList params; if(paramList.isParameter("ParameterList")) params = paramList.get<Teuchos::ParameterList>("ParameterList");
836
837 return rcp(new SmootherFactory(rcp(new BlockedDirectSolver(type, params))));
838 }
839
840 //RCP<FactoryBase> BuildBlockedPFactory(const Teuchos::ParameterList& paramList, const FactoryMap& factoryMapIn, const FactoryManagerMap& factoryManagersIn) const {
841 // RCP<BlockedPFactory> pfac = rcp(new BlockedPFactory());
842
843 template <class T> // T must implement the Factory interface
844 RCP<T> BuildBlockedFactory(const Teuchos::ParameterList & paramList, const FactoryMap& factoryMapIn, const FactoryManagerMap& factoryManagersIn) const {
845 RCP<T> pfac = Teuchos::null;
846
847 // read in sub lists
848 RCP<ParameterList> paramListNonConst = rcp(new ParameterList(paramList));
849
850 // internal vector of factory managers
851 std::vector<RCP<FactoryManager> > facManagers;
852
853 // loop over all "block%i" sublists in parameter list
854 int blockid = 1;
855 bool blockExists = true;
856 while (blockExists == true) {
857 std::stringstream ss;
858 ss << "block" << blockid;
859
860 if(paramList.isSublist(ss.str()) == true) {
861 // we either have a parameter group or we have a list of factories in here
862 RCP<const ParameterList> b = rcp(new ParameterList(*sublist(paramListNonConst, ss.str())));
863
864 RCP<FactoryManager> M = Teuchos::null;
865
866 if (b->isParameter("group")) {
867 // use a factory manager
868 std::string facManagerName = b->get< std::string >("group");
869 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.");
870 RCP<FactoryManagerBase> Mb = factoryManagersIn.find(facManagerName)->second;
871 M = Teuchos::rcp_dynamic_cast<FactoryManager>(Mb);
872 TEUCHOS_TEST_FOR_EXCEPTION(M==Teuchos::null, Exceptions::RuntimeError, "Failed to cast FactoryManagerBase object to FactoryManager.");
873 } else {
874 // read in the list of factories
875 M = rcp(new FactoryManager());
876 for (ParameterList::ConstIterator param = b->begin(); param != b->end(); ++param) {
877 RCP<const FactoryBase> p = BuildFactory(b->entry(param), factoryMapIn, factoryManagersIn);
878 M->SetFactory(b->name(param),p);
879 }
880 }
881
882 // add factory manager to internal vector of factory managers
883 M->SetIgnoreUserData(true);
884 facManagers.push_back(M);
885 paramListNonConst->remove(ss.str());
886 blockid++;
887 } else {
888 blockExists = false;
889 break;
890 }
891
892 }
893
894 // build BlockedPFactory (without sub block information)
895 pfac = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
896
897 // add FactoryManager objects
898 for(size_t i = 0; i<facManagers.size(); i++) {
899 pfac->AddFactoryManager(facManagers[i]); // add factory manager
900 }
901
902 return pfac;
903 }
904
905
906 template <class T> // T must implement the Factory interface
907 RCP<T> BuildBlockedCoordFactory(const Teuchos::ParameterList & paramList, const FactoryMap& factoryMapIn, const FactoryManagerMap& factoryManagersIn) const {
908 RCP<T> pfac = Teuchos::null;
909
910 // read in sub lists
911 RCP<ParameterList> paramListNonConst = rcp(new ParameterList(paramList));
912
913 // internal vector of factory managers
914 std::vector<RCP<const FactoryBase> > facBase;
915
916 // loop over all "block%i" sublists in parameter list
917 int blockid = 1;
918 bool blockExists = true;
919 while (blockExists == true) {
920 std::stringstream ss;
921 ss << "block" << blockid;
922
923 if(paramList.isSublist(ss.str()) == true) {
924 // we either have a parameter group or we have a list of factories in here
925 RCP<const ParameterList> b = rcp(new ParameterList(*sublist(paramListNonConst, ss.str())));
926
927 // read in the list of factories
928 for (ParameterList::ConstIterator param = b->begin(); param != b->end(); ++param) {
929 RCP<const FactoryBase> p = BuildFactory(b->entry(param), factoryMapIn, factoryManagersIn);
930 facBase.push_back(p);
931 }
932
933 // add factory manager to internal vector of factory managers
934 paramListNonConst->remove(ss.str());
935 blockid++;
936 } else {
937 blockExists = false;
938 break;
939 }
940
941 }
942
943 // build BlockedPFactory (without sub block information)
944 pfac = Build2<T>(*paramListNonConst, factoryMapIn, factoryManagersIn);
945
946 // add FactoryManager objects
947 for(size_t i = 0; i<facBase.size(); i++) {
948 pfac->AddFactory(facBase[i]); // add factory manager
949 }
950
951 return pfac;
952 }
953
954 }; // class
955} // namespace MueLu
956
957#define MUELU_FACTORYFACTORY_SHORT
958#endif // MUELU_FACTORYFACTORY_DECL_HPP
959
960 // TODO: handle factory parameters
961 // TODO: parameter validator
962 // TODO: static
963 // TODO: default parameters should not be duplicated here and on the Factory (ex: default for overlap (=0) is defined both here and on TrilinosSmoother constructors)
MueLu_ConfigDefs.hpp
MueLu_Exceptions.hpp
MueLu_FactoryBase.hpp
MueLu_FactoryBase_fwd.hpp
arraysize
#define arraysize(ar)
Definition MueLu_FactoryFactory_decl.hpp:428
MueLu_FactoryFactory_fwd.hpp
MueLu_FactoryManagerBase_fwd.hpp
MueLu_FactoryManager_fwd.hpp
MueLu_HierarchyFactory.hpp
MueLu_Hierarchy_fwd.hpp
MueLu_Monitor.hpp
LocalOrdinal
MueLu::DefaultLocalOrdinal LocalOrdinal
Definition MueLu_UseDefaultTypes.hpp:50
Scalar
MueLu::DefaultScalar Scalar
Definition MueLu_UseDefaultTypes.hpp:49
GlobalOrdinal
MueLu::DefaultGlobalOrdinal GlobalOrdinal
Definition MueLu_UseDefaultTypes.hpp:51
Node
MueLu::DefaultNode Node
Definition MueLu_UseDefaultTypes.hpp:52
MueLu_UseShortNames.hpp
MueLu::BaseClass
Base class for MueLu classes.
Definition MueLu_BaseClass.hpp:63
MueLu::BlockedDirectSolver
direct solver for nxn blocked matrices
Definition MueLu_BlockedDirectSolver_decl.hpp:83
MueLu::DirectSolver
Class that encapsulates direct solvers. Autoselection of AmesosSmoother or Amesos2Smoother according ...
Definition MueLu_DirectSolver_decl.hpp:80
MueLu::Exceptions::RuntimeError
Exception throws to report errors in the internal logical of the program.
Definition MueLu_Exceptions.hpp:70
MueLu::FactoryFactory
Factory that can generate other factories from.
Definition MueLu_FactoryFactory_decl.hpp:200
MueLu::FactoryFactory::FactoryMap
std::map< std::string, RCP< const FactoryBase > > FactoryMap
Definition MueLu_FactoryFactory_decl.hpp:204
MueLu::FactoryFactory::BuildBlockedDirectSolver
RCP< FactoryBase > BuildBlockedDirectSolver(const Teuchos::ParameterList &paramList, const FactoryMap &, const FactoryManagerMap &) const
Definition MueLu_FactoryFactory_decl.hpp:827
MueLu::FactoryFactory::FactoryManagerMap
std::map< std::string, RCP< FactoryManagerBase > > FactoryManagerMap
Definition MueLu_FactoryFactory_decl.hpp:205
MueLu::FactoryFactory::MatlabSmoother
MueLu::MatlabSmoother< Scalar, LocalOrdinal, GlobalOrdinal, Node > MatlabSmoother
Definition MueLu_FactoryFactory_decl.hpp:451
MueLu::FactoryFactory::BuildToggleCoordinatesTransferFactory
RCP< ToggleCoordinatesTransferFactory > BuildToggleCoordinatesTransferFactory(const Teuchos::ParameterList &paramList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
Definition MueLu_FactoryFactory_decl.hpp:599
MueLu::FactoryFactory::BuildBlockedFactory
RCP< T > BuildBlockedFactory(const Teuchos::ParameterList &paramList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
Definition MueLu_FactoryFactory_decl.hpp:844
MueLu::FactoryFactory::BuildBlockedSmoother
RCP< FactoryBase > BuildBlockedSmoother(const Teuchos::ParameterList &paramList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
Definition MueLu_FactoryFactory_decl.hpp:740
MueLu::FactoryFactory::BuildTekoSmoother
RCP< FactoryBase > BuildTekoSmoother(const Teuchos::ParameterList &paramList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
Definition MueLu_FactoryFactory_decl.hpp:805
MueLu::FactoryFactory::BuildTogglePFactory
RCP< T > BuildTogglePFactory(const Teuchos::ParameterList &paramList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
Definition MueLu_FactoryFactory_decl.hpp:508
MueLu::FactoryFactory::BuildRAPFactory
RCP< T > BuildRAPFactory(const Teuchos::ParameterList &paramList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
Definition MueLu_FactoryFactory_decl.hpp:485
MueLu::FactoryFactory::FactoryManager
MueLu::FactoryManager< Scalar, LocalOrdinal, GlobalOrdinal, Node > FactoryManager
MueLu::FactoryFactory::BuildBlockedCoordFactory
RCP< T > BuildBlockedCoordFactory(const Teuchos::ParameterList &paramList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
Definition MueLu_FactoryFactory_decl.hpp:907
MueLu::FactoryFactory::BuildDirectSolver
RCP< FactoryBase > BuildDirectSolver(const Teuchos::ParameterList &paramList, const FactoryMap &, const FactoryManagerMap &) const
Definition MueLu_FactoryFactory_decl.hpp:726
MueLu::FactoryFactory::Build
RCP< T > Build(const Teuchos::ParameterList &paramList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
Definition MueLu_FactoryFactory_decl.hpp:431
MueLu::FactoryFactory::BuildFactory
virtual RCP< const FactoryBase > BuildFactory(const Teuchos::ParameterEntry &param, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
: Interpret Factory parameter list and build new factory
Definition MueLu_FactoryFactory_decl.hpp:226
MueLu::FactoryFactory::Build2
RCP< T > Build2(const Teuchos::ParameterList &paramList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
Definition MueLu_FactoryFactory_decl.hpp:444
MueLu::FactoryFactory::BuildTrilinosSmoother
RCP< FactoryBase > BuildTrilinosSmoother(const Teuchos::ParameterList &paramList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
TrilinosSmoother.
Definition MueLu_FactoryFactory_decl.hpp:654
MueLu::FactoryFactory::BuildMatlabSmoother
RCP< FactoryBase > BuildMatlabSmoother(const Teuchos::ParameterList &paramList, const FactoryMap &factoryMapIn, const FactoryManagerMap &factoryManagersIn) const
MatlabSmoother.
Definition MueLu_FactoryFactory_decl.hpp:710
MueLu::NoFactory::getRCP
static const RCP< const NoFactory > getRCP()
Static Get() functions.
Definition MueLu_NoFactory.hpp:90
MueLu::SmootherFactory
Generic Smoother Factory for generating the smoothers of the MG hierarchy.
Definition MueLu_SmootherFactory_decl.hpp:90
MueLu::TrilinosSmoother
Class that encapsulates external library smoothers.
Definition MueLu_TrilinosSmoother_decl.hpp:90
MueLu
Namespace for MueLu classes and methods.
Definition MueLu_BrickAggregationFactory_decl.hpp:78
MueLu::DefaultNode
Tpetra::KokkosClassic::DefaultNode::DefaultNodeType DefaultNode
Definition MueLu_Details_DefaultTypes.hpp:70
MueLu::DefaultScalar
Tpetra::Details::DefaultTypes::scalar_type DefaultScalar
Definition MueLu_Details_DefaultTypes.hpp:58