MueLu  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
MueLu_Utilities_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_UTILITIES_DECL_HPP
47 #define MUELU_UTILITIES_DECL_HPP
48 
49 #include <string>
50 
51 #include "MueLu_ConfigDefs.hpp"
52 
53 #include <Teuchos_DefaultComm.hpp>
54 #include <Teuchos_ScalarTraits.hpp>
55 #include <Teuchos_ParameterList.hpp>
56 
57 #include <Xpetra_TpetraBlockCrsMatrix_fwd.hpp>
58 #include <Xpetra_TpetraOperator.hpp>
59 #include <Xpetra_CrsMatrix_fwd.hpp>
60 #include <Xpetra_CrsMatrixWrap.hpp>
61 #include <Xpetra_Map_fwd.hpp>
62 #include <Xpetra_Matrix_fwd.hpp>
63 #include <Xpetra_MultiVector_fwd.hpp>
64 #include <Xpetra_MultiVectorFactory_fwd.hpp>
65 #include <Xpetra_Operator_fwd.hpp>
66 #include <Xpetra_Vector_fwd.hpp>
67 #include <Xpetra_VectorFactory_fwd.hpp>
68 
69 #include <Xpetra_MatrixMatrix.hpp>
70 
71 #ifdef HAVE_MUELU_EPETRA
72 #include <Xpetra_EpetraCrsMatrix.hpp>
73 
74 // needed because of inlined function
75 // TODO: remove inline function?
76 #include <Xpetra_EpetraCrsMatrix_fwd.hpp>
77 #include <Xpetra_CrsMatrixWrap_fwd.hpp>
78 
79 #endif
80 
81 #include "MueLu_Exceptions.hpp"
82 
83 #ifdef HAVE_MUELU_EPETRAEXT
84 class Epetra_CrsMatrix;
85 class Epetra_MultiVector;
86 class Epetra_Vector;
87 #include "EpetraExt_Transpose_RowMatrix.h"
88 #endif
89 
90 #include <Tpetra_CrsMatrix.hpp>
91 #include <Tpetra_BlockCrsMatrix.hpp>
92 #include <Tpetra_BlockCrsMatrix_Helpers.hpp>
93 #include <Tpetra_FECrsMatrix.hpp>
94 #include <Tpetra_RowMatrixTransposer.hpp>
95 #include <Tpetra_Map.hpp>
96 #include <Tpetra_MultiVector.hpp>
97 #include <Tpetra_FEMultiVector.hpp>
98 #include <Xpetra_TpetraRowMatrix.hpp>
99 #include <Xpetra_TpetraCrsMatrix_fwd.hpp>
100 #include <Xpetra_TpetraMultiVector_fwd.hpp>
101 
102 #include <MueLu_UtilitiesBase.hpp>
103 
104 namespace MueLu {
105 
106 #ifdef HAVE_MUELU_EPETRA
107 // defined after Utilities class
108 template <typename SC, typename LO, typename GO, typename NO>
109 RCP<Xpetra::CrsMatrixWrap<SC, LO, GO, NO>>
110 Convert_Epetra_CrsMatrix_ToXpetra_CrsMatrixWrap(RCP<Epetra_CrsMatrix>& epAB);
111 
112 template <typename SC, typename LO, typename GO, typename NO>
113 RCP<Xpetra::Matrix<SC, LO, GO, NO>>
114 EpetraCrs_To_XpetraMatrix(const Teuchos::RCP<Epetra_CrsMatrix>& A);
115 
116 template <typename SC, typename LO, typename GO, typename NO>
117 RCP<Xpetra::MultiVector<SC, LO, GO, NO>>
118 EpetraMultiVector_To_XpetraMultiVector(const Teuchos::RCP<Epetra_MultiVector>& V);
119 #endif
120 
121 template <typename SC, typename LO, typename GO, typename NO>
122 RCP<Xpetra::Matrix<SC, LO, GO, NO>>
123 TpetraCrs_To_XpetraMatrix(const Teuchos::RCP<Tpetra::CrsMatrix<SC, LO, GO, NO>>& Atpetra);
124 
125 template <typename SC, typename LO, typename GO, typename NO>
126 RCP<Xpetra::Matrix<SC, LO, GO, NO>>
127 TpetraFECrs_To_XpetraMatrix(const Teuchos::RCP<Tpetra::FECrsMatrix<SC, LO, GO, NO>>& Atpetra);
128 
129 template <typename SC, typename LO, typename GO, typename NO>
130 RCP<Xpetra::MultiVector<SC, LO, GO, NO>>
131 TpetraMultiVector_To_XpetraMultiVector(const Teuchos::RCP<Tpetra::MultiVector<SC, LO, GO, NO>>& Vtpetra);
132 
133 template <typename SC, typename LO, typename GO, typename NO>
134 RCP<Xpetra::MultiVector<SC, LO, GO, NO>>
135 TpetraFEMultiVector_To_XpetraMultiVector(const Teuchos::RCP<Tpetra::FEMultiVector<SC, LO, GO, NO>>& Vtpetra);
136 
137 template <typename SC, typename LO, typename GO, typename NO>
138 void leftRghtDofScalingWithinNode(const Xpetra::Matrix<SC, LO, GO, NO>& Atpetra, size_t blkSize, size_t nSweeps, Teuchos::ArrayRCP<SC>& rowScaling, Teuchos::ArrayRCP<SC>& colScaling);
139 
140 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
141 Teuchos::RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>> importOffRankDroppingInfo(
142  Teuchos::RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>>& localDropMap,
143  Teuchos::RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& Ain);
144 
152 template <class Scalar,
153  class LocalOrdinal = DefaultLocalOrdinal,
154  class GlobalOrdinal = DefaultGlobalOrdinal,
155  class Node = DefaultNode>
156 class Utilities : public UtilitiesBase<Scalar, LocalOrdinal, GlobalOrdinal, Node> {
157 #undef MUELU_UTILITIES_SHORT
158 #include "MueLu_UseShortNames.hpp"
159 
160  public:
161  typedef typename Teuchos::ScalarTraits<Scalar>::magnitudeType Magnitude;
162 
163 #ifdef HAVE_MUELU_EPETRA
164  // @{
166  static RCP<const Epetra_MultiVector> MV2EpetraMV(RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> const vec);
167  static RCP<Epetra_MultiVector> MV2NonConstEpetraMV(RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> vec);
168 
169  static const Epetra_MultiVector& MV2EpetraMV(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& vec);
170  static Epetra_MultiVector& MV2NonConstEpetraMV(Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& vec);
171 
172  static RCP<const Epetra_CrsMatrix> Op2EpetraCrs(RCP<const Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op);
173  static RCP<Epetra_CrsMatrix> Op2NonConstEpetraCrs(RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op);
174 
175  static const Epetra_CrsMatrix& Op2EpetraCrs(const Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op);
176  static Epetra_CrsMatrix& Op2NonConstEpetraCrs(Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op);
177 
178  static const Epetra_Map& Map2EpetraMap(const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>& map);
179  // @}
180 #endif
181 
183  static RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> MV2TpetraMV(RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> const vec);
184  static RCP<Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> MV2NonConstTpetraMV(RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> vec);
185  static RCP<Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> MV2NonConstTpetraMV2(Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& vec);
186 
187  static const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& MV2TpetraMV(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& vec);
188  static Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& MV2NonConstTpetraMV(Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& vec);
189 
190  static RCP<const Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op2TpetraCrs(RCP<const Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op);
191  static RCP<Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op2NonConstTpetraCrs(RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op);
192 
193  static const Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op2TpetraCrs(const Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op);
194  static Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op2NonConstTpetraCrs(Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op);
195 
196  static RCP<const Tpetra::BlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op2TpetraBlockCrs(RCP<const Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op);
197  static RCP<Tpetra::BlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op2NonConstTpetraBlockCrs(RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op);
198 
199  static const Tpetra::BlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op2TpetraBlockCrs(const Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op);
200  static Tpetra::BlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op2NonConstTpetraBlockCrs(Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op);
201 
202  static RCP<const Tpetra::RowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op2TpetraRow(RCP<const Xpetra::Operator<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op);
203  static RCP<Tpetra::RowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op2NonConstTpetraRow(RCP<Xpetra::Operator<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op);
204 
205  static const RCP<const Tpetra::Map<LocalOrdinal, GlobalOrdinal, Node>> Map2TpetraMap(const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>& map);
206 
207  static void MyOldScaleMatrix(Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op, const Teuchos::ArrayRCP<const Scalar>& scalingVector, bool doInverse = true,
208  bool doFillComplete = true, bool doOptimizeStorage = true);
209 
210  static void MyOldScaleMatrix_Epetra(Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op, const Teuchos::ArrayRCP<Scalar>& scalingVector,
211  bool doFillComplete, bool doOptimizeStorage);
212  static void MyOldScaleMatrix_Tpetra(Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op, const Teuchos::ArrayRCP<Scalar>& scalingVector,
213  bool doFillComplete, bool doOptimizeStorage);
214 
215  static RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Transpose(Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op, bool optimizeTranspose = false, const std::string& label = std::string(), const Teuchos::RCP<Teuchos::ParameterList>& params = Teuchos::null);
216 
217  static RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> RealValuedToScalarMultiVector(RCP<Xpetra::MultiVector<typename Teuchos::ScalarTraits<Scalar>::coordinateType, LocalOrdinal, GlobalOrdinal, Node>> X);
218 
219  static RCP<Xpetra::MultiVector<typename Teuchos::ScalarTraits<Scalar>::magnitudeType, LocalOrdinal, GlobalOrdinal, Node>> ExtractCoordinatesFromParameterList(ParameterList& paramList);
220 
221 }; // class Utilities
222 
224 
225 #ifdef HAVE_MUELU_EPETRA
226 
235 template <>
236 class Utilities<double, int, int, Xpetra::EpetraNode> : public UtilitiesBase<double, int, int, Xpetra::EpetraNode> {
237  public:
238  typedef double Scalar;
239  typedef int LocalOrdinal;
240  typedef int GlobalOrdinal;
241  typedef Xpetra::EpetraNode Node;
242  typedef Teuchos::ScalarTraits<Scalar>::magnitudeType Magnitude;
243 #undef MUELU_UTILITIES_SHORT
244 #include "MueLu_UseShortNames.hpp"
245 
246  private:
247  using EpetraMap = Xpetra::EpetraMapT<GlobalOrdinal, Node>;
248  using EpetraMultiVector = Xpetra::EpetraMultiVectorT<GlobalOrdinal, Node>;
249  // using EpetraCrsMatrix = Xpetra::EpetraCrsMatrixT<GlobalOrdinal,Node>;
250  public:
252  // @{
253  static RCP<const Epetra_MultiVector> MV2EpetraMV(RCP<MultiVector> const vec) {
254  RCP<const EpetraMultiVector> tmpVec = rcp_dynamic_cast<EpetraMultiVector>(vec);
255  if (tmpVec == Teuchos::null)
256  throw Exceptions::BadCast("Cast from Xpetra::MultiVector to Xpetra::EpetraMultiVector failed");
257  return tmpVec->getEpetra_MultiVector();
258  }
259  static RCP<Epetra_MultiVector> MV2NonConstEpetraMV(RCP<MultiVector> vec) {
260  RCP<const EpetraMultiVector> tmpVec = rcp_dynamic_cast<EpetraMultiVector>(vec);
261  if (tmpVec == Teuchos::null)
262  throw Exceptions::BadCast("Cast from Xpetra::MultiVector to Xpetra::EpetraMultiVector failed");
263  return tmpVec->getEpetra_MultiVector();
264  }
265 
266  static const Epetra_MultiVector& MV2EpetraMV(const MultiVector& vec) {
267  const EpetraMultiVector& tmpVec = dynamic_cast<const EpetraMultiVector&>(vec);
268  return *(tmpVec.getEpetra_MultiVector());
269  }
270  static Epetra_MultiVector& MV2NonConstEpetraMV(MultiVector& vec) {
271  const EpetraMultiVector& tmpVec = dynamic_cast<const EpetraMultiVector&>(vec);
272  return *(tmpVec.getEpetra_MultiVector());
273  }
274 
275  static RCP<const Epetra_CrsMatrix> Op2EpetraCrs(RCP<const Matrix> Op) {
276  RCP<const CrsMatrixWrap> crsOp = rcp_dynamic_cast<const CrsMatrixWrap>(Op);
277  if (crsOp == Teuchos::null)
278  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
279  const RCP<const EpetraCrsMatrix>& tmp_ECrsMtx = rcp_dynamic_cast<const EpetraCrsMatrix>(crsOp->getCrsMatrix());
280  if (tmp_ECrsMtx == Teuchos::null)
281  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::EpetraCrsMatrix failed");
282  return tmp_ECrsMtx->getEpetra_CrsMatrix();
283  }
284  static RCP<Epetra_CrsMatrix> Op2NonConstEpetraCrs(RCP<Matrix> Op) {
285  RCP<const CrsMatrixWrap> crsOp = rcp_dynamic_cast<const CrsMatrixWrap>(Op);
286  if (crsOp == Teuchos::null)
287  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
288  const RCP<const EpetraCrsMatrix>& tmp_ECrsMtx = rcp_dynamic_cast<const EpetraCrsMatrix>(crsOp->getCrsMatrix());
289  if (tmp_ECrsMtx == Teuchos::null)
290  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::EpetraCrsMatrix failed");
291  return tmp_ECrsMtx->getEpetra_CrsMatrixNonConst();
292  }
293 
294  static const Epetra_CrsMatrix& Op2EpetraCrs(const Matrix& Op) {
295  try {
296  const CrsMatrixWrap& crsOp = dynamic_cast<const CrsMatrixWrap&>(Op);
297  try {
298  const EpetraCrsMatrix& tmp_ECrsMtx = dynamic_cast<const EpetraCrsMatrix&>(*crsOp.getCrsMatrix());
299  return *tmp_ECrsMtx.getEpetra_CrsMatrix();
300  } catch (std::bad_cast&) {
301  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::EpetraCrsMatrix failed");
302  }
303  } catch (std::bad_cast&) {
304  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
305  }
306  }
307  static Epetra_CrsMatrix& Op2NonConstEpetraCrs(Matrix& Op) {
308  try {
309  CrsMatrixWrap& crsOp = dynamic_cast<CrsMatrixWrap&>(Op);
310  try {
311  EpetraCrsMatrix& tmp_ECrsMtx = dynamic_cast<EpetraCrsMatrix&>(*crsOp.getCrsMatrix());
312  return *tmp_ECrsMtx.getEpetra_CrsMatrixNonConst();
313  } catch (std::bad_cast&) {
314  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::EpetraCrsMatrix failed");
315  }
316  } catch (std::bad_cast&) {
317  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
318  }
319  }
320 
321  static const Epetra_Map& Map2EpetraMap(const Map& map) {
322  RCP<const EpetraMap> xeMap = rcp_dynamic_cast<const EpetraMap>(rcpFromRef(map));
323  if (xeMap == Teuchos::null)
324  throw Exceptions::BadCast("Utilities::Map2EpetraMap : Cast from Xpetra::Map to Xpetra::EpetraMap failed");
325  return xeMap->getEpetra_Map();
326  }
327  // @}
328 
330  static RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> MV2TpetraMV(RCP<MultiVector> const vec) {
331 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
332  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
333  throw Exceptions::RuntimeError("MV2TpetraMV: Tpetra has not been compiled with support for LO=GO=int.");
334 #else
335  RCP<const Xpetra::TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> tmpVec = rcp_dynamic_cast<Xpetra::TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(vec);
336  if (tmpVec == Teuchos::null)
337  throw Exceptions::BadCast("Cast from Xpetra::MultiVector to Xpetra::TpetraMultiVector failed");
338  return tmpVec->getTpetra_MultiVector();
339 #endif
340  }
341  static RCP<Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> MV2NonConstTpetraMV(RCP<MultiVector> vec) {
342 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
343  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
344  throw Exceptions::RuntimeError("MV2NonConstTpetraMV: Tpetra has not been compiled with support for LO=GO=int.");
345 #else
346  RCP<const Xpetra::TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> tmpVec = rcp_dynamic_cast<Xpetra::TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(vec);
347  if (tmpVec == Teuchos::null)
348  throw Exceptions::BadCast("Cast from Xpetra::MultiVector to Xpetra::TpetraMultiVector failed");
349  return tmpVec->getTpetra_MultiVector();
350 #endif
351  }
352  static RCP<Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> MV2NonConstTpetraMV2(MultiVector& vec) {
353 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
354  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
355  throw Exceptions::RuntimeError("MV2NonConstTpetraMV2: Tpetra has not been compiled with support for LO=GO=int.");
356 #else
357  const Xpetra::TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& tmpVec = dynamic_cast<const Xpetra::TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>&>(vec);
358  return tmpVec.getTpetra_MultiVector();
359 #endif
360  }
361 
362  static const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& MV2TpetraMV(const MultiVector& vec) {
363 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
364  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
365  throw Exceptions::RuntimeError("MV2TpetraMV: Tpetra has not been compiled with support for LO=GO=int.");
366 #else
367  const Xpetra::TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& tmpVec = dynamic_cast<const Xpetra::TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>&>(vec);
368  return *(tmpVec.getTpetra_MultiVector());
369 #endif
370  }
371  static Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& MV2NonConstTpetraMV(MultiVector& vec) {
372 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
373  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
374  throw Exceptions::RuntimeError("MV2NonConstTpetraMV: Tpetra has not been compiled with support for LO=GO=int.");
375 #else
376  const Xpetra::TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& tmpVec = dynamic_cast<const Xpetra::TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>&>(vec);
377  return *(tmpVec.getTpetra_MultiVector());
378 #endif
379  }
380 
381  static RCP<const Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op2TpetraCrs(RCP<const Matrix> Op) {
382 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
383  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
384  throw Exceptions::RuntimeError("Op2TpetraCrs: Tpetra has not been compiled with support for LO=GO=int.");
385 #else
386  // Get the underlying Tpetra Mtx
387  RCP<const CrsMatrixWrap> crsOp = rcp_dynamic_cast<const CrsMatrixWrap>(Op);
388  if (crsOp == Teuchos::null)
389  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
390  const RCP<const Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& tmp_ECrsMtx = rcp_dynamic_cast<const Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(crsOp->getCrsMatrix());
391  if (tmp_ECrsMtx == Teuchos::null)
392  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::TpetraCrsMatrix failed");
393  return tmp_ECrsMtx->getTpetra_CrsMatrix();
394 #endif
395  }
396  static RCP<Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op2NonConstTpetraCrs(RCP<Matrix> Op) {
397 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
398  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
399  throw Exceptions::RuntimeError("Op2NonConstTpetraCrs: Tpetra has not been compiled with support for LO=GO=int.");
400 #else
401  RCP<const CrsMatrixWrap> crsOp = rcp_dynamic_cast<const CrsMatrixWrap>(Op);
402  if (crsOp == Teuchos::null)
403  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
404  const RCP<const Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& tmp_ECrsMtx = rcp_dynamic_cast<const Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(crsOp->getCrsMatrix());
405  if (tmp_ECrsMtx == Teuchos::null)
406  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::TpetraCrsMatrix failed");
407  return tmp_ECrsMtx->getTpetra_CrsMatrixNonConst();
408 #endif
409  };
410 
411  static const Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op2TpetraCrs(const Matrix& Op) {
412 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
413  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
414  throw Exceptions::RuntimeError("Op2TpetraCrs: Tpetra has not been compiled with support for LO=GO=int.");
415 #else
416  try {
417  const CrsMatrixWrap& crsOp = dynamic_cast<const CrsMatrixWrap&>(Op);
418  try {
419  const Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& tmp_ECrsMtx = dynamic_cast<const Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>&>(*crsOp.getCrsMatrix());
420  return *tmp_ECrsMtx.getTpetra_CrsMatrix();
421  } catch (std::bad_cast&) {
422  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::TpetraCrsMatrix failed");
423  }
424  } catch (std::bad_cast&) {
425  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
426  }
427 #endif
428  }
429  static Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op2NonConstTpetraCrs(Matrix& Op) {
430 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
431  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
432  throw Exceptions::RuntimeError("Op2NonConstTpetraCrs: Tpetra has not been compiled with support for LO=GO=int.");
433 #else
434  try {
435  CrsMatrixWrap& crsOp = dynamic_cast<CrsMatrixWrap&>(Op);
436  try {
437  Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& tmp_ECrsMtx = dynamic_cast<Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>&>(*crsOp.getCrsMatrix());
438  return *tmp_ECrsMtx.getTpetra_CrsMatrixNonConst();
439  } catch (std::bad_cast&) {
440  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::TpetraCrsMatrix failed");
441  }
442  } catch (std::bad_cast&) {
443  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
444  }
445 #endif
446  }
447 
448  static RCP<const Tpetra::BlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op2TpetraBlockCrs(RCP<const Matrix> Op) {
449 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
450  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
451  throw Exceptions::RuntimeError("Op2TpetraBlockCrs: Tpetra has not been compiled with support for LO=GO=int.");
452 #else
453  // Get the underlying Tpetra Mtx
454  RCP<const CrsMatrixWrap> crsOp = rcp_dynamic_cast<const CrsMatrixWrap>(Op);
455  if (crsOp == Teuchos::null)
456  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
457  const RCP<const Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& tmp_ECrsMtx = rcp_dynamic_cast<const Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(crsOp->getCrsMatrix());
458  if (tmp_ECrsMtx == Teuchos::null)
459  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::TpetraBlockCrsMatrix failed");
460  return tmp_ECrsMtx->getTpetra_BlockCrsMatrix();
461 #endif
462  }
463 
464  static RCP<Tpetra::BlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op2NonConstTpetraBlockCrs(RCP<Matrix> Op) {
465 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
466  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
467  throw Exceptions::RuntimeError("Op2NonConstTpetraBlockCrs: Tpetra has not been compiled with support for LO=GO=int.");
468 #else
469  RCP<const CrsMatrixWrap> crsOp = rcp_dynamic_cast<const CrsMatrixWrap>(Op);
470  if (crsOp == Teuchos::null)
471  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
472  const RCP<const Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& tmp_ECrsMtx = rcp_dynamic_cast<const Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(crsOp->getCrsMatrix());
473  if (tmp_ECrsMtx == Teuchos::null)
474  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::TpetraBlockCrsMatrix failed");
475  return tmp_ECrsMtx->getTpetra_BlockCrsMatrixNonConst();
476 #endif
477  };
478 
479  static const Tpetra::BlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op2TpetraBlockCrs(const Matrix& Op) {
480 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
481  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
482  throw Exceptions::RuntimeError("Op2TpetraBlockCrs: Tpetra has not been compiled with support for LO=GO=int.");
483 #else
484  try {
485  const CrsMatrixWrap& crsOp = dynamic_cast<const CrsMatrixWrap&>(Op);
486  try {
487  const Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& tmp_ECrsMtx = dynamic_cast<const Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>&>(*crsOp.getCrsMatrix());
488  return *tmp_ECrsMtx.getTpetra_BlockCrsMatrix();
489  } catch (std::bad_cast&) {
490  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::TpetraBlockCrsMatrix failed");
491  }
492  } catch (std::bad_cast&) {
493  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
494  }
495 #endif
496  }
497  static Tpetra::BlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Op2NonConstTpetraBlockCrs(Matrix& Op) {
498 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
499  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
500  throw Exceptions::RuntimeError("Op2NonConstTpetraCrs: Tpetra has not been compiled with support for LO=GO=int.");
501 #else
502  try {
503  CrsMatrixWrap& crsOp = dynamic_cast<CrsMatrixWrap&>(Op);
504  try {
505  Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& tmp_ECrsMtx = dynamic_cast<Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>&>(*crsOp.getCrsMatrix());
506  return *tmp_ECrsMtx.getTpetra_BlockCrsMatrixNonConst();
507  } catch (std::bad_cast&) {
508  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::TpetraBlockCrsMatrix failed");
509  }
510  } catch (std::bad_cast&) {
511  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
512  }
513 #endif
514  }
515 
516  static RCP<const Tpetra::RowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op2TpetraRow(RCP<const Operator> Op) {
517 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
518  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
519  throw Exceptions::RuntimeError("Op2TpetraRow: Tpetra has not been compiled with support for LO=GO=int.");
520 #else
521  RCP<const Matrix> mat = rcp_dynamic_cast<const Matrix>(Op);
522  RCP<const Xpetra::TpetraRowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> rmat = rcp_dynamic_cast<const Xpetra::TpetraRowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(Op);
523  if (!mat.is_null()) {
524  RCP<const CrsMatrixWrap> crsOp = rcp_dynamic_cast<const CrsMatrixWrap>(mat);
525  if (crsOp == Teuchos::null)
526  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
527 
528  RCP<const CrsMatrix> crsMat = crsOp->getCrsMatrix();
529  const RCP<const Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> tmp_Crs = rcp_dynamic_cast<const Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(crsMat);
530  RCP<const Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> tmp_BlockCrs;
531  if (!tmp_Crs.is_null()) {
532  return tmp_Crs->getTpetra_CrsMatrixNonConst();
533  } else {
534  tmp_BlockCrs = rcp_dynamic_cast<const Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(crsMat);
535  if (tmp_BlockCrs.is_null())
536  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::TpetraCrsMatrix and Xpetra::TpetraBlockCrsMatrix failed");
537  return tmp_BlockCrs->getTpetra_BlockCrsMatrixNonConst();
538  }
539  } else if (!rmat.is_null()) {
540  return rmat->getTpetra_RowMatrix();
541  } else {
542  RCP<const TpetraOperator> tpOp = rcp_dynamic_cast<const TpetraOperator>(Op, true);
543  RCP<const Tpetra::Operator<Scalar, LocalOrdinal, GlobalOrdinal, Node>> tOp = tpOp->getOperatorConst();
544  RCP<const Tpetra::RowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> tRow = rcp_dynamic_cast<const Tpetra::RowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(tOp, true);
545  return tRow;
546  }
547 #endif
548  }
549 
550  static RCP<Tpetra::RowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Op2NonConstTpetraRow(RCP<Operator> Op) {
551 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
552  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
553  throw Exceptions::RuntimeError("Op2NonConstTpetraRow: Tpetra has not been compiled with support for LO=GO=int.");
554 #else
555  RCP<Matrix> mat = rcp_dynamic_cast<Matrix>(Op);
556  RCP<Xpetra::TpetraRowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> rmat = rcp_dynamic_cast<Xpetra::TpetraRowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(Op);
557  if (!mat.is_null()) {
558  RCP<const CrsMatrixWrap> crsOp = rcp_dynamic_cast<const CrsMatrixWrap>(mat);
559  if (crsOp == Teuchos::null)
560  throw Exceptions::BadCast("Cast from Xpetra::Matrix to Xpetra::CrsMatrixWrap failed");
561 
562  RCP<const CrsMatrix> crsMat = crsOp->getCrsMatrix();
563  const RCP<const Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> tmp_Crs = rcp_dynamic_cast<const Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(crsMat);
564  RCP<const Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> tmp_BlockCrs;
565  if (!tmp_Crs.is_null()) {
566  return tmp_Crs->getTpetra_CrsMatrixNonConst();
567  } else {
568  tmp_BlockCrs = rcp_dynamic_cast<const Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(crsMat);
569  if (tmp_BlockCrs.is_null())
570  throw Exceptions::BadCast("Cast from Xpetra::CrsMatrix to Xpetra::TpetraCrsMatrix and Xpetra::TpetraBlockCrsMatrix failed");
571  return tmp_BlockCrs->getTpetra_BlockCrsMatrixNonConst();
572  }
573  } else if (!rmat.is_null()) {
574  return rmat->getTpetra_RowMatrixNonConst();
575  } else {
576  RCP<TpetraOperator> tpOp = rcp_dynamic_cast<TpetraOperator>(Op, true);
577  RCP<Tpetra::Operator<Scalar, LocalOrdinal, GlobalOrdinal, Node>> tOp = tpOp->getOperator();
578  RCP<Tpetra::RowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> tRow = rcp_dynamic_cast<Tpetra::RowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(tOp, true);
579  return tRow;
580  }
581 #endif
582  };
583 
584  static const RCP<const Tpetra::Map<LocalOrdinal, GlobalOrdinal, Node>> Map2TpetraMap(const Map& map) {
585 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
586  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
587  throw Exceptions::RuntimeError("Map2TpetraMap: Tpetra has not been compiled with support for LO=GO=int.");
588 #else
589  const RCP<const Xpetra::TpetraMap<LocalOrdinal, GlobalOrdinal, Node>>& tmp_TMap = rcp_dynamic_cast<const Xpetra::TpetraMap<LocalOrdinal, GlobalOrdinal, Node>>(rcpFromRef(map));
590  if (tmp_TMap == Teuchos::null)
591  throw Exceptions::BadCast("Utilities::Map2TpetraMap : Cast from Xpetra::Map to Xpetra::TpetraMap failed");
592  return tmp_TMap->getTpetra_Map();
593 #endif
594  };
595 
596  static void MyOldScaleMatrix(Matrix& Op, const Teuchos::ArrayRCP<const Scalar>& scalingVector, bool doInverse = true,
597  bool doFillComplete = true, bool doOptimizeStorage = true) {
598  Scalar one = Teuchos::ScalarTraits<Scalar>::one();
599  Teuchos::ArrayRCP<Scalar> sv(scalingVector.size());
600  if (doInverse) {
601  for (int i = 0; i < scalingVector.size(); ++i)
602  sv[i] = one / scalingVector[i];
603  } else {
604  for (int i = 0; i < scalingVector.size(); ++i)
605  sv[i] = scalingVector[i];
606  }
607 
608  switch (Op.getRowMap()->lib()) {
609  case Xpetra::UseTpetra:
610  MyOldScaleMatrix_Tpetra(Op, sv, doFillComplete, doOptimizeStorage);
611  break;
612 
613  case Xpetra::UseEpetra:
614  MyOldScaleMatrix_Epetra(Op, sv, doFillComplete, doOptimizeStorage);
615  break;
616 
617  default:
618  throw Exceptions::RuntimeError("Only Epetra and Tpetra matrices can be scaled.");
619  }
620  }
621 
622  // TODO This is the <double,int,int> specialization
623  static void MyOldScaleMatrix_Tpetra(Matrix& Op, const Teuchos::ArrayRCP<Scalar>& scalingVector,
624  bool doFillComplete, bool doOptimizeStorage) {
625 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
626  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
627  throw Exceptions::RuntimeError("Matrix scaling is not possible because Tpetra has not been compiled with support for LO=GO=int.");
628 #else
629  try {
630  Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& tpOp = Op2NonConstTpetraCrs(Op);
631 
632  const RCP<const Tpetra::Map<LocalOrdinal, GlobalOrdinal, Node>> rowMap = tpOp.getRowMap();
633  const RCP<const Tpetra::Map<LocalOrdinal, GlobalOrdinal, Node>> domainMap = tpOp.getDomainMap();
634  const RCP<const Tpetra::Map<LocalOrdinal, GlobalOrdinal, Node>> rangeMap = tpOp.getRangeMap();
635 
636  size_t maxRowSize = tpOp.getLocalMaxNumRowEntries();
637  if (maxRowSize == Teuchos::as<size_t>(-1)) // hasn't been determined yet
638  maxRowSize = 20;
639 
640  std::vector<Scalar> scaledVals(maxRowSize);
641  if (tpOp.isFillComplete())
642  tpOp.resumeFill();
643 
644  if (Op.isLocallyIndexed() == true) {
645  typename Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>::local_inds_host_view_type cols;
646  typename Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>::values_host_view_type vals;
647  for (size_t i = 0; i < rowMap->getLocalNumElements(); ++i) {
648  tpOp.getLocalRowView(i, cols, vals);
649  size_t nnz = tpOp.getNumEntriesInLocalRow(i);
650  if (nnz > maxRowSize) {
651  maxRowSize = nnz;
652  scaledVals.resize(maxRowSize);
653  }
654  for (size_t j = 0; j < nnz; ++j)
655  scaledVals[j] = vals[j] * scalingVector[i];
656 
657  if (nnz > 0) {
658  Teuchos::ArrayView<const LocalOrdinal> cols_view(cols.data(), nnz);
659  Teuchos::ArrayView<const Scalar> valview(&scaledVals[0], nnz);
660  tpOp.replaceLocalValues(i, cols_view, valview);
661  }
662  } // for (size_t i=0; ...
663 
664  } else {
665  typename Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>::local_inds_host_view_type cols;
666  typename Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>::values_host_view_type vals;
667 
668  for (size_t i = 0; i < rowMap->getLocalNumElements(); ++i) {
669  GlobalOrdinal gid = rowMap->getGlobalElement(i);
670  tpOp.getGlobalRowView(gid, cols, vals);
671  size_t nnz = tpOp.getNumEntriesInGlobalRow(gid);
672  if (nnz > maxRowSize) {
673  maxRowSize = nnz;
674  scaledVals.resize(maxRowSize);
675  }
676  // FIXME FIXME FIXME FIXME FIXME FIXME
677  for (size_t j = 0; j < nnz; ++j)
678  scaledVals[j] = vals[j] * scalingVector[i]; // FIXME i or gid?
679 
680  if (nnz > 0) {
681  Teuchos::ArrayView<const LocalOrdinal> cols_view(cols.data(), nnz);
682  Teuchos::ArrayView<const Scalar> valview(&scaledVals[0], nnz);
683  tpOp.replaceGlobalValues(gid, cols_view, valview);
684  }
685  } // for (size_t i=0; ...
686  }
687 
688  if (doFillComplete) {
689  if (domainMap == Teuchos::null || rangeMap == Teuchos::null)
690  throw Exceptions::RuntimeError("In Utilities::Scaling: cannot fillComplete because the domain and/or range map hasn't been defined");
691 
692  RCP<Teuchos::ParameterList> params = rcp(new Teuchos::ParameterList());
693  params->set("Optimize Storage", doOptimizeStorage);
694  params->set("No Nonlocal Changes", true);
695  Op.fillComplete(Op.getDomainMap(), Op.getRangeMap(), params);
696  }
697  } catch (...) {
698  throw Exceptions::RuntimeError("Only Tpetra::CrsMatrix types can be scaled (Err.1)");
699  }
700 #endif
701  }
702 
703  static void MyOldScaleMatrix_Epetra(Matrix& Op, const Teuchos::ArrayRCP<Scalar>& scalingVector, bool /* doFillComplete */, bool /* doOptimizeStorage */) {
704 #ifdef HAVE_MUELU_EPETRA
705  try {
706  // const Epetra_CrsMatrix& epOp = Utilities<double,int,int>::Op2NonConstEpetraCrs(Op);
707  const Epetra_CrsMatrix& epOp = Op2NonConstEpetraCrs(Op);
708 
709  Epetra_Map const& rowMap = epOp.RowMap();
710  int nnz;
711  double* vals;
712  int* cols;
713 
714  for (int i = 0; i < rowMap.NumMyElements(); ++i) {
715  epOp.ExtractMyRowView(i, nnz, vals, cols);
716  for (int j = 0; j < nnz; ++j)
717  vals[j] *= scalingVector[i];
718  }
719 
720  } catch (...) {
721  throw Exceptions::RuntimeError("Only Epetra_CrsMatrix types can be scaled");
722  }
723 #else
724  throw Exceptions::RuntimeError("Matrix scaling is not possible because Epetra has not been enabled.");
725 #endif // HAVE_MUELU_EPETRA
726  }
727 
733  static RCP<Matrix> Transpose(Matrix& Op, bool /* optimizeTranspose */ = false, const std::string& label = std::string(), const Teuchos::RCP<Teuchos::ParameterList>& params = Teuchos::null) {
734  switch (Op.getRowMap()->lib()) {
735  case Xpetra::UseTpetra: {
736 #if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
737  (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))
738  throw Exceptions::RuntimeError("Utilities::Transpose: Tpetra is not compiled with LO=GO=int. Add TPETRA_INST_INT_INT:BOOL=ON to your configuration!");
739 #else
740  using Helpers = Xpetra::Helpers<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
741  /***************************************************************/
742  if (Helpers::isTpetraCrs(Op)) {
743  const Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& tpetraOp = Utilities<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Op2TpetraCrs(Op);
744 
745  // Compute the transpose A of the Tpetra matrix tpetraOp.
746  RCP<Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> A;
747  Tpetra::RowMatrixTransposer<Scalar, LocalOrdinal, GlobalOrdinal, Node> transposer(rcpFromRef(tpetraOp), label);
748 
749  {
750  using Teuchos::ParameterList;
751  using Teuchos::rcp;
752  RCP<ParameterList> transposeParams = params.is_null() ? rcp(new ParameterList) : rcp(new ParameterList(*params));
753  transposeParams->set("sort", false);
754  A = transposer.createTranspose(transposeParams);
755  }
756 
757  RCP<Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> AA = rcp(new Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>(A));
758  RCP<CrsMatrix> AAA = rcp_implicit_cast<CrsMatrix>(AA);
759  RCP<Matrix> AAAA = rcp(new CrsMatrixWrap(AAA));
760 
761  if (Op.IsView("stridedMaps"))
762  AAAA->CreateView("stridedMaps", Teuchos::rcpFromRef(Op), true /*doTranspose*/);
763 
764  return AAAA;
765  }
766  /***************************************************************/
767  else if (Helpers::isTpetraBlockCrs(Op)) {
768  using BCRS = Tpetra::BlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
769  // using CRS = Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>;
770  const BCRS& tpetraOp = Utilities<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Op2TpetraBlockCrs(Op);
771  RCP<BCRS> At;
772  {
773  Tpetra::BlockCrsMatrixTransposer<Scalar, LocalOrdinal, GlobalOrdinal, Node> transposer(rcpFromRef(tpetraOp), label);
774 
775  using Teuchos::ParameterList;
776  using Teuchos::rcp;
777  RCP<ParameterList> transposeParams = params.is_null() ? rcp(new ParameterList) : rcp(new ParameterList(*params));
778  transposeParams->set("sort", false);
779  At = transposer.createTranspose(transposeParams);
780  }
781 
782  RCP<Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>> AA = rcp(new Xpetra::TpetraBlockCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>(At));
783  RCP<CrsMatrix> AAA = rcp_implicit_cast<CrsMatrix>(AA);
784  RCP<Matrix> AAAA = rcp(new CrsMatrixWrap(AAA));
785 
786  if (Op.IsView("stridedMaps"))
787  AAAA->CreateView("stridedMaps", Teuchos::rcpFromRef(Op), true /*doTranspose*/);
788 
789  return AAAA;
790 
791  }
792  /***************************************************************/
793  else {
794  throw Exceptions::RuntimeError("Utilities::Transpose failed, perhaps because matrix is not a Crs or BlockCrs matrix");
795  }
796 #endif
797  }
798  case Xpetra::UseEpetra: {
799 #if defined(HAVE_MUELU_EPETRA) && defined(HAVE_MUELU_EPETRAEXT)
800  Teuchos::TimeMonitor tm(*Teuchos::TimeMonitor::getNewTimer("ZZ Entire Transpose"));
801  // Epetra case
802  Epetra_CrsMatrix& epetraOp = Utilities<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Op2NonConstEpetraCrs(Op);
803  EpetraExt::RowMatrix_Transpose transposer;
804  Epetra_CrsMatrix* A = dynamic_cast<Epetra_CrsMatrix*>(&transposer(epetraOp));
805  transposer.ReleaseTranspose(); // So we can keep A in Muelu...
806 
807  RCP<Epetra_CrsMatrix> rcpA(A);
808  RCP<EpetraCrsMatrix> AA = rcp(new EpetraCrsMatrix(rcpA));
809  RCP<CrsMatrix> AAA = rcp_implicit_cast<CrsMatrix>(AA);
810  RCP<Matrix> AAAA = rcp(new CrsMatrixWrap(AAA));
811 
812  if (Op.IsView("stridedMaps"))
813  AAAA->CreateView("stridedMaps", Teuchos::rcpFromRef(Op), true /*doTranspose*/);
814 
815  return AAAA;
816 #else
817  throw Exceptions::RuntimeError("Epetra (Err. 2)");
818 #endif
819  }
820  default:
821  throw Exceptions::RuntimeError("Only Epetra and Tpetra matrices can be transposed.");
822  }
823 
824  TEUCHOS_UNREACHABLE_RETURN(Teuchos::null);
825  }
826 
827  static RCP<Xpetra::MultiVector<typename Teuchos::ScalarTraits<Scalar>::magnitudeType, LocalOrdinal, GlobalOrdinal, Node>>
828  RealValuedToScalarMultiVector(RCP<Xpetra::MultiVector<typename Teuchos::ScalarTraits<Scalar>::coordinateType, LocalOrdinal, GlobalOrdinal, Node>> X) {
829  RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> Xscalar = rcp_dynamic_cast<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>(X, true);
830  return Xscalar;
831  }
832 
835  static RCP<Xpetra::MultiVector<typename Teuchos::ScalarTraits<Scalar>::magnitudeType, LocalOrdinal, GlobalOrdinal, Node>> ExtractCoordinatesFromParameterList(ParameterList& paramList) {
836  RCP<Xpetra::MultiVector<typename Teuchos::ScalarTraits<Scalar>::magnitudeType, LocalOrdinal, GlobalOrdinal, Node>> coordinates = Teuchos::null;
837 
838  // check whether coordinates are contained in parameter list
839  if (paramList.isParameter("Coordinates") == false)
840  return coordinates;
841 
842 #if (defined(EPETRA_HAVE_OMP) && defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT)) || \
843  (!defined(EPETRA_HAVE_OMP) && defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))
844 
845  // define Tpetra::MultiVector type with Scalar=float only if
846  // * ETI is turned off, since then the compiler will instantiate it automatically OR
847  // * Tpetra is instantiated on Scalar=float
848 #if !defined(HAVE_TPETRA_EXPLICIT_INSTANTIATION) || defined(HAVE_TPETRA_INST_FLOAT)
849  typedef Tpetra::MultiVector<float, LocalOrdinal, GlobalOrdinal, Node> tfMV;
850  RCP<tfMV> floatCoords = Teuchos::null;
851 #endif
852 
853  // define Tpetra::MultiVector type with Scalar=double only if
854  // * ETI is turned off, since then the compiler will instantiate it automatically OR
855  // * Tpetra is instantiated on Scalar=double
856  typedef Tpetra::MultiVector<typename Teuchos::ScalarTraits<Scalar>::magnitudeType, LocalOrdinal, GlobalOrdinal, Node> tdMV;
857  RCP<tdMV> doubleCoords = Teuchos::null;
858  if (paramList.isType<RCP<tdMV>>("Coordinates")) {
859  // Coordinates are stored as a double vector
860  doubleCoords = paramList.get<RCP<tdMV>>("Coordinates");
861  paramList.remove("Coordinates");
862  }
863 #if !defined(HAVE_TPETRA_EXPLICIT_INSTANTIATION) || defined(HAVE_TPETRA_INST_FLOAT)
864  else if (paramList.isType<RCP<tfMV>>("Coordinates")) {
865  // check if coordinates are stored as a float vector
866  floatCoords = paramList.get<RCP<tfMV>>("Coordinates");
867  paramList.remove("Coordinates");
868  doubleCoords = rcp(new tdMV(floatCoords->getMap(), floatCoords->getNumVectors()));
869  deep_copy(*doubleCoords, *floatCoords);
870  }
871 #endif
872  // We have the coordinates in a Tpetra double vector
873  if (doubleCoords != Teuchos::null) {
874  coordinates = Teuchos::rcp(new Xpetra::TpetraMultiVector<typename Teuchos::ScalarTraits<Scalar>::magnitudeType, LocalOrdinal, GlobalOrdinal, Node>(doubleCoords));
875  TEUCHOS_TEST_FOR_EXCEPT(doubleCoords->getNumVectors() != coordinates->getNumVectors());
876  }
877 #endif // Tpetra instantiated on GO=int and EpetraNode
878 
879 #if defined(HAVE_MUELU_EPETRA)
880  RCP<Epetra_MultiVector> doubleEpCoords;
881  if (paramList.isType<RCP<Epetra_MultiVector>>("Coordinates")) {
882  doubleEpCoords = paramList.get<RCP<Epetra_MultiVector>>("Coordinates");
883  paramList.remove("Coordinates");
884  RCP<Xpetra::EpetraMultiVectorT<GlobalOrdinal, Node>> epCoordinates = Teuchos::rcp(new Xpetra::EpetraMultiVectorT<GlobalOrdinal, Node>(doubleEpCoords));
885  coordinates = rcp_dynamic_cast<Xpetra::MultiVector<typename Teuchos::ScalarTraits<Scalar>::magnitudeType, LocalOrdinal, GlobalOrdinal, Node>>(epCoordinates);
886  TEUCHOS_TEST_FOR_EXCEPT(doubleEpCoords->NumVectors() != Teuchos::as<int>(coordinates->getNumVectors()));
887  }
888 #endif
889 
890  // check for Xpetra coordinates vector
891  if (paramList.isType<decltype(coordinates)>("Coordinates")) {
892  coordinates = paramList.get<decltype(coordinates)>("Coordinates");
893  }
894 
895  TEUCHOS_TEST_FOR_EXCEPT(Teuchos::is_null(coordinates));
896  return coordinates;
897  }
898 
899 }; // class Utilities (specialization SC=double LO=GO=int)
900 
901 #endif // HAVE_MUELU_EPETRA
902 
932 long ExtractNonSerializableData(const Teuchos::ParameterList& inList, Teuchos::ParameterList& serialList, Teuchos::ParameterList& nonSerialList);
933 
937 void TokenizeStringAndStripWhiteSpace(const std::string& stream, std::vector<std::string>& tokenList, const char* token = ",");
938 
941 bool IsParamMuemexVariable(const std::string& name);
942 
945 bool IsParamValidVariable(const std::string& name);
946 
947 #ifdef HAVE_MUELU_EPETRA
948 
952 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
953 RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
954 EpetraCrs_To_XpetraMatrix(const Teuchos::RCP<Epetra_CrsMatrix>& A) {
955  typedef Xpetra::EpetraCrsMatrixT<GlobalOrdinal, Node> XECrsMatrix;
956  typedef Xpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node> XCrsMatrix;
957  typedef Xpetra::CrsMatrixWrap<Scalar, LocalOrdinal, GlobalOrdinal, Node> XCrsMatrixWrap;
958 
959  RCP<XCrsMatrix> Atmp = rcp(new XECrsMatrix(A));
960  return rcp(new XCrsMatrixWrap(Atmp));
961 }
962 
967 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
968 RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
969 EpetraMultiVector_To_XpetraMultiVector(const Teuchos::RCP<Epetra_MultiVector>& V) {
970  return rcp(new Xpetra::EpetraMultiVectorT<GlobalOrdinal, Node>(V));
971 }
972 #endif
973 
978 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
979 RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
980 TpetraCrs_To_XpetraMatrix(const Teuchos::RCP<Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& Atpetra) {
981  typedef Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node> XTCrsMatrix;
982  typedef Xpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node> XCrsMatrix;
983  typedef Xpetra::CrsMatrixWrap<Scalar, LocalOrdinal, GlobalOrdinal, Node> XCrsMatrixWrap;
984 
985  RCP<XCrsMatrix> Atmp = rcp(new XTCrsMatrix(Atpetra));
986  return rcp(new XCrsMatrixWrap(Atmp));
987 }
988 
1016 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
1017 void leftRghtDofScalingWithinNode(const Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>& Amat, size_t blkSize, size_t nSweeps, Teuchos::ArrayRCP<Scalar>& rowScaling, Teuchos::ArrayRCP<Scalar>& colScaling) {
1018  LocalOrdinal nBlks = (Amat.getRowMap()->getLocalNumElements()) / blkSize;
1019 
1020  Teuchos::ArrayRCP<Scalar> rowScaleUpdate(blkSize);
1021  Teuchos::ArrayRCP<Scalar> colScaleUpdate(blkSize);
1022 
1023  for (size_t i = 0; i < blkSize; i++) rowScaling[i] = 1.0;
1024  for (size_t i = 0; i < blkSize; i++) colScaling[i] = 1.0;
1025 
1026  for (size_t k = 0; k < nSweeps; k++) {
1027  LocalOrdinal row = 0;
1028  for (size_t i = 0; i < blkSize; i++) rowScaleUpdate[i] = 0.0;
1029 
1030  for (LocalOrdinal i = 0; i < nBlks; i++) {
1031  for (size_t j = 0; j < blkSize; j++) {
1032  Teuchos::ArrayView<const LocalOrdinal> cols;
1033  Teuchos::ArrayView<const Scalar> vals;
1034  Amat.getLocalRowView(row, cols, vals);
1035 
1036  for (size_t kk = 0; kk < Teuchos::as<size_t>(vals.size()); kk++) {
1037  size_t modGuy = (cols[kk] + 1) % blkSize;
1038  if (modGuy == 0) modGuy = blkSize;
1039  modGuy--;
1040  rowScaleUpdate[j] += rowScaling[j] * (Teuchos::ScalarTraits<Scalar>::magnitude(vals[kk])) * colScaling[modGuy];
1041  }
1042  row++;
1043  }
1044  }
1045  // combine information across processors
1046  Teuchos::ArrayRCP<Scalar> tempUpdate(blkSize);
1047  Teuchos::reduceAll(*(Amat.getRowMap()->getComm()), Teuchos::REDUCE_SUM, (LocalOrdinal)blkSize, rowScaleUpdate.getRawPtr(), tempUpdate.getRawPtr());
1048  for (size_t i = 0; i < blkSize; i++) rowScaleUpdate[i] = tempUpdate[i];
1049 
1050  /* We want to scale by sqrt(1/rowScaleUpdate), but we'll */
1051  /* normalize things by the minimum rowScaleUpdate. That is, the */
1052  /* largest scaling is always one (as normalization is arbitrary).*/
1053 
1054  Scalar minUpdate = Teuchos::ScalarTraits<Scalar>::magnitude((rowScaleUpdate[0] / rowScaling[0]) / rowScaling[0]);
1055 
1056  for (size_t i = 1; i < blkSize; i++) {
1057  Scalar temp = (rowScaleUpdate[i] / rowScaling[i]) / rowScaling[i];
1058  if (Teuchos::ScalarTraits<Scalar>::magnitude(temp) < Teuchos::ScalarTraits<Scalar>::magnitude(minUpdate))
1059  minUpdate = Teuchos::ScalarTraits<Scalar>::magnitude(temp);
1060  }
1061  for (size_t i = 0; i < blkSize; i++) rowScaling[i] *= sqrt(minUpdate / rowScaleUpdate[i]);
1062 
1063  row = 0;
1064  for (size_t i = 0; i < blkSize; i++) colScaleUpdate[i] = 0.0;
1065 
1066  for (LocalOrdinal i = 0; i < nBlks; i++) {
1067  for (size_t j = 0; j < blkSize; j++) {
1068  Teuchos::ArrayView<const LocalOrdinal> cols;
1069  Teuchos::ArrayView<const Scalar> vals;
1070  Amat.getLocalRowView(row, cols, vals);
1071  for (size_t kk = 0; kk < Teuchos::as<size_t>(vals.size()); kk++) {
1072  size_t modGuy = (cols[kk] + 1) % blkSize;
1073  if (modGuy == 0) modGuy = blkSize;
1074  modGuy--;
1075  colScaleUpdate[modGuy] += colScaling[modGuy] * (Teuchos::ScalarTraits<Scalar>::magnitude(vals[kk])) * rowScaling[j];
1076  }
1077  row++;
1078  }
1079  }
1080  Teuchos::reduceAll(*(Amat.getRowMap()->getComm()), Teuchos::REDUCE_SUM, (LocalOrdinal)blkSize, colScaleUpdate.getRawPtr(), tempUpdate.getRawPtr());
1081  for (size_t i = 0; i < blkSize; i++) colScaleUpdate[i] = tempUpdate[i];
1082 
1083  /* We want to scale by sqrt(1/colScaleUpdate), but we'll */
1084  /* normalize things by the minimum colScaleUpdate. That is, the */
1085  /* largest scaling is always one (as normalization is arbitrary).*/
1086 
1087  minUpdate = Teuchos::ScalarTraits<Scalar>::magnitude((colScaleUpdate[0] / colScaling[0]) / colScaling[0]);
1088 
1089  for (size_t i = 1; i < blkSize; i++) {
1090  Scalar temp = (colScaleUpdate[i] / colScaling[i]) / colScaling[i];
1091  if (Teuchos::ScalarTraits<Scalar>::magnitude(temp) < Teuchos::ScalarTraits<Scalar>::magnitude(minUpdate))
1092  minUpdate = Teuchos::ScalarTraits<Scalar>::magnitude(temp);
1093  }
1094  for (size_t i = 0; i < blkSize; i++) colScaling[i] *= sqrt(minUpdate / colScaleUpdate[i]);
1095  }
1096 }
1097 
1102 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
1103 RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
1104 TpetraFECrs_To_XpetraMatrix(const Teuchos::RCP<Tpetra::FECrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& Atpetra) {
1105  typedef typename Tpetra::FECrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>::crs_matrix_type tpetra_crs_matrix_type;
1106  typedef Xpetra::TpetraCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node> XTCrsMatrix;
1107  typedef Xpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node> XCrsMatrix;
1108  typedef Xpetra::CrsMatrixWrap<Scalar, LocalOrdinal, GlobalOrdinal, Node> XCrsMatrixWrap;
1109 
1110  RCP<XCrsMatrix> Atmp = rcp(new XTCrsMatrix(rcp_dynamic_cast<tpetra_crs_matrix_type>(Atpetra)));
1111  return rcp(new XCrsMatrixWrap(Atmp));
1112 }
1113 
1118 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
1119 RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
1120 TpetraMultiVector_To_XpetraMultiVector(const Teuchos::RCP<Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& Vtpetra) {
1121  return rcp(new Xpetra::TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(Vtpetra));
1122 }
1123 
1128 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
1129 RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
1130 TpetraFEMultiVector_To_XpetraMultiVector(const Teuchos::RCP<Tpetra::FEMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& Vtpetra) {
1131  typedef Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> MV;
1132  RCP<const MV> Vmv = Teuchos::rcp_dynamic_cast<const MV>(Vtpetra);
1133  return rcp(new Xpetra::TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(Vmv));
1134 }
1135 
1137 template <class T>
1138 std::string toString(const T& what) {
1139  std::ostringstream buf;
1140  buf << what;
1141  return buf.str();
1142 }
1143 
1144 #ifdef HAVE_MUELU_EPETRA
1145 
1149 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
1150 RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
1151 EpetraCrs_To_XpetraMatrix(const Teuchos::RCP<Epetra_CrsMatrix>& A);
1152 
1157 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
1158 RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
1159 EpetraMultiVector_To_XpetraMultiVector(const Teuchos::RCP<Epetra_MultiVector>& V);
1160 #endif
1161 
1166 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
1167 RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
1168 TpetraCrs_To_XpetraMatrix(const Teuchos::RCP<Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& Atpetra);
1169 
1174 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
1175 RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>
1176 TpetraMultiVector_To_XpetraMultiVector(const Teuchos::RCP<Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& Vtpetra);
1177 
1178 // Generates a communicator whose only members are other ranks of the baseComm on my node
1179 Teuchos::RCP<const Teuchos::Comm<int>> GenerateNodeComm(RCP<const Teuchos::Comm<int>>& baseComm, int& NodeId, const int reductionFactor);
1180 
1181 // Lower case string
1182 std::string lowerCase(const std::string& s);
1183 
1184 template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
1185 Teuchos::RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>> importOffRankDroppingInfo(
1186  Teuchos::RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>>& localDropMap,
1187  Teuchos::RCP<Xpetra::Matrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>>& Ain) {
1188  using SC = Scalar;
1189  using LO = LocalOrdinal;
1190  using GO = GlobalOrdinal;
1191  using NO = Node;
1192  using MT = typename Teuchos::ScalarTraits<SC>::magnitudeType;
1193 
1194  Teuchos::RCP<const Teuchos::Comm<int>> comm = localDropMap->getComm();
1195 
1196  Teuchos::RCP<Xpetra::Vector<SC, LO, GO, NO>> toggleVec = Xpetra::VectorFactory<SC, LO, GO, NO>::Build(localDropMap);
1197  toggleVec->putScalar(1);
1198 
1199  Teuchos::RCP<Xpetra::Vector<SC, LO, GO, NO>> finalVec = Xpetra::VectorFactory<SC, LO, GO, NO>::Build(Ain->getColMap(), true);
1200  Teuchos::RCP<Xpetra::Import<LO, GO, NO>> importer = Xpetra::ImportFactory<LO, GO, NO>::Build(localDropMap, Ain->getColMap());
1201  finalVec->doImport(*toggleVec, *importer, Xpetra::ABSMAX);
1202 
1203  std::vector<GO> finalDropMapEntries = {};
1204  auto finalVec_h_2D = finalVec->getHostLocalView(Xpetra::Access::ReadOnly);
1205  auto finalVec_h_1D = Kokkos::subview(finalVec_h_2D, Kokkos::ALL(), 0);
1206  const size_t localLength = finalVec->getLocalLength();
1207 
1208  for (size_t k = 0; k < localLength; ++k) {
1209  if (Teuchos::ScalarTraits<SC>::magnitude(finalVec_h_1D(k)) > Teuchos::ScalarTraits<MT>::zero()) {
1210  finalDropMapEntries.push_back(finalVec->getMap()->getGlobalElement(k));
1211  }
1212  }
1213 
1214  Teuchos::RCP<const Xpetra::Map<LO, GO, NO>> finalDropMap = Xpetra::MapFactory<LO, GO, NO>::Build(
1215  localDropMap->lib(), Teuchos::OrdinalTraits<Tpetra::global_size_t>::invalid(), finalDropMapEntries, 0, comm);
1216  return finalDropMap;
1217 } // importOffRankDroppingInfo
1218 
1219 } // namespace MueLu
1220 
1221 #define MUELU_UTILITIES_SHORT
1222 #endif // MUELU_UTILITIES_DECL_HPP
Epetra_MultiVector
MueLu::Exceptions::BadCast
Exception indicating invalid cast attempted.
Definition: MueLu_Exceptions.hpp:57
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Op2TpetraBlockCrs
static const Tpetra::BlockCrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > & Op2TpetraBlockCrs(const Matrix &Op)
Definition: MueLu_Utilities_decl.hpp:479
Epetra_Map
MueLu::Utilities::Map2TpetraMap
static const RCP< const Tpetra::Map< LocalOrdinal, GlobalOrdinal, Node > > Map2TpetraMap(const Xpetra::Map< LocalOrdinal, GlobalOrdinal, Node > &map)
Definition: MueLu_Utilities_def.hpp:418
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::MV2EpetraMV
static const Epetra_MultiVector & MV2EpetraMV(const MultiVector &vec)
Definition: MueLu_Utilities_decl.hpp:266
LocalOrdinal
MueLu::DefaultLocalOrdinal LocalOrdinal
Definition: MueLu_UseDefaultTypes.hpp:50
Xpetra_TpetraOperator.hpp
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Op2NonConstTpetraCrs
static Tpetra::CrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > & Op2NonConstTpetraCrs(Matrix &Op)
Definition: MueLu_Utilities_decl.hpp:429
MueLu::Utilities::MV2TpetraMV
static RCP< const Tpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > MV2TpetraMV(RCP< Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node >> const vec)
Helper utility to pull out the underlying Tpetra objects from an Xpetra object.
Definition: MueLu_Utilities_def.hpp:213
MueLu::EpetraCrs_To_XpetraMatrix
RCP< Xpetra::Matrix< SC, LO, GO, NO > > EpetraCrs_To_XpetraMatrix(const Teuchos::RCP< Epetra_CrsMatrix > &A)
Definition: MueLu_Utilities_decl.hpp:954
MueLu::toString
std::string toString(const T &what)
Little helper function to convert non-string types to strings.
Definition: MueLu_Utilities_decl.hpp:1138
MueLu::DefaultNode
Tpetra::KokkosClassic::DefaultNode::DefaultNodeType DefaultNode
Definition: MueLu_Details_DefaultTypes.hpp:69
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::MV2NonConstTpetraMV2
static RCP< Tpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > MV2NonConstTpetraMV2(MultiVector &vec)
Definition: MueLu_Utilities_decl.hpp:352
MueLu::Utilities::MyOldScaleMatrix
static void MyOldScaleMatrix(Xpetra::Matrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > &Op, const Teuchos::ArrayRCP< const Scalar > &scalingVector, bool doInverse=true, bool doFillComplete=true, bool doOptimizeStorage=true)
Definition: MueLu_Utilities_def.hpp:426
MueLu::Utilities::RealValuedToScalarMultiVector
static RCP< Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > RealValuedToScalarMultiVector(RCP< Xpetra::MultiVector< typename Teuchos::ScalarTraits< Scalar >::coordinateType, LocalOrdinal, GlobalOrdinal, Node >> X)
Definition: MueLu_Utilities_def.hpp:616
MueLu::Utilities::Map2EpetraMap
static const Epetra_Map & Map2EpetraMap(const Xpetra::Map< LocalOrdinal, GlobalOrdinal, Node > &map)
Definition: MueLu_Utilities_def.hpp:203
Tpetra::CrsMatrix::getRangeMap
Teuchos::RCP< const map_type > getRangeMap() const override
Xpetra::TpetraBlockCrsMatrix::getTpetra_BlockCrsMatrixNonConst
RCP< Tpetra::BlockCrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getTpetra_BlockCrsMatrixNonConst() const
GO
GlobalOrdinal GO
Teuchos::ParameterList::get
T & get(const std::string &name, T def_value)
MueLu_Exceptions.hpp
MueLu::Utilities::ExtractCoordinatesFromParameterList
static RCP< Xpetra::MultiVector< typename Teuchos::ScalarTraits< Scalar >::magnitudeType, LocalOrdinal, GlobalOrdinal, Node > > ExtractCoordinatesFromParameterList(ParameterList &paramList)
Definition: MueLu_Utilities_def.hpp:644
Teuchos::ParameterList::set
ParameterList & set(std::string const &name, T const &value, std::string const &docString="", RCP< const ParameterEntryValidator > const &validator=null)
MueLu::Utilities::Op2NonConstTpetraRow
static RCP< Tpetra::RowMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Op2NonConstTpetraRow(RCP< Xpetra::Operator< Scalar, LocalOrdinal, GlobalOrdinal, Node >> Op)
Definition: MueLu_Utilities_def.hpp:388
Teuchos::is_null
bool is_null(const std::shared_ptr< T > &p)
MueLu::Utilities::Op2NonConstEpetraCrs
static RCP< Epetra_CrsMatrix > Op2NonConstEpetraCrs(RCP< Xpetra::Matrix< Scalar, LocalOrdinal, GlobalOrdinal, Node >> Op)
Definition: MueLu_Utilities_def.hpp:162
Xpetra_TpetraRowMatrix.hpp
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Magnitude
Teuchos::ScalarTraits< Scalar >::magnitudeType Magnitude
Definition: MueLu_Utilities_decl.hpp:242
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Op2EpetraCrs
static RCP< const Epetra_CrsMatrix > Op2EpetraCrs(RCP< const Matrix > Op)
Definition: MueLu_Utilities_decl.hpp:275
Xpetra_EpetraCrsMatrix_fwd.hpp
Teuchos::ArrayRCP::getRawPtr
T * getRawPtr() const
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Op2TpetraBlockCrs
static RCP< const Tpetra::BlockCrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Op2TpetraBlockCrs(RCP< const Matrix > Op)
Definition: MueLu_Utilities_decl.hpp:448
MueLu::TpetraMultiVector_To_XpetraMultiVector
RCP< Xpetra::MultiVector< SC, LO, GO, NO > > TpetraMultiVector_To_XpetraMultiVector(const Teuchos::RCP< Tpetra::MultiVector< SC, LO, GO, NO >> &Vtpetra)
Definition: MueLu_Utilities_decl.hpp:1120
Teuchos::ArrayView::size
size_type size() const
Tpetra::CrsMatrix::resumeFill
void resumeFill(const Teuchos::RCP< Teuchos::ParameterList > &params=Teuchos::null)
MueLu::TpetraFECrs_To_XpetraMatrix
RCP< Xpetra::Matrix< SC, LO, GO, NO > > TpetraFECrs_To_XpetraMatrix(const Teuchos::RCP< Tpetra::FECrsMatrix< SC, LO, GO, NO >> &Atpetra)
Definition: MueLu_Utilities_decl.hpp:1104
Xpetra_VectorFactory_fwd.hpp
MueLu_UseShortNames.hpp
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Op2NonConstTpetraRow
static RCP< Tpetra::RowMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Op2NonConstTpetraRow(RCP< Operator > Op)
Definition: MueLu_Utilities_decl.hpp:550
LO
LocalOrdinal LO
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::MV2EpetraMV
static RCP< const Epetra_MultiVector > MV2EpetraMV(RCP< MultiVector > const vec)
Helper utility to pull out the underlying Epetra objects from an Xpetra object.
Definition: MueLu_Utilities_decl.hpp:253
Epetra_Vector
EpetraExt::RowMatrix_Transpose::ReleaseTranspose
void ReleaseTranspose()
MueLu::Utilities::Op2TpetraCrs
static RCP< const Tpetra::CrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Op2TpetraCrs(RCP< const Xpetra::Matrix< Scalar, LocalOrdinal, GlobalOrdinal, Node >> Op)
Definition: MueLu_Utilities_def.hpp:248
MueLu::IsParamMuemexVariable
bool IsParamMuemexVariable(const std::string &name)
Definition: MueLu_Utilities.cpp:146
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::MV2TpetraMV
static RCP< const Tpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > MV2TpetraMV(RCP< MultiVector > const vec)
Helper utility to pull out the underlying Tpetra objects from an Xpetra object.
Definition: MueLu_Utilities_decl.hpp:330
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Map2TpetraMap
static const RCP< const Tpetra::Map< LocalOrdinal, GlobalOrdinal, Node > > Map2TpetraMap(const Map &map)
Definition: MueLu_Utilities_decl.hpp:584
Teuchos::ArrayRCP::size
size_type size() const
Xpetra_MatrixMatrix.hpp
MueLu_ConfigDefs.hpp
Xpetra_TpetraCrsMatrix_fwd.hpp
Node
MueLu::DefaultNode Node
Definition: MueLu_UseDefaultTypes.hpp:52
EpetraExt::RowMatrix_Transpose
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::MyOldScaleMatrix_Tpetra
static void MyOldScaleMatrix_Tpetra(Matrix &Op, const Teuchos::ArrayRCP< Scalar > &scalingVector, bool doFillComplete, bool doOptimizeStorage)
Definition: MueLu_Utilities_decl.hpp:623
Teuchos::TimeMonitor::getNewTimer
static RCP< Time > getNewTimer(const std::string &name)
Epetra_CrsMatrix::ExtractMyRowView
int ExtractMyRowView(int MyRow, int &NumEntries, double *&Values, int *&Indices) const
MueLu::Utilities::Op2NonConstTpetraBlockCrs
static RCP< Tpetra::BlockCrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Op2NonConstTpetraBlockCrs(RCP< Xpetra::Matrix< Scalar, LocalOrdinal, GlobalOrdinal, Node >> Op)
Definition: MueLu_Utilities_def.hpp:314
Xpetra_TpetraMultiVector_fwd.hpp
EpetraExt_Transpose_RowMatrix.h
MueLu::TpetraFEMultiVector_To_XpetraMultiVector
RCP< Xpetra::MultiVector< SC, LO, GO, NO > > TpetraFEMultiVector_To_XpetraMultiVector(const Teuchos::RCP< Tpetra::FEMultiVector< SC, LO, GO, NO >> &Vtpetra)
Definition: MueLu_Utilities_decl.hpp:1130
Epetra_CrsMatrix::RowMap
const Epetra_Map & RowMap() const
Teuchos::ParameterList::isParameter
bool isParameter(const std::string &name) const
Epetra_BlockMap::NumMyElements
int NumMyElements() const
deep_copy
void deep_copy(MultiVector< DS, DL, DG, DN > &dst, const MultiVector< SS, SL, SG, SN > &src)
Teuchos::ParameterList::remove
bool remove(std::string const &name, bool throwIfNotExists=true)
Xpetra_CrsMatrix_fwd.hpp
Tpetra::CrsMatrix::getLocalMaxNumRowEntries
size_t getLocalMaxNumRowEntries() const override
Xpetra::Matrix::getLocalRowView
virtual void getLocalRowView(LocalOrdinal LocalRow, ArrayView< const LocalOrdinal > &indices, ArrayView< const Scalar > &values) const =0
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Op2NonConstEpetraCrs
static RCP< Epetra_CrsMatrix > Op2NonConstEpetraCrs(RCP< Matrix > Op)
Definition: MueLu_Utilities_decl.hpp:284
Tpetra::CrsMatrix::isFillComplete
bool isFillComplete() const override
rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Teuchos_ParameterList.hpp
MueLu::Utilities::MV2NonConstEpetraMV
static RCP< Epetra_MultiVector > MV2NonConstEpetraMV(RCP< Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node >> vec)
Definition: MueLu_Utilities_def.hpp:131
Xpetra_CrsMatrixWrap_fwd.hpp
Scalar
MueLu::DefaultScalar Scalar
Definition: MueLu_UseDefaultTypes.hpp:49
GlobalOrdinal
MueLu::DefaultGlobalOrdinal GlobalOrdinal
Definition: MueLu_UseDefaultTypes.hpp:51
Xpetra::MapFactory::Build
static Teuchos::RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(UnderlyingLib lib, global_size_t numGlobalElements, GlobalOrdinal indexBase, const Teuchos::RCP< const Teuchos::Comm< int >> &comm, LocalGlobal lg=Xpetra::GloballyDistributed)
Xpetra::TpetraBlockCrsMatrix::getTpetra_BlockCrsMatrix
RCP< const Tpetra::BlockCrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getTpetra_BlockCrsMatrix() const
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::MV2NonConstEpetraMV
static Epetra_MultiVector & MV2NonConstEpetraMV(MultiVector &vec)
Definition: MueLu_Utilities_decl.hpp:270
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::MV2NonConstEpetraMV
static RCP< Epetra_MultiVector > MV2NonConstEpetraMV(RCP< MultiVector > vec)
Definition: MueLu_Utilities_decl.hpp:259
MueLu::leftRghtDofScalingWithinNode
void leftRghtDofScalingWithinNode(const Xpetra::Matrix< SC, LO, GO, NO > &Atpetra, size_t blkSize, size_t nSweeps, Teuchos::ArrayRCP< SC > &rowScaling, Teuchos::ArrayRCP< SC > &colScaling)
Definition: MueLu_Utilities_decl.hpp:1017
MueLu::TpetraCrs_To_XpetraMatrix
RCP< Xpetra::Matrix< SC, LO, GO, NO > > TpetraCrs_To_XpetraMatrix(const Teuchos::RCP< Tpetra::CrsMatrix< SC, LO, GO, NO >> &Atpetra)
Definition: MueLu_Utilities_decl.hpp:980
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::MV2TpetraMV
static const Tpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > & MV2TpetraMV(const MultiVector &vec)
Definition: MueLu_Utilities_decl.hpp:362
MueLu::Utilities::MV2NonConstTpetraMV2
static RCP< Tpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > MV2NonConstTpetraMV2(Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &vec)
Definition: MueLu_Utilities_def.hpp:235
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Op2TpetraCrs
static RCP< const Tpetra::CrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Op2TpetraCrs(RCP< const Matrix > Op)
Definition: MueLu_Utilities_decl.hpp:381
MueLu::Utilities::Transpose
static RCP< Xpetra::Matrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Transpose(Xpetra::Matrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > &Op, bool optimizeTranspose=false, const std::string &label=std::string(), const Teuchos::RCP< Teuchos::ParameterList > &params=Teuchos::null)
Definition: MueLu_Utilities_def.hpp:532
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Transpose
static RCP< Matrix > Transpose(Matrix &Op, bool=false, const std::string &label=std::string(), const Teuchos::RCP< Teuchos::ParameterList > &params=Teuchos::null)
Transpose a Xpetra::Matrix.
Definition: MueLu_Utilities_decl.hpp:733
Tpetra::CrsMatrix::replaceGlobalValues
local_ordinal_type replaceGlobalValues(const global_ordinal_type globalRow, const Kokkos::View< const global_ordinal_type *, Kokkos::AnonymousSpace > &inputInds, const Kokkos::View< const impl_scalar_type *, Kokkos::AnonymousSpace > &inputVals)
MueLu::Convert_Epetra_CrsMatrix_ToXpetra_CrsMatrixWrap
RCP< Xpetra::CrsMatrixWrap< SC, LO, GO, NO > > Convert_Epetra_CrsMatrix_ToXpetra_CrsMatrixWrap(RCP< Epetra_CrsMatrix > &epAB)
Definition: MueLu_Utilities_def.hpp:116
Tpetra::CrsMatrix::getNumEntriesInLocalRow
size_t getNumEntriesInLocalRow(local_ordinal_type localRow) const override
Xpetra_Operator_fwd.hpp
MueLu::IsParamValidVariable
bool IsParamValidVariable(const std::string &name)
Definition: MueLu_Utilities.cpp:192
Xpetra_EpetraCrsMatrix.hpp
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::MV2NonConstTpetraMV
static RCP< Tpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > MV2NonConstTpetraMV(RCP< MultiVector > vec)
Definition: MueLu_Utilities_decl.hpp:341
Xpetra::VectorFactory::Build
static RCP< Vector > Build(const Teuchos::RCP< const Map > &map, bool zeroOut=true)
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::RealValuedToScalarMultiVector
static RCP< Xpetra::MultiVector< typename Teuchos::ScalarTraits< Scalar >::magnitudeType, LocalOrdinal, GlobalOrdinal, Node > > RealValuedToScalarMultiVector(RCP< Xpetra::MultiVector< typename Teuchos::ScalarTraits< Scalar >::coordinateType, LocalOrdinal, GlobalOrdinal, Node >> X)
Definition: MueLu_Utilities_decl.hpp:828
Tpetra::BlockCrsMatrixTransposer::createTranspose
Teuchos::RCP< bcrs_matrix_type > createTranspose(const Teuchos::RCP< Teuchos::ParameterList > &params=Teuchos::null)
Teuchos::ScalarTraits::magnitude
static magnitudeType magnitude(T a)
MueLu::lowerCase
std::string lowerCase(const std::string &s)
Definition: MueLu_VerbosityLevel.cpp:74
Tpetra::RowMatrixTransposer::createTranspose
Teuchos::RCP< crs_matrix_type > createTranspose(const Teuchos::RCP< Teuchos::ParameterList > &params=Teuchos::null)
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Op2TpetraRow
static RCP< const Tpetra::RowMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Op2TpetraRow(RCP< const Operator > Op)
Definition: MueLu_Utilities_decl.hpp:516
MueLu::Utilities::MyOldScaleMatrix_Epetra
static void MyOldScaleMatrix_Epetra(Xpetra::Matrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > &Op, const Teuchos::ArrayRCP< Scalar > &scalingVector, bool doFillComplete, bool doOptimizeStorage)
Definition: MueLu_Utilities_def.hpp:454
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Op2TpetraCrs
static const Tpetra::CrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > & Op2TpetraCrs(const Matrix &Op)
Definition: MueLu_Utilities_decl.hpp:411
TEUCHOS_UNREACHABLE_RETURN
#define TEUCHOS_UNREACHABLE_RETURN(dummyReturnVal)
Tpetra::CrsMatrix::getDomainMap
Teuchos::RCP< const map_type > getDomainMap() const override
Xpetra::TpetraCrsMatrix::getTpetra_CrsMatrix
RCP< const Tpetra::CrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getTpetra_CrsMatrix() const
Epetra_CrsMatrix
Xpetra_Vector_fwd.hpp
Xpetra::TpetraCrsMatrix::getTpetra_CrsMatrixNonConst
RCP< Tpetra::CrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getTpetra_CrsMatrixNonConst() const
MueLu::importOffRankDroppingInfo
Teuchos::RCP< const Xpetra::Map< LocalOrdinal, GlobalOrdinal, Node > > importOffRankDroppingInfo(Teuchos::RCP< const Xpetra::Map< LocalOrdinal, GlobalOrdinal, Node >> &localDropMap, Teuchos::RCP< Xpetra::Matrix< Scalar, LocalOrdinal, GlobalOrdinal, Node >> &Ain)
Definition: MueLu_Utilities_decl.hpp:1185
SC
Scalar SC
Teuchos::ParameterList::isType
bool isType(const std::string &name) const
MueLu::Utilities::Op2TpetraRow
static RCP< const Tpetra::RowMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Op2TpetraRow(RCP< const Xpetra::Operator< Scalar, LocalOrdinal, GlobalOrdinal, Node >> Op)
Definition: MueLu_Utilities_def.hpp:358
Tpetra::CrsMatrix::getGlobalRowView
virtual void getGlobalRowView(GlobalOrdinal GlobalRow, global_inds_host_view_type &indices, values_host_view_type &values) const =0
Teuchos_ScalarTraits.hpp
MueLu::TpetraOperator
Wraps an existing MueLu::Hierarchy as a Tpetra::Operator.
Definition: MueLu_TpetraOperator_fwd.hpp:51
EpetraCrsMatrix
EpetraCrsMatrixT< int, EpetraNode > EpetraCrsMatrix
MueLu::Utilities::MV2EpetraMV
static RCP< const Epetra_MultiVector > MV2EpetraMV(RCP< Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node >> const vec)
Helper utility to pull out the underlying Epetra objects from an Xpetra object.
Definition: MueLu_Utilities_def.hpp:123
Xpetra::EpetraMultiVectorT::getEpetra_MultiVector
RCP< Epetra_MultiVector > getEpetra_MultiVector() const
NO
Node NO
Xpetra::TpetraMultiVector::getTpetra_MultiVector
RCP< Tpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getTpetra_MultiVector() const
Xpetra_MultiVector_fwd.hpp
Tpetra::CrsMatrix::getNumEntriesInGlobalRow
size_t getNumEntriesInGlobalRow(GlobalOrdinal globalRow) const override
MueLu::Exceptions::RuntimeError
Exception throws to report errors in the internal logical of the program.
Definition: MueLu_Exceptions.hpp:70
Tpetra::CrsMatrix::getLocalRowView
virtual void getLocalRowView(LocalOrdinal LocalRow, local_inds_host_view_type &indices, values_host_view_type &values) const =0
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Op2NonConstTpetraBlockCrs
static Tpetra::BlockCrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > & Op2NonConstTpetraBlockCrs(Matrix &Op)
Definition: MueLu_Utilities_decl.hpp:497
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::MV2NonConstTpetraMV
static Tpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > & MV2NonConstTpetraMV(MultiVector &vec)
Definition: MueLu_Utilities_decl.hpp:371
Tpetra::CrsMatrix::replaceLocalValues
local_ordinal_type replaceLocalValues(const local_ordinal_type localRow, const Kokkos::View< const local_ordinal_type *, Kokkos::AnonymousSpace > &inputInds, const Kokkos::View< const impl_scalar_type *, Kokkos::AnonymousSpace > &inputVals)
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Map2EpetraMap
static const Epetra_Map & Map2EpetraMap(const Map &map)
Definition: MueLu_Utilities_decl.hpp:321
MueLu::TokenizeStringAndStripWhiteSpace
void TokenizeStringAndStripWhiteSpace(const std::string &stream, std::vector< std::string > &tokenList, const char *delimChars)
Definition: MueLu_Utilities.cpp:117
MueLu::Utilities::Op2TpetraBlockCrs
static RCP< const Tpetra::BlockCrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Op2TpetraBlockCrs(RCP< const Xpetra::Matrix< Scalar, LocalOrdinal, GlobalOrdinal, Node >> Op)
Definition: MueLu_Utilities_def.hpp:301
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::MyOldScaleMatrix
static void MyOldScaleMatrix(Matrix &Op, const Teuchos::ArrayRCP< const Scalar > &scalingVector, bool doInverse=true, bool doFillComplete=true, bool doOptimizeStorage=true)
Definition: MueLu_Utilities_decl.hpp:596
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::MyOldScaleMatrix_Epetra
static void MyOldScaleMatrix_Epetra(Matrix &Op, const Teuchos::ArrayRCP< Scalar > &scalingVector, bool, bool)
Definition: MueLu_Utilities_decl.hpp:703
MueLu::Utilities::MyOldScaleMatrix_Tpetra
static void MyOldScaleMatrix_Tpetra(Xpetra::Matrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > &Op, const Teuchos::ArrayRCP< Scalar > &scalingVector, bool doFillComplete, bool doOptimizeStorage)
Definition: MueLu_Utilities_def.hpp:459
MueLu::GenerateNodeComm
Teuchos::RCP< const Teuchos::Comm< int > > GenerateNodeComm(RCP< const Teuchos::Comm< int > > &baseComm, int &NodeId, const int reductionFactor)
Definition: MueLu_Utilities.cpp:243
MueLu::EpetraMultiVector_To_XpetraMultiVector
RCP< Xpetra::MultiVector< SC, LO, GO, NO > > EpetraMultiVector_To_XpetraMultiVector(const Teuchos::RCP< Epetra_MultiVector > &V)
Definition: MueLu_Utilities_decl.hpp:969
Xpetra_Map_fwd.hpp
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Op2EpetraCrs
static const Epetra_CrsMatrix & Op2EpetraCrs(const Matrix &Op)
Definition: MueLu_Utilities_decl.hpp:294
MueLu::Utilities::Magnitude
Teuchos::ScalarTraits< Scalar >::magnitudeType Magnitude
Definition: MueLu_Utilities_decl.hpp:161
Xpetra_MultiVectorFactory_fwd.hpp
MueLu::Utilities::Op2EpetraCrs
static RCP< const Epetra_CrsMatrix > Op2EpetraCrs(RCP< const Xpetra::Matrix< Scalar, LocalOrdinal, GlobalOrdinal, Node >> Op)
Definition: MueLu_Utilities_def.hpp:151
Xpetra_Matrix_fwd.hpp
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::ExtractCoordinatesFromParameterList
static RCP< Xpetra::MultiVector< typename Teuchos::ScalarTraits< Scalar >::magnitudeType, LocalOrdinal, GlobalOrdinal, Node > > ExtractCoordinatesFromParameterList(ParameterList &paramList)
Extract coordinates from parameter list and return them in a Xpetra::MultiVector. ...
Definition: MueLu_Utilities_decl.hpp:835
MueLu::Utilities
MueLu utility class.
Definition: MueLu_Utilities_fwd.hpp:51
TEUCHOS_TEST_FOR_EXCEPT
#define TEUCHOS_TEST_FOR_EXCEPT(throw_exception_test)
MueLu::Utilities::Op2NonConstTpetraCrs
static RCP< Tpetra::CrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Op2NonConstTpetraCrs(RCP< Xpetra::Matrix< Scalar, LocalOrdinal, GlobalOrdinal, Node >> Op)
Definition: MueLu_Utilities_def.hpp:260
MueLu::Utilities::MV2NonConstTpetraMV
static RCP< Tpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > MV2NonConstTpetraMV(RCP< Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node >> vec)
Definition: MueLu_Utilities_def.hpp:221
Xpetra::ImportFactory::Build
static RCP< Import< LocalOrdinal, GlobalOrdinal, Node > > Build(const RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > &source, const RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > &target, const Teuchos::RCP< Teuchos::ParameterList > &plist=Teuchos::null)
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Op2NonConstTpetraBlockCrs
static RCP< Tpetra::BlockCrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Op2NonConstTpetraBlockCrs(RCP< Matrix > Op)
Definition: MueLu_Utilities_decl.hpp:464
MueLu::ExtractNonSerializableData
long ExtractNonSerializableData(const Teuchos::ParameterList &inList, Teuchos::ParameterList &serialList, Teuchos::ParameterList &nonSerialList)
Extract non-serializable data from level-specific sublists and move it to a separate parameter list...
Definition: MueLu_Utilities.cpp:67
Tpetra::CrsMatrix::getRowMap
Teuchos::RCP< const map_type > getRowMap() const override
Teuchos::RCP::is_null
bool is_null() const
MueLu::Utilities< double, int, int, Xpetra::EpetraNode >::Op2NonConstTpetraCrs
static RCP< Tpetra::CrsMatrix< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Op2NonConstTpetraCrs(RCP< Matrix > Op)
Definition: MueLu_Utilities_decl.hpp:396