MueLu Version of the Day
Loading...
Searching...
No Matches
MueLu_AdaptiveSaMLParameterListInterpreter_def.hpp
Go to the documentation of this file.
1/*
2 * MueLu_AdaptiveSaMLParamterListInterpreter_def.hpp
3 *
4 * Created on: Jan 28, 2013
5 * Author: tobias
6 */
7
8#ifndef MUELU_ADAPTIVESAMLPARAMETERLISTINTERPRETER_DEF_HPP_
9#define MUELU_ADAPTIVESAMLPARAMETERLISTINTERPRETER_DEF_HPP_
10
11#include <Teuchos_XMLParameterListHelpers.hpp>
12
13#include "MueLu_ConfigDefs.hpp"
14#if defined(HAVE_MUELU_ML) && defined(HAVE_MUELU_EPETRA)
15#include <ml_ValidateParameters.h>
16#endif
17
18#include <Xpetra_Matrix.hpp>
19#include <Xpetra_MultiVector.hpp>
20#include <Xpetra_MultiVectorFactory.hpp>
21#include <Xpetra_Operator.hpp>
22#include <Xpetra_IO.hpp>
23
25
26#include "MueLu_Level.hpp"
27#include "MueLu_Hierarchy.hpp"
28#include "MueLu_FactoryManager.hpp"
29
30#include "MueLu_TentativePFactory.hpp"
31#include "MueLu_SaPFactory.hpp"
32#include "MueLu_PgPFactory.hpp"
33#include "MueLu_TransPFactory.hpp"
34#include "MueLu_GenericRFactory.hpp"
35#include "MueLu_SmootherPrototype.hpp"
36#include "MueLu_SmootherFactory.hpp"
37#include "MueLu_TrilinosSmoother.hpp"
39#include "MueLu_DirectSolver.hpp"
40#include "MueLu_HierarchyUtils.hpp"
41#include "MueLu_RAPFactory.hpp"
42#include "MueLu_CoalesceDropFactory.hpp"
43#include "MueLu_CoupledAggregationFactory.hpp"
44#include "MueLu_UncoupledAggregationFactory.hpp"
45#include "MueLu_HybridAggregationFactory.hpp"
46#include "MueLu_NullspaceFactory.hpp"
48#include "MueLu_MLParameterListInterpreter.hpp"
49
50//#include "MueLu_Utilities.hpp"
51
53
54// Note: do not add options that are only recognized by MueLu.
55
56// TODO: this parameter list interpreter should force MueLu to use default ML parameters
57// - Ex: smoother sweep=2 by default for ML
58
59// Read a parameter value from a parameter list and store it into a variable named 'varName'
60#define MUELU_READ_PARAM(paramList, paramStr, varType, defaultValue, varName) \
61 varType varName = defaultValue; if (paramList.isParameter(paramStr)) varName = paramList.get<varType>(paramStr);
62
63// Read a parameter value from a paraeter list and copy it into a new parameter list (with another parameter name)
64#define MUELU_COPY_PARAM(paramList, paramStr, varType, defaultValue, outParamList, outParamStr) \
65 if (paramList.isParameter(paramStr)) \
66 outParamList.set<varType>(outParamStr, paramList.get<varType>(paramStr)); \
67 else outParamList.set<varType>(outParamStr, defaultValue); \
68
69namespace MueLu {
70
71 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
72 AdaptiveSaMLParameterListInterpreter<Scalar, LocalOrdinal, GlobalOrdinal, Node>::AdaptiveSaMLParameterListInterpreter(Teuchos::ParameterList & paramList, std::vector<RCP<FactoryBase> > factoryList) : TransferFacts_(factoryList), blksize_(1) {
73 SetParameterList(paramList);
74 }
75
76 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
77 AdaptiveSaMLParameterListInterpreter<Scalar, LocalOrdinal, GlobalOrdinal, Node>::AdaptiveSaMLParameterListInterpreter(const std::string & xmlFileName, std::vector<RCP<FactoryBase> > factoryList) : nullspace_(NULL), TransferFacts_(factoryList), blksize_(1) {
78 Teuchos::RCP<Teuchos::ParameterList> paramList = Teuchos::getParametersFromXmlFile(xmlFileName);
79 SetParameterList(*paramList);
80 }
81
82 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
84 Teuchos::ParameterList paramList = paramList_in;
85
86 RCP<Teuchos::FancyOStream> out = Teuchos::fancyOStream(Teuchos::rcpFromRef(std::cout)); // TODO: use internal out (GetOStream())
87
88 //
89 // Read top-level of the parameter list
90 //
91
92 // hard-coded default values == ML defaults according to the manual
93 MUELU_READ_PARAM(paramList, "ML output", int, 0, verbosityLevel);
94 MUELU_READ_PARAM(paramList, "max levels", int, 10, maxLevels);
95 MUELU_READ_PARAM(paramList, "PDE equations", int, 1, nDofsPerNode);
96
97 MUELU_READ_PARAM(paramList, "coarse: max size", int, 128, maxCoarseSize);
98
99 MUELU_READ_PARAM(paramList, "aggregation: type", std::string, "Uncoupled", agg_type);
100 //MUELU_READ_PARAM(paramList, "aggregation: threshold", double, 0.0, agg_threshold);
101 MUELU_READ_PARAM(paramList, "aggregation: damping factor", double, (double)4/(double)3, agg_damping);
102 //MUELU_READ_PARAM(paramList, "aggregation: smoothing sweeps", int, 1, agg_smoothingsweeps);
103 MUELU_READ_PARAM(paramList, "aggregation: nodes per aggregate", int, 1, minPerAgg);
104
105 MUELU_READ_PARAM(paramList, "null space: type", std::string, "default vectors", nullspaceType);
106 MUELU_READ_PARAM(paramList, "null space: dimension", int, -1, nullspaceDim); // TODO: ML default not in documentation
107 MUELU_READ_PARAM(paramList, "null space: vectors", double*, NULL, nullspaceVec); // TODO: ML default not in documentation
108
109 MUELU_READ_PARAM(paramList, "energy minimization: enable", bool, false, bEnergyMinimization);
110
111
112 //
113 // Move smoothers/aggregation/coarse parameters to sublists
114 //
115
116 // ML allows to have level-specific smoothers/aggregation/coarse parameters at the top level of the list or/and defined in sublists:
117 // See also: ML Guide section 6.4.1, MueLu::CreateSublists, ML_CreateSublists
118 ParameterList paramListWithSubList;
119 MueLu::CreateSublists(paramList, paramListWithSubList);
120 paramList = paramListWithSubList; // swap
121
122 // std::cout << std::endl << "Parameter list after CreateSublists" << std::endl;
123 // std::cout << paramListWithSubList << std::endl;
124
125 int maxNbrAlreadySelected = 0;
126
127 // Matrix option
128 this->blksize_ = nDofsPerNode;
129
130 // Translate verbosity parameter
131 Teuchos::EVerbosityLevel eVerbLevel = Teuchos::VERB_NONE;
132 if (verbosityLevel == 0) eVerbLevel = Teuchos::VERB_NONE;
133 if (verbosityLevel > 0) eVerbLevel = Teuchos::VERB_LOW;
134 if (verbosityLevel > 4) eVerbLevel = Teuchos::VERB_MEDIUM;
135 if (verbosityLevel > 7) eVerbLevel = Teuchos::VERB_HIGH;
136 if (verbosityLevel > 9) eVerbLevel = Teuchos::VERB_EXTREME;
137
138 TEUCHOS_TEST_FOR_EXCEPTION(agg_type != "Uncoupled" && agg_type != "Coupled", Exceptions::RuntimeError, "MueLu::MLParameterListInterpreter::Setup(): parameter \"aggregation: type\": only 'Uncoupled' or 'Coupled' aggregation is supported.");
139
140 // Create MueLu factories
141 // RCP<NullspaceFactory> nspFact = rcp(new NullspaceFactory());
142 RCP<CoalesceDropFactory> dropFact = rcp(new CoalesceDropFactory());
143 //dropFact->SetVerbLevel(toMueLuVerbLevel(eVerbLevel));
144
145 RCP<FactoryBase> CoupledAggFact = Teuchos::null;
146 if(agg_type == "Uncoupled") {
147 // Uncoupled aggregation
148 RCP<UncoupledAggregationFactory> CoupledAggFact2 = rcp(new UncoupledAggregationFactory());
149 CoupledAggFact2->SetMinNodesPerAggregate(minPerAgg); //TODO should increase if run anything other than 1D
150 CoupledAggFact2->SetMaxNeighAlreadySelected(maxNbrAlreadySelected);
151 CoupledAggFact2->SetOrdering("natural");
152 CoupledAggFact = CoupledAggFact2;
153 } else {
154 // Coupled Aggregation (default)
155 RCP<CoupledAggregationFactory> CoupledAggFact2 = rcp(new CoupledAggregationFactory());
156 CoupledAggFact2->SetMinNodesPerAggregate(minPerAgg); //TODO should increase if run anything other than 1D
157 CoupledAggFact2->SetMaxNeighAlreadySelected(maxNbrAlreadySelected);
158 CoupledAggFact2->SetOrdering("natural");
159 CoupledAggFact2->SetPhase3AggCreation(0.5);
160 CoupledAggFact = CoupledAggFact2;
161 }
162 if (verbosityLevel > 3) { // TODO fix me: Setup is a static function: we cannot use GetOStream without an object...
163 *out << "========================= Aggregate option summary =========================" << std::endl;
164 *out << "min Nodes per aggregate : " << minPerAgg << std::endl;
165 *out << "min # of root nbrs already aggregated : " << maxNbrAlreadySelected << std::endl;
166 *out << "aggregate ordering : natural" << std::endl;
167 *out << "=============================================================================" << std::endl;
168 }
169
170 RCP<Factory> PFact;
171 RCP<Factory> RFact;
172 RCP<Factory> PtentFact = rcp( new TentativePFactory() );
173 if (agg_damping == 0.0 && bEnergyMinimization == false) {
174 // tentative prolongation operator (PA-AMG)
175 PFact = PtentFact;
176 RFact = rcp( new TransPFactory() );
177 } else if (agg_damping != 0.0 && bEnergyMinimization == false) {
178 // smoothed aggregation (SA-AMG)
179 RCP<SaPFactory> SaPFact = rcp( new SaPFactory() );
180 SaPFact->SetParameter("sa: damping factor", ParameterEntry(agg_damping));
181 PFact = SaPFact;
182 RFact = rcp( new TransPFactory() );
183 } else if (bEnergyMinimization == true) {
184 // Petrov Galerkin PG-AMG smoothed aggregation (energy minimization in ML)
185 PFact = rcp( new PgPFactory() );
186 RFact = rcp( new GenericRFactory() );
187 }
188
189 RCP<RAPFactory> AcFact = rcp( new RAPFactory() );
190 for (size_t i = 0; i<TransferFacts_.size(); i++) {
191 AcFact->AddTransferFactory(TransferFacts_[i]); // THIS WILL BE REPLACED with a call to the MLParamterListInterpreter
192 }
193
194 //
195 // Nullspace factory
196 //
197
198 // Set fine level nullspace
199 // extract pre-computed nullspace from ML parameter list
200 // store it in nullspace_ and nullspaceDim_
201 if (nullspaceType != "default vectors") {
202 TEUCHOS_TEST_FOR_EXCEPTION(nullspaceType != "pre-computed", Exceptions::RuntimeError, "MueLu::MLParameterListInterpreter: no valid nullspace (no pre-computed null space). error.");
203 TEUCHOS_TEST_FOR_EXCEPTION(nullspaceDim == -1, Exceptions::RuntimeError, "MueLu::MLParameterListInterpreter: no valid nullspace (nullspace dim == -1). error.");
204 TEUCHOS_TEST_FOR_EXCEPTION(nullspaceVec == NULL, Exceptions::RuntimeError, "MueLu::MLParameterListInterpreter: no valid nullspace (nullspace == NULL). You have to provide a valid fine-level nullspace in \'null space: vectors\'");
205
206 nullspaceDim_ = nullspaceDim;
207 nullspace_ = nullspaceVec;
208 }
209
210 Teuchos::RCP<NullspaceFactory> nspFact = Teuchos::rcp(new NullspaceFactory());
211 nspFact->SetFactory("Nullspace", PtentFact);
212
213 //
214 // Hierarchy + FactoryManager
215 //
216
217 // Hierarchy options
218 this->SetVerbLevel(toMueLuVerbLevel(eVerbLevel));
219 this->numDesiredLevel_ = maxLevels;
220 this->maxCoarseSize_ = maxCoarseSize;
221
222 // init smoother
223 RCP<SmootherFactory> initSmootherFact = Teuchos::null;
224 if(paramList.isSublist("init smoother")) {
225 ParameterList& initList = paramList.sublist("init smoother"); // TODO move this before for loop
226 initSmootherFact = MLParameterListInterpreter::GetSmootherFactory(initList); // TODO: missing AFact input arg.
227 } else {
228 std::string ifpackType = "RELAXATION";
229 Teuchos::ParameterList smootherParamList;
230 smootherParamList.set("relaxation: type", "symmetric Gauss-Seidel");
231 smootherParamList.set("smoother: sweeps", 1);
232 smootherParamList.set("smoother: damping factor", 1.0);
233 RCP<SmootherPrototype> smooProto = rcp( new TrilinosSmoother(ifpackType, smootherParamList, 0) );
234
235 initSmootherFact = rcp( new SmootherFactory() );
236 initSmootherFact->SetSmootherPrototypes(smooProto, smooProto);
237 }
238
239 //
240 // Coarse Smoother
241 //
242 ParameterList& coarseList = paramList.sublist("coarse: list");
243 // coarseList.get("smoother: type", "Amesos-KLU"); // set default
244 //RCP<SmootherFactory> coarseFact = this->GetSmootherFactory(coarseList);
245 RCP<SmootherFactory> coarseFact = MLParameterListInterpreter::GetSmootherFactory(coarseList);
246
247 // Smoothers Top Level Parameters
248
249 RCP<ParameterList> topLevelSmootherParam = ExtractSetOfParameters(paramList, "smoother");
250 // std::cout << std::endl << "Top level smoother parameters:" << std::endl;
251 // std::cout << *topLevelSmootherParam << std::endl;
252
253 //
254
255 // Prepare factory managers
256 // TODO: smootherFact can be reuse accross level if same parameters/no specific parameterList
257
258 for (int levelID=0; levelID < maxLevels; levelID++) {
259
260 //
261 // Level FactoryManager
262 //
263
264 RCP<FactoryManager> manager = rcp(new FactoryManager());
265 RCP<FactoryManager> initmanager = rcp(new FactoryManager());
266
267 //
268 // Smoothers
269 //
270
271 {
272 // Merge level-specific parameters with global parameters. level-specific parameters takes precedence.
273 // TODO: unit-test this part alone
274
275 ParameterList levelSmootherParam = GetMLSubList(paramList, "smoother", levelID); // copy
276 MergeParameterList(*topLevelSmootherParam, levelSmootherParam, false); /* false = do no overwrite levelSmootherParam parameters by topLevelSmootherParam parameters */
277 // std::cout << std::endl << "Merged List for level " << levelID << std::endl;
278 // std::cout << levelSmootherParam << std::endl;
279
280 //RCP<SmootherFactory> smootherFact = this->GetSmootherFactory(levelSmootherParam); // TODO: missing AFact input arg.
281 RCP<SmootherFactory> smootherFact = MLParameterListInterpreter::GetSmootherFactory(levelSmootherParam); // TODO: missing AFact input arg.
282 manager->SetFactory("Smoother", smootherFact);
283 smootherFact->DisableMultipleCallCheck();
284
285 initmanager->SetFactory("Smoother", initSmootherFact);
286 initmanager->SetFactory("CoarseSolver", initSmootherFact);
287 initSmootherFact->DisableMultipleCallCheck();
288
289 }
290
291 //
292 // Misc
293 //
294
295 Teuchos::rcp_dynamic_cast<PFactory>(PFact)->DisableMultipleCallCheck();
296 Teuchos::rcp_dynamic_cast<PFactory>(PtentFact)->DisableMultipleCallCheck();
297 Teuchos::rcp_dynamic_cast<TwoLevelFactoryBase>(RFact)->DisableMultipleCallCheck();
298 Teuchos::rcp_dynamic_cast<SingleLevelFactoryBase>(coarseFact)->DisableMultipleCallCheck();
299 Teuchos::rcp_dynamic_cast<SingleLevelFactoryBase>(dropFact)->DisableMultipleCallCheck();
300 Teuchos::rcp_dynamic_cast<SingleLevelFactoryBase>(CoupledAggFact)->DisableMultipleCallCheck();
301 Teuchos::rcp_dynamic_cast<TwoLevelFactoryBase>(AcFact)->DisableMultipleCallCheck();
302 Teuchos::rcp_dynamic_cast<SingleLevelFactoryBase>(nspFact)->DisableMultipleCallCheck();
303
304 manager->SetFactory("CoarseSolver", coarseFact); // TODO: should not be done in the loop
305 manager->SetFactory("Graph", dropFact);
306 manager->SetFactory("Aggregates", CoupledAggFact);
307 manager->SetFactory("DofsPerNode", dropFact);
308 manager->SetFactory("A", AcFact);
309 manager->SetFactory("P", PFact);
310 manager->SetFactory("Ptent", PtentFact);
311 manager->SetFactory("R", RFact);
312 manager->SetFactory("Nullspace", nspFact);
313
314 //initmanager->SetFactory("CoarseSolver", coarseFact);
315 initmanager->SetFactory("Graph", dropFact);
316 initmanager->SetFactory("Aggregates", CoupledAggFact);
317 initmanager->SetFactory("DofsPerNode", dropFact);
318 initmanager->SetFactory("A", AcFact);
319 initmanager->SetFactory("P", PtentFact); // use nonsmoothed transfers
320 initmanager->SetFactory("Ptent", PtentFact);
321 initmanager->SetFactory("R", RFact);
322 initmanager->SetFactory("Nullspace", nspFact);
323
324 this->AddFactoryManager(levelID, 1, manager);
325 this->AddInitFactoryManager(levelID, 1, initmanager);
326 } // for (level loop)
327 }
328
329 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
331 TEUCHOS_TEST_FOR_EXCEPTION(!H.GetLevel(0)->IsAvailable("A"), Exceptions::RuntimeError, "No fine level operator");
332
333 RCP<Level> l = H.GetLevel(0);
334 RCP<Operator> Op = l->Get<RCP<Operator> >("A");
335 SetupOperator(*Op); // use overloaded SetupMatrix routine
336 this->SetupExtra(H);
337
338 // Setup Hierarchy
339 H.SetMaxCoarseSize(this->maxCoarseSize_); // TODO
340
341 int levelID = 0;
342 int lastLevelID = this->numDesiredLevel_ - 1;
343 bool isLastLevel = false;
344
345 while(!isLastLevel) {
346 bool r = H.Setup(levelID,
347 InitLvlMngr(levelID-1, lastLevelID),
348 InitLvlMngr(levelID, lastLevelID),
349 InitLvlMngr(levelID+1, lastLevelID));
350
351 isLastLevel = r || (levelID == lastLevelID);
352 levelID++;
353 }
354 }
355
356 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
358
359 // set fine level null space
360 // usually this null space is provided from outside (by the user) using
361 // the ML parameter lists.
362 if (this->nullspace_ != NULL) {
363 RCP<Level> fineLevel = H.GetLevel(0);
364 const RCP<const Map> rowMap = fineLevel->Get< RCP<Matrix> >("A")->getRowMap();
365 RCP<MultiVector> nullspace = MultiVectorFactory::Build(rowMap, nullspaceDim_, true);
366
367 for ( size_t i=0; i < Teuchos::as<size_t>(nullspaceDim_); i++) {
368 Teuchos::ArrayRCP<Scalar> nullspacei = nullspace->getDataNonConst(i);
369 const size_t myLength = nullspace->getLocalLength();
370
371 for (size_t j = 0; j < myLength; j++) {
372 nullspacei[j] = nullspace_[i*myLength + j];
373 }
374 }
375
376 fineLevel->Set("Nullspace", nullspace);
377 }
378
379 // keep aggregates
380 H.Keep("Aggregates", HierarchyManager::GetFactoryManager(0)->GetFactory("Aggregates").get());
381
383
384 // build hierarchy for initialization
385 SetupInitHierarchy(H);
386
387 {
388 // do some iterations with the built hierarchy to improve the null space
389 Teuchos::RCP<MueLu::Level> Finest = H.GetLevel(0); // get finest level,MueLu::NoFactory::get()
390 Teuchos::RCP<MultiVector> nspVector2 = Finest->Get<Teuchos::RCP<MultiVector> >("Nullspace");
391
392 Xpetra::IO<Scalar,LocalOrdinal,GlobalOrdinal,Node>::Write("orig_nsp.vec", *nspVector2);
393
394 RCP<Matrix> Op = Finest->Get<RCP<Matrix> >("A");
395 Xpetra::IO<Scalar,LocalOrdinal,GlobalOrdinal,Node>::Write("A.mat", *Op);
396
397
398 Teuchos::RCP<MultiVector> homogRhsVec = MultiVectorFactory::Build(nspVector2->getMap(),nspVector2->getNumVectors(),true);
399 homogRhsVec->putScalar(0.0);
400
401 // do 1 multigrid cycle for improving the null space by "solving"
402 // A B_f = 0
403 // where A is the system matrix and B_f the fine level null space vectors
404 H.Iterate(*homogRhsVec, *nspVector2, 1, false);
405
406 // store improved fine level null space
407 Finest->Set("Nullspace",nspVector2);
408
409 Xpetra::IO<Scalar,LocalOrdinal,GlobalOrdinal,Node>::Write("new_nsp.vec", *nspVector2);
410
411 //H.Delete("CoarseSolver", init_levelManagers_[0]->GetFactory("CoarseSolver").get());
412 }
413
414 {
415 // do some clean up.
416 // remove all old default factories. Build new ones for the second build.
417 // this is a little bit tricky to understand
418 for(size_t k=0; k < HierarchyManager::getNumFactoryManagers(); k++) {
420 //Teuchos::rcp_dynamic_cast<const SingleLevelFactoryBase>(HierarchyManager::GetFactoryManager(k)->GetFactory("Smoother"))->DisableMultipleCallCheck(); // after changing to MLParamterListInterpreter functions
421 }
422 // not sure about this. i only need it if Smoother is defined explicitely (not using default smoother)
423 // need this: otherwise RAPFactory::Build is complaining on level 0
424 // and TentativePFactory::Build is complaining on level 1
425 Teuchos::rcp_dynamic_cast<const TwoLevelFactoryBase>(HierarchyManager::GetFactoryManager(0)->GetFactory("A"))->DisableMultipleCallCheck();
426 Teuchos::rcp_dynamic_cast<const TwoLevelFactoryBase>(HierarchyManager::GetFactoryManager(1)->GetFactory("P"))->DisableMultipleCallCheck();
427 Teuchos::rcp_dynamic_cast<const TwoLevelFactoryBase>(HierarchyManager::GetFactoryManager(1)->GetFactory("Ptent"))->DisableMultipleCallCheck();
428
430 }
431
432 }
433
434 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
436 // check if it's a TwoLevelFactoryBase based transfer factory
437 TEUCHOS_TEST_FOR_EXCEPTION(Teuchos::rcp_dynamic_cast<TwoLevelFactoryBase>(factory) == Teuchos::null, Exceptions::BadCast, "Transfer factory is not derived from TwoLevelFactoryBase. Since transfer factories will be handled by the RAPFactory they have to be derived from TwoLevelFactoryBase!");
438 TransferFacts_.push_back(factory);
439 }
440
441 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
443 return TransferFacts_.size();
444 }
445
446 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
448 try {
449 Matrix& A = dynamic_cast<Matrix&>(Op);
450 if (A.IsFixedBlockSizeSet() && (A.GetFixedBlockSize() != blksize_))
451 this->GetOStream(Warnings0) << "Setting matrix block size to " << blksize_ << " (value of the parameter in the list) "
452 << "instead of " << A.GetFixedBlockSize() << " (provided matrix)." << std::endl;
453
454 A.SetFixedBlockSize(blksize_);
455
456 } catch (std::bad_cast& e) {
457 this->GetOStream(Warnings0) << "Skipping setting block size as the operator is not a matrix" << std::endl;
458 }
459 }
460
461} // namespace MueLu
462
463
464#endif /* MUELU_ADAPTIVESAMLPARAMETERLISTINTERPRETER_DEF_HPP_ */
#define MUELU_READ_PARAM(paramList, paramStr, varType, defaultValue, varName)
size_t NumTransferFactories() const
Returns number of transfer factories.
virtual void SetupHierarchy(Hierarchy &H) const
Setup Hierarchy object.
void AddTransferFactory(const RCP< FactoryBase > &factory)
Add transfer factory in the end of list of transfer factories for RAPFactory.
Factory for creating a graph based on a given matrix.
Factory for coarsening a graph with uncoupled aggregation.
Exception indicating invalid cast attempted.
Exception throws to report errors in the internal logical of the program.
This class specifies the default factory that should generate some data on a Level if the data does n...
Factory for building restriction operators using a prolongator factory.
virtual void SetupHierarchy(Hierarchy &H) const
Setup Hierarchy object.
RCP< FactoryManagerBase > GetFactoryManager(int levelID) const
size_t getNumFactoryManagers() const
returns number of factory managers stored in levelManagers_ vector.
Provides methods to build a multigrid hierarchy and apply multigrid cycles.
RCP< Level > & GetLevel(const int levelID=0)
Retrieve a certain level from hierarchy.
bool Setup(int coarseLevelID, const RCP< const FactoryManagerBase > fineLevelManager, const RCP< const FactoryManagerBase > coarseLevelManager, const RCP< const FactoryManagerBase > nextLevelManager=Teuchos::null)
Multi-level setup phase: build a new level of the hierarchy.
ConvergenceStatus Iterate(const MultiVector &B, MultiVector &X, ConvData conv=ConvData(), bool InitialGuessIsZero=false, LO startLevel=0)
Apply the multigrid preconditioner.
void SetMaxCoarseSize(Xpetra::global_size_t maxCoarseSize)
void Keep(const std::string &ename, const FactoryBase *factory=NoFactory::get())
Call Level::Keep(ename, factory) for each level of the Hierarchy.
static RCP< SmootherFactory > GetSmootherFactory(const Teuchos::ParameterList &paramList, const RCP< FactoryBase > &AFact=Teuchos::null)
Read smoother options and build the corresponding smoother factory.
Factory for generating nullspace.
Factory for building Petrov-Galerkin Smoothed Aggregation prolongators.
Factory for building coarse matrices.
Factory for building Smoothed Aggregation prolongators.
Generic Smoother Factory for generating the smoothers of the MG hierarchy.
Factory for building tentative prolongator.
Factory for building restriction operators.
Class that encapsulates external library smoothers.
Factory for building uncoupled aggregates.
Namespace for MueLu classes and methods.
Teuchos::RCP< Teuchos::ParameterList > ExtractSetOfParameters(const Teuchos::ParameterList &paramList, const std::string &str)
@ Warnings0
Important warning messages (one line)
void CreateSublists(const ParameterList &List, ParameterList &newList)
void MergeParameterList(const Teuchos::ParameterList &source, Teuchos::ParameterList &dest, bool overWrite)
: merge two parameter lists
const Teuchos::ParameterList & GetMLSubList(const Teuchos::ParameterList &paramList, const std::string &type, int levelID)
VerbLevel toMueLuVerbLevel(const Teuchos::EVerbosityLevel verbLevel)
Translate Teuchos verbosity level to MueLu verbosity level.