MueLu  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
MueLu_HierarchyUtils_def.hpp
Go to the documentation of this file.
1 // @HEADER
2 // *****************************************************************************
3 // MueLu: A package for multigrid based preconditioning
4 //
5 // Copyright 2012 NTESS and the MueLu contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9 
10 #ifndef MUELU_HIERARCHYUTILS_DEF_HPP
11 #define MUELU_HIERARCHYUTILS_DEF_HPP
12 
13 #include "Teuchos_ScalarTraits.hpp"
14 
15 #include <Xpetra_Matrix.hpp>
16 #include <Xpetra_Operator.hpp>
17 
18 #include "MueLu_HierarchyUtils_decl.hpp"
19 #include "MueLu_HierarchyManager.hpp"
20 #include "MueLu_FactoryManager.hpp"
21 
22 // TODO/FIXME: DeclareInput(, **this**) cannot be used here
23 #ifdef HAVE_MUELU_INTREPID2
24 #include "Kokkos_DynRankView.hpp"
25 #endif
26 
27 namespace MueLu {
28 
29 // Copy object from one hierarchy to another calling AddNewLevel as appropriate.
30 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
31 void HierarchyUtils<Scalar, LocalOrdinal, GlobalOrdinal, Node>::CopyBetweenHierarchies(Hierarchy& fromHierarchy, Hierarchy& toHierarchy, const std::string fromLabel, const std::string toLabel, const std::string dataType) {
32  // add any necessary levels
33  for (int i = toHierarchy.GetNumLevels(); i < fromHierarchy.GetNumLevels(); i++)
34  toHierarchy.AddNewLevel();
35 
36  for (int i = 0; i < fromHierarchy.GetNumLevels(); i++) {
37  RCP<Level> fromLevel = fromHierarchy.GetLevel(i);
38  RCP<Level> toLevel = toHierarchy.GetLevel(i);
39 
40  TEUCHOS_TEST_FOR_EXCEPTION(dataType != "RCP<Matrix>" && dataType != "RCP<const Import>", Exceptions::InvalidArgument,
41  std::string("MueLu::Utils::CopyBetweenHierarchies: unknown data type(") + dataType + ")");
42  if (fromLevel->IsAvailable(fromLabel)) {
43  if (dataType == "RCP<Matrix>") {
44  // Normally, we should only do
45  // toLevel->Set(toLabel,fromLevel->Get<RCP<Matrix> >(fromLabel));
46  // The logic below is meant to handle a special case when we
47  // repartition a processor away, leaving behind a RCP<Operator> on
48  // on the level instead of an RCP<Matrix>
49 
50  auto tempOp = fromLevel->Get<RCP<Operator>>(fromLabel);
51  auto tempMatrix = rcp_dynamic_cast<Matrix>(tempOp);
52  if (!tempMatrix.is_null())
53  toLevel->Set(toLabel, tempMatrix);
54  else
55  toLevel->Set(toLabel, tempOp);
56  }
57  if (dataType == "RCP<const Import>") {
58  toLevel->Set(toLabel, fromLevel->Get<RCP<const Import>>(fromLabel));
59  }
60  }
61  }
62 }
63 
64 // Adds the following non-serializable data (A,P,R,Nullspace,Coordinates) from level-specific sublist nonSerialList,
65 // calling AddNewLevel as appropriate.
66 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
67 void HierarchyUtils<Scalar, LocalOrdinal, GlobalOrdinal, Node>::AddNonSerializableDataToHierarchy(HierarchyManager& HM, Hierarchy& H, const ParameterList& nonSerialList) {
68  typedef typename Xpetra::MultiVector<typename Teuchos::ScalarTraits<Scalar>::coordinateType,
69  LocalOrdinal, GlobalOrdinal, Node>
70  realvaluedmultivector_type;
71 
72  for (ParameterList::ConstIterator nonSerialEntry = nonSerialList.begin(); nonSerialEntry != nonSerialList.end(); nonSerialEntry++) {
73  const std::string& levelName = nonSerialEntry->first;
74  // Check for match of the form "level X" where X is a positive integer
75  if (nonSerialList.isSublist(levelName) && levelName.find("level ") == 0 && levelName.size() > 6) {
76  int levelID = strtol(levelName.substr(6).c_str(), 0, 0);
77  if (levelID > 0) {
78  // Do enough level adding so we can be sure to add the data to the right place
79  for (int i = H.GetNumLevels(); i <= levelID; i++)
80  H.AddNewLevel();
81  }
82  RCP<Level> level = H.GetLevel(levelID);
83 
84  RCP<FactoryManager> M = Teuchos::rcp_dynamic_cast<FactoryManager>(HM.GetFactoryManager(levelID));
85  TEUCHOS_TEST_FOR_EXCEPTION(M.is_null(), Exceptions::InvalidArgument, "MueLu::Utils::AddNonSerializableDataToHierarchy: cannot get FactoryManager");
86 
87  // Grab the level sublist & loop over parameters
88  const ParameterList& levelList = nonSerialList.sublist(levelName);
89  for (ParameterList::ConstIterator levelListEntry = levelList.begin(); levelListEntry != levelList.end(); levelListEntry++) {
90  const std::string& name = levelListEntry->first;
91  TEUCHOS_TEST_FOR_EXCEPTION(name != "A" && name != "P" && name != "R" && name != "K" && name != "M" && name != "Mdiag" &&
92  name != "D0" && name != "Dk_1" && name != "Dk_2" &&
93  name != "Mk_one" && name != "Mk_1_one" && name != "M1_beta" && name != "M1_alpha" &&
94  name != "invMk_1_invBeta" && name != "invMk_2_invAlpha" &&
95  name != "M1" && name != "Ms" && name != "M0inv" &&
96  name != "Pnodal" && name != "NodeMatrix" && name != "NodeAggMatrix" &&
97  name != "Nullspace" && name != "Coordinates" && name != "pcoarsen: element to node map" &&
98  name != "Node Comm" && name != "DualNodeID2PrimalNodeID" && name != "Primal interface DOF map" &&
99  name != "dropMap1" && name != "dropMap2" &&
100  !IsParamMuemexVariable(name),
101  Exceptions::InvalidArgument,
102  std::string("MueLu::Utils::AddNonSerializableDataToHierarchy: parameter list contains unknown data type(") + name + ")");
103 
104  // Get a valid communicator and lib
105  RCP<const Teuchos::Comm<int>> comm;
106  if (!level->GetComm().is_null())
107  comm = level->GetComm();
108  else if (level->IsAvailable("A")) {
109  RCP<Matrix> mat;
110  level->Get("A", mat);
111  comm = mat->getMap()->getComm();
112  } else {
113  RCP<Level> level0 = H.GetLevel(0);
114  if (!level0->GetComm().is_null())
115  comm = level0->GetComm();
116  else {
117  RCP<Matrix> mat;
118  level0->Get("A", mat);
119  comm = mat->getMap()->getComm();
120  }
121  }
122  Xpetra::UnderlyingLib lib = level->lib();
123 
124  if (name == "A") {
125  RCP<Matrix> mat;
126  if (levelListEntry->second.isType<std::string>())
127  // We might also want to read maps here.
128  mat = Xpetra::IO<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Read(Teuchos::getValue<std::string>(levelListEntry->second), lib, comm);
129  else
130  mat = Teuchos::getValue<RCP<Matrix>>(levelListEntry->second);
131  level->Set(name, mat, NoFactory::get());
132  M->SetFactory(name, NoFactory::getRCP()); // TAW: not sure about this: be aware that this affects all levels
133  // However, A is accessible through NoFactory anyway, so it should
134  // be fine here.
135  } else if (name == "P" || name == "R" || name == "K" || name == "M") {
136  if (levelListEntry->second.isType<RCP<Operator>>()) {
137  RCP<Operator> mat;
138  mat = Teuchos::getValue<RCP<Operator>>(levelListEntry->second);
139 
140  RCP<const FactoryBase> fact = M->GetFactory(name);
141  level->AddKeepFlag(name, fact.get(), MueLu::UserData);
142  level->Set(name, mat, fact.get());
143 
144  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
145  level->Set(name, mat, NoFactory::get());
146  } else {
147  RCP<Matrix> mat;
148  if (levelListEntry->second.isType<std::string>())
149  // We might also want to read maps here.
150  mat = Xpetra::IO<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Read(Teuchos::getValue<std::string>(levelListEntry->second), lib, comm);
151  else
152  mat = Teuchos::getValue<RCP<Matrix>>(levelListEntry->second);
153 
154  RCP<const FactoryBase> fact = M->GetFactory(name);
155  level->AddKeepFlag(name, fact.get(), MueLu::UserData);
156  level->Set(name, mat, fact.get());
157 
158  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
159  level->Set(name, mat, NoFactory::get());
160  }
161  } else if (name == "D0" || name == "Dk_1" || name == "Dk_2" ||
162  name == "Mk_one" || name == "Mk_1_one" || name == "M1_beta" || name == "M1_alpha" ||
163  name == "invMk_1_invBeta" || name == "invMk_2_invAlpha" ||
164  name == "M1" || name == "Ms" || name == "M0inv" ||
165  name == "Pnodal" || name == "NodeMatrix" || name == "NodeAggMatrix") {
166  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
167  if (levelListEntry->second.isType<RCP<Operator>>())
168  level->Set(name, Teuchos::getValue<RCP<Operator>>(levelListEntry->second), NoFactory::get());
169  else
170  level->Set(name, Teuchos::getValue<RCP<Matrix>>(levelListEntry->second), NoFactory::get());
171  } else if (name == "Mdiag") {
172  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
173  level->Set(name, Teuchos::getValue<RCP<Vector>>(levelListEntry->second), NoFactory::get());
174  } else if (name == "Nullspace") {
175  RCP<MultiVector> vec;
176  if (levelListEntry->second.isType<std::string>()) {
177  TEUCHOS_ASSERT(level->IsAvailable("A"));
178  RCP<Matrix> mat;
179  level->Get("A", mat);
180  auto map = mat->getMap();
181  vec = Xpetra::IO<Scalar, LocalOrdinal, GlobalOrdinal, Node>::ReadMultiVector(Teuchos::getValue<std::string>(levelListEntry->second), map);
182  } else
183  vec = Teuchos::getValue<RCP<MultiVector>>(levelListEntry->second);
184  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
185  level->Set(name, vec, NoFactory::get());
186  // M->SetFactory(name, NoFactory::getRCP()); // TAW: generally it is a bad idea to overwrite the factory manager data here
187  // One should do this only in very special cases
188  } else if (name == "Coordinates") // Scalar of Coordinates MV is always double
189  {
190  RCP<realvaluedmultivector_type> vec;
191  if (levelListEntry->second.isType<std::string>()) {
192  TEUCHOS_ASSERT(level->IsAvailable("A"));
193  RCP<Matrix> mat;
194  level->Get("A", mat);
195  size_t blkSize = mat->GetFixedBlockSize();
196  RCP<const Map> nodeMap = mat->getRowMap();
197  if (blkSize > 1) {
198  // Create a nodal map, as coordinates have not been expanded to a DOF map yet.
199  RCP<const Map> dofMap = mat->getRowMap();
200  GO indexBase = dofMap->getIndexBase();
201  size_t numLocalDOFs = dofMap->getLocalNumElements();
202  TEUCHOS_TEST_FOR_EXCEPTION(numLocalDOFs % blkSize, Exceptions::RuntimeError,
203  "HierarchyUtils: block size (" << blkSize << ") is incompatible with the number of local dofs in a row map (" << numLocalDOFs);
204  ArrayView<const GO> GIDs = dofMap->getLocalElementList();
205 
206  Array<GO> nodeGIDs(numLocalDOFs / blkSize);
207  for (size_t i = 0; i < numLocalDOFs; i += blkSize)
208  nodeGIDs[i / blkSize] = (GIDs[i] - indexBase) / blkSize + indexBase;
209 
210  Xpetra::global_size_t INVALID = Teuchos::OrdinalTraits<Xpetra::global_size_t>::invalid();
211  nodeMap = MapFactory::Build(dofMap->lib(), INVALID, nodeGIDs(), indexBase, dofMap->getComm());
212  }
213  vec = Xpetra::IO<typename Teuchos::ScalarTraits<Scalar>::coordinateType, LocalOrdinal, GlobalOrdinal, Node>::ReadMultiVector(Teuchos::getValue<std::string>(levelListEntry->second), nodeMap);
214  } else
215  vec = Teuchos::getValue<RCP<realvaluedmultivector_type>>(levelListEntry->second);
216  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
217  level->Set(name, vec, NoFactory::get());
218  // M->SetFactory(name, NoFactory::getRCP()); // TAW: generally it is a bad idea to overwrite the factory manager data here
219  } else if (name == "Node Comm") {
220  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
221  level->Set(name, Teuchos::getValue<RCP<const Teuchos::Comm<int>>>(levelListEntry->second), NoFactory::get());
222  } else if (name == "DualNodeID2PrimalNodeID") {
223  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
224  level->Set(name, Teuchos::getValue<RCP<std::map<LO, LO>>>(levelListEntry->second), NoFactory::get());
225  } else if (name == "Primal interface DOF map") {
226  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
227  level->Set(name, Teuchos::getValue<RCP<const Map>>(levelListEntry->second), NoFactory::get());
228  } else if (name == "dropMap1") {
229  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
230  level->Set(name, Teuchos::getValue<RCP<const Map>>(levelListEntry->second), NoFactory::get());
231  } else if (name == "dropMap2") {
232  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
233  level->Set(name, Teuchos::getValue<RCP<const Map>>(levelListEntry->second), NoFactory::get());
234  }
235 #ifdef HAVE_MUELU_INTREPID2
236  else if (name == "pcoarsen: element to node map") {
237  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
238  level->Set(name, Teuchos::getValue<RCP<Kokkos::DynRankView<LocalOrdinal, typename Node::device_type>>>(levelListEntry->second), NoFactory::get());
239  }
240 #endif
241  else
242 #ifdef HAVE_MUELU_MATLAB
243  {
244  // Custom variable for Muemex
245  size_t typeNameStart = name.find_first_not_of(' ');
246  size_t typeNameEnd = name.find(' ', typeNameStart);
247  std::string typeName = name.substr(typeNameStart, typeNameEnd - typeNameStart);
248  std::transform(typeName.begin(), typeName.end(), typeName.begin(), ::tolower);
249  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
250  if (typeName == "matrix")
251  level->Set(name, Teuchos::getValue<RCP<Matrix>>(levelListEntry->second), NoFactory::get());
252  else if (typeName == "multivector")
253  level->Set(name, Teuchos::getValue<RCP<MultiVector>>(levelListEntry->second), NoFactory::get());
254  else if (typeName == "map")
255  level->Set(name, Teuchos::getValue<RCP<Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>>>(levelListEntry->second), NoFactory::get());
256  else if (typeName == "ordinalvector")
257  level->Set(name, Teuchos::getValue<RCP<Xpetra::Vector<LocalOrdinal, LocalOrdinal, GlobalOrdinal, Node>>>(levelListEntry->second), NoFactory::get());
258  else if (typeName == "scalar")
259  level->Set(name, Teuchos::getValue<Scalar>(levelListEntry->second), NoFactory::get());
260  else if (typeName == "double")
261  level->Set(name, Teuchos::getValue<double>(levelListEntry->second), NoFactory::get());
262  else if (typeName == "complex")
263  level->Set(name, Teuchos::getValue<std::complex<double>>(levelListEntry->second), NoFactory::get());
264  else if (typeName == "int")
265  level->Set(name, Teuchos::getValue<int>(levelListEntry->second), NoFactory::get());
266  else if (typeName == "string")
267  level->Set(name, Teuchos::getValue<std::string>(levelListEntry->second), NoFactory::get());
268  }
269 #else
270  {
271  throw std::runtime_error("Invalid non-serializable data on list");
272  }
273 #endif
274  }
275  } else if (nonSerialList.isSublist(levelName) && levelName.find("user data") != std::string::npos) {
276  // So far only put data on level 0
277  int levelID = 0;
278  RCP<Level> level = H.GetLevel(levelID);
279 
280  RCP<FactoryManager> M = Teuchos::rcp_dynamic_cast<FactoryManager>(HM.GetFactoryManager(levelID));
281  TEUCHOS_TEST_FOR_EXCEPTION(M.is_null(), Exceptions::InvalidArgument, "MueLu::Utils::AddNonSerializableDataToHierarchy: cannot get FactoryManager");
282 
283  // Grab the user data sublist & loop over parameters
284  const ParameterList& userList = nonSerialList.sublist(levelName);
285  for (ParameterList::ConstIterator userListEntry = userList.begin(); userListEntry != userList.end(); userListEntry++) {
286  const std::string& name = userListEntry->first;
287  TEUCHOS_TEST_FOR_EXCEPTION(name != "P" && name != "R" && name != "K" && name != "M" && name != "Mdiag" &&
288  name != "D0" && name != "Dk_1" && name != "Dk_2" &&
289  name != "Mk_one" && name != "Mk_1_one" && name != "M1_beta" && name != "M1_alpha" &&
290  name != "invMk_1_invBeta" && name != "invMk_2_invAlpha" &&
291  name != "M1" && name != "Ms" && name != "M0inv" &&
292  name != "NodeMatrix" &&
293  name != "Nullspace" && name != "Coordinates" && name != "pcoarsen: element to node map" &&
294  name != "Node Comm" && name != "DualNodeID2PrimalNodeID" && name != "Primal interface DOF map" &&
295  name != "dropMap1" && name != "dropMap2" &&
296  name != "output stream" &&
297  !IsParamValidVariable(name),
298  Exceptions::InvalidArgument,
299  std::string("MueLu::Utils::AddNonSerializableDataToHierarchy: user data parameter list contains unknown data type (") + name + ")");
300  if (name == "P" || name == "R" || name == "K" || name == "M" ||
301  name == "D0" || name == "Dk_1" || name == "Dk_2" ||
302  name == "Mk_one" || name == "Mk_1_one" || name == "M1_beta" || name == "M1_alpha" ||
303  name == "invMk_1_invBeta" || name == "invMk_2_invAlpha" ||
304  name == "M1" || name == "Ms" || name == "M0inv" ||
305  name == "NodeMatrix") {
306  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
307  level->Set(name, Teuchos::getValue<RCP<Matrix>>(userListEntry->second), NoFactory::get());
308  } else if (name == "Mdiag") {
309  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
310  level->Set(name, Teuchos::getValue<RCP<Vector>>(userListEntry->second), NoFactory::get());
311  } else if (name == "Nullspace") {
312  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
313  level->Set(name, Teuchos::getValue<RCP<MultiVector>>(userListEntry->second), NoFactory::get());
314  // M->SetFactory(name, NoFactory::getRCP()); // TAW: generally it is a bad idea to overwrite the factory manager data here
315  // One should do this only in very special cases
316  } else if (name == "Coordinates") { // Scalar of Coordinates MV is always double
317  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
318  level->Set(name, Teuchos::getValue<RCP<realvaluedmultivector_type>>(userListEntry->second), NoFactory::get());
319  } else if (name == "Node Comm") {
320  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
321  level->Set(name, Teuchos::getValue<RCP<const Teuchos::Comm<int>>>(userListEntry->second), NoFactory::get());
322  } else if (name == "DualNodeID2PrimalNodeID") {
323  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
324  level->Set(name, Teuchos::getValue<RCP<std::map<LO, LO>>>(userListEntry->second), NoFactory::get());
325  } else if (name == "Primal interface DOF map") {
326  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
327  level->Set(name, Teuchos::getValue<RCP<const Map>>(userListEntry->second), NoFactory::get());
328  } else if (name == "dropMap1") {
329  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
330  level->Set(name, Teuchos::getValue<RCP<const Map>>(userListEntry->second), NoFactory::get());
331  } else if (name == "dropMap2") {
332  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
333  level->Set(name, Teuchos::getValue<RCP<const Map>>(userListEntry->second), NoFactory::get());
334  }
335 #ifdef HAVE_MUELU_INTREPID2
336  else if (name == "pcoarsen: element to node map") {
337  level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
338  level->Set(name, Teuchos::getValue<RCP<Kokkos::DynRankView<LocalOrdinal, typename Node::device_type>>>(userListEntry->second), NoFactory::get());
339  }
340 #endif
341  else if (name == "output stream") {
342  H.SetMueLuOStream(Teuchos::getValue<RCP<Teuchos::FancyOStream>>(userListEntry->second));
343  } else {
344  // Custom variable
345  size_t typeNameStart = name.find_first_not_of(' ');
346  size_t typeNameEnd = name.find(' ', typeNameStart);
347  std::string typeName = name.substr(typeNameStart, typeNameEnd - typeNameStart);
348  size_t varNameStart = name.find_first_not_of(' ', typeNameEnd);
349  std::string varName = name.substr(varNameStart, name.size());
350  std::transform(typeName.begin(), typeName.end(), typeName.begin(), ::tolower);
351  level->AddKeepFlag(varName, NoFactory::get(), MueLu::UserData);
352  if (typeName == "matrix")
353  level->Set(varName, Teuchos::getValue<RCP<Matrix>>(userListEntry->second), NoFactory::get());
354  else if (typeName == "multivector")
355  level->Set(varName, Teuchos::getValue<RCP<MultiVector>>(userListEntry->second), NoFactory::get());
356  else if (typeName == "vector")
357  level->Set(varName, Teuchos::getValue<RCP<Vector>>(userListEntry->second), NoFactory::get());
358  else if (typeName == "map")
359  level->Set(varName, Teuchos::getValue<RCP<Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>>>(userListEntry->second), NoFactory::get());
360  else if (typeName == "ordinalvector")
361  level->Set(varName, Teuchos::getValue<RCP<Xpetra::Vector<LocalOrdinal, LocalOrdinal, GlobalOrdinal, Node>>>(userListEntry->second), NoFactory::get());
362  else if (typeName == "scalar")
363  level->Set(varName, Teuchos::getValue<Scalar>(userListEntry->second), NoFactory::get());
364  else if (typeName == "double")
365  level->Set(varName, Teuchos::getValue<double>(userListEntry->second), NoFactory::get());
366  else if (typeName == "complex")
367  level->Set(varName, Teuchos::getValue<std::complex<double>>(userListEntry->second), NoFactory::get());
368  else if (typeName == "int")
369  level->Set(varName, Teuchos::getValue<int>(userListEntry->second), NoFactory::get());
370  else if (typeName == "string")
371  level->Set(varName, Teuchos::getValue<std::string>(userListEntry->second), NoFactory::get());
372  else if (typeName == "array<go>")
373  level->Set(varName, Teuchos::getValue<Array<GlobalOrdinal>>(userListEntry->second), NoFactory::get());
374  else if (typeName == "array<lo>")
375  level->Set(varName, Teuchos::getValue<Array<LocalOrdinal>>(userListEntry->second), NoFactory::get());
376  else if (typeName == "arrayrcp<lo>")
377  level->Set(varName, Teuchos::getValue<ArrayRCP<LocalOrdinal>>(userListEntry->second), NoFactory::get());
378  else if (typeName == "arrayrcp<go>")
379  level->Set(varName, Teuchos::getValue<ArrayRCP<GlobalOrdinal>>(userListEntry->second), NoFactory::get());
380  else
381  throw std::runtime_error("Invalid non-serializable data on list");
382  }
383  }
384  // level->print(std::cout, MueLu::Debug);
385  }
386  }
387 }
388 } // namespace MueLu
389 
390 #define MUELU_HIERARCHY_UTILS_SHORT
391 #endif // MUELU_HIERARCHYHELPERS_DEF_HPP
MueLu::FactoryManager
This class specifies the default factory that should generate some data on a Level if the data does n...
Definition: MueLu_FactoryManager_decl.hpp:70
Teuchos::ParameterList::end
ConstIterator end() const
LocalOrdinal
MueLu::DefaultLocalOrdinal LocalOrdinal
Definition: MueLu_UseDefaultTypes.hpp:13
MueLu::Level::Get
T & Get(const std::string &ename, const FactoryBase *factory=NoFactory::get())
Get data without decrementing associated storage counter (i.e., read-only access). Usage: Level-&gt;Get&lt; RCP&lt;Matrix&gt; &gt;(&quot;A&quot;, factory) if factory == NULL =&gt; use default factory.
Definition: MueLu_Level.hpp:154
MueLu::Hierarchy::GetLevel
RCP< Level > & GetLevel(const int levelID=0)
Retrieve a certain level from hierarchy.
Definition: MueLu_Hierarchy_def.hpp:123
MueLu::HierarchyUtils::AddNonSerializableDataToHierarchy
static void AddNonSerializableDataToHierarchy(HierarchyManager &HM, Hierarchy &H, const ParameterList &nonSerialList)
Add non-serializable data to Hierarchy.
Definition: MueLu_HierarchyUtils_def.hpp:67
GO
GlobalOrdinal GO
MueLu::HierarchyManager::GetFactoryManager
RCP< FactoryManagerBase > GetFactoryManager(int levelID) const
Definition: MueLu_HierarchyManager.hpp:79
TEUCHOS_TEST_FOR_EXCEPTION
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
MueLu::Hierarchy::AddNewLevel
void AddNewLevel()
Add a new level at the end of the hierarchy.
Definition: MueLu_Hierarchy_def.hpp:116
MueLu::UserData
User data are always kept. This flag is set automatically when Level::Set(&quot;data&quot;, data) is used...
Definition: MueLu_KeepType.hpp:18
Teuchos::RCP::get
T * get() const
MueLu::MueLuIntrepid::tolower
std::string tolower(const std::string &str)
Definition: MueLu_IntrepidPCoarsenFactory_def.hpp:66
MueLu::IsParamMuemexVariable
bool IsParamMuemexVariable(const std::string &name)
Definition: MueLu_Utilities.cpp:110
Xpetra_Matrix.hpp
MueLu::FactoryManager::GetFactory
const RCP< const FactoryBase > GetFactory(const std::string &varName) const
Get factory associated with a particular data name.
Definition: MueLu_FactoryManager_def.hpp:76
Node
MueLu::DefaultNode Node
Definition: MueLu_UseDefaultTypes.hpp:15
MueLu::NoFactory::get
static const NoFactory * get()
Definition: MueLu_NoFactory.cpp:34
MueLu_HierarchyManager.hpp
GlobalOrdinal
MueLu::DefaultGlobalOrdinal GlobalOrdinal
Definition: MueLu_UseDefaultTypes.hpp:14
Teuchos::ParameterList::isSublist
bool isSublist(const std::string &name) const
Xpetra::IO::ReadMultiVector
static RCP< MultiVector > ReadMultiVector(const std::string &fileName, const RCP< const Map > &map)
Teuchos::ParameterList::ConstIterator
params_t::ConstIterator ConstIterator
MueLu::Level::lib
Xpetra::UnderlyingLib lib()
Definition: MueLu_Level.hpp:327
MueLu::NoFactory::getRCP
static const RCP< const NoFactory > getRCP()
Static Get() functions.
Definition: MueLu_NoFactory.cpp:27
MueLu::Level::AddKeepFlag
void AddKeepFlag(const std::string &ename, const FactoryBase *factory=NoFactory::get(), KeepType keep=MueLu::Keep)
Definition: MueLu_Level.cpp:106
Teuchos::ParameterList::begin
ConstIterator begin() const
MueLu::IsParamValidVariable
bool IsParamValidVariable(const std::string &name)
Definition: MueLu_Utilities.cpp:156
Xpetra::global_size_t
size_t global_size_t
MueLu::Level::Set
void Set(const std::string &ename, const T &entry, const FactoryBase *factory=NoFactory::get())
Definition: MueLu_Level.hpp:120
MueLu::FactoryManager::SetFactory
void SetFactory(const std::string &varName, const RCP< const FactoryBase > &factory)
Set Factory.
Definition: MueLu_FactoryManager_def.hpp:71
MueLu_HierarchyUtils_decl.hpp
Xpetra::IO::Read
static Teuchos::RCP< Xpetra::Matrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Read(const std::string &fileName, Xpetra::UnderlyingLib lib, const RCP< const Teuchos::Comm< int > > &comm, bool binary=false)
Teuchos_ScalarTraits.hpp
Teuchos::ParameterList::sublist
ParameterList & sublist(const std::string &name, bool mustAlreadyExist=false, const std::string &docString="")
MueLu::Exceptions::RuntimeError
Exception throws to report errors in the internal logical of the program.
Definition: MueLu_Exceptions.hpp:36
TEUCHOS_ASSERT
#define TEUCHOS_ASSERT(assertion_test)
MueLu::VerboseObject::SetMueLuOStream
static void SetMueLuOStream(const Teuchos::RCP< Teuchos::FancyOStream > &mueluOStream)
Definition: MueLu_VerboseObject.cpp:97
MueLu::Level::GetComm
RCP< const Teuchos::Comm< int > > GetComm() const
Definition: MueLu_Level.hpp:330
Xpetra_Operator.hpp
MueLu::Hierarchy
Provides methods to build a multigrid hierarchy and apply multigrid cycles.
Definition: MueLu_Hierarchy_decl.hpp:63
typeName
std::string typeName(const T &t)
MueLu::Level::IsAvailable
bool IsAvailable(const std::string &ename, const FactoryBase *factory=NoFactory::get()) const
Test whether a need&#39;s value has been saved.
Definition: MueLu_Level.cpp:281
MueLu::Exceptions::InvalidArgument
Exception throws to report invalid user entry.
Definition: MueLu_Exceptions.hpp:64
MueLu::HierarchyUtils::CopyBetweenHierarchies
static void CopyBetweenHierarchies(Hierarchy &fromHierarchy, Hierarchy &toHierarchy, const std::string fromLabel, const std::string toLabel, const std::string dataType)
Definition: MueLu_HierarchyUtils_def.hpp:31
Teuchos::RCP::is_null
bool is_null() const