Ifpack2 Templated Preconditioning Package  Version 1.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
Ifpack2_Hiptmair_def.hpp
1 // @HEADER
2 // *****************************************************************************
3 // Ifpack2: Templated Object-Oriented Algebraic Preconditioner Package
4 //
5 // Copyright 2009 NTESS and the Ifpack2 contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9 
10 #ifndef IFPACK2_HIPTMAIR_DEF_HPP
11 #define IFPACK2_HIPTMAIR_DEF_HPP
12 
13 #include "Ifpack2_Details_OneLevelFactory.hpp"
14 #include "Ifpack2_Parameters.hpp"
15 #include "Teuchos_TimeMonitor.hpp"
16 #include "Tpetra_MultiVector.hpp"
17 #include "Tpetra_Details_residual.hpp"
18 #include <Tpetra_RowMatrixTransposer.hpp>
19 #include <cmath>
20 #include <iostream>
21 #include <sstream>
22 
23 namespace Ifpack2 {
24 
25 template <class MatrixType>
26 Hiptmair<MatrixType>::
27  Hiptmair(const Teuchos::RCP<const row_matrix_type>& A,
28  const Teuchos::RCP<const row_matrix_type>& PtAP,
29  const Teuchos::RCP<const row_matrix_type>& P,
30  const Teuchos::RCP<const row_matrix_type>& Pt)
31  : A_(A)
32  , PtAP_(PtAP)
33  , P_(P)
34  , Pt_(Pt)
35  ,
36  // Default values
37  precType1_("CHEBYSHEV")
38  , precType2_("CHEBYSHEV")
39  , preOrPost_("both")
40  , ZeroStartingSolution_(true)
41  , ImplicitTranspose_(Pt.is_null())
42  ,
43  // General
44  IsInitialized_(false)
45  , IsComputed_(false)
46  , NumInitialize_(0)
47  , NumCompute_(0)
48  , NumApply_(0)
49  , InitializeTime_(0.0)
50  , ComputeTime_(0.0)
51  , ApplyTime_(0.0) {}
52 
53 template <class MatrixType>
54 Hiptmair<MatrixType>::
55  Hiptmair(const Teuchos::RCP<const row_matrix_type>& A)
56  : A_(A)
57  , PtAP_()
58  , P_()
59  , Pt_()
60  ,
61  // Default values
62  precType1_("CHEBYSHEV")
63  , precType2_("CHEBYSHEV")
64  , preOrPost_("both")
65  , ZeroStartingSolution_(true)
66  , ImplicitTranspose_(true)
67  ,
68  // General
69  IsInitialized_(false)
70  , IsComputed_(false)
71  , NumInitialize_(0)
72  , NumCompute_(0)
73  , NumApply_(0)
74  , InitializeTime_(0.0)
75  , ComputeTime_(0.0)
76  , ApplyTime_(0.0) {}
77 
78 template <class MatrixType>
79 Hiptmair<MatrixType>::~Hiptmair() {}
80 
81 template <class MatrixType>
82 void Hiptmair<MatrixType>::setParameters(const Teuchos::ParameterList& plist) {
83  using Teuchos::as;
84  using Teuchos::ParameterList;
85  using Teuchos::RCP;
86  using Teuchos::Exceptions::InvalidParameterName;
87  using Teuchos::Exceptions::InvalidParameterType;
88 
89  ParameterList params = plist;
90 
91  // Get the current parameters' values. We don't assign to the
92  // instance data directly until we've gotten all the parameters.
93  // This ensures "transactional" semantics, so that if attempting to
94  // get some parameter throws an exception, the class' state doesn't
95  // change.
96  std::string precType1 = precType1_;
97  std::string precType2 = precType2_;
98  std::string preOrPost = preOrPost_;
99  Teuchos::ParameterList precList1 = precList1_;
100  Teuchos::ParameterList precList2 = precList2_;
101  bool zeroStartingSolution = ZeroStartingSolution_;
102  bool implicitTranspose = ImplicitTranspose_;
103 
104  precType1 = params.get("hiptmair: smoother type 1", precType1);
105  precType2 = params.get("hiptmair: smoother type 2", precType2);
106  precList1 = params.get("hiptmair: smoother list 1", precList1);
107  precList2 = params.get("hiptmair: smoother list 2", precList2);
108  preOrPost = params.get("hiptmair: pre or post", preOrPost);
109  zeroStartingSolution = params.get("hiptmair: zero starting solution",
110  zeroStartingSolution);
111  implicitTranspose = params.get("hiptmair: implicit transpose", implicitTranspose);
112 
113  // Grab the matrices off of the parameter list if we need them
114  // This will intentionally throw if they're not there and we need them
115  if (PtAP_.is_null())
116  PtAP_ = params.get<RCP<row_matrix_type>>("PtAP");
117  if (P_.is_null())
118  P_ = params.get<RCP<row_matrix_type>>("P");
119  if (params.isType<RCP<row_matrix_type>>("Pt"))
120  Pt_ = params.get<RCP<row_matrix_type>>("Pt");
121 
122  // "Commit" the new values to the instance data.
123  precType1_ = precType1;
124  precType2_ = precType2;
125  precList1_ = precList1;
126  precList2_ = precList2;
127  preOrPost_ = preOrPost;
128  ZeroStartingSolution_ = zeroStartingSolution;
129  ImplicitTranspose_ = implicitTranspose;
130 }
131 
132 template <class MatrixType>
133 Teuchos::RCP<const Teuchos::Comm<int>>
134 Hiptmair<MatrixType>::getComm() const {
135  TEUCHOS_TEST_FOR_EXCEPTION(
136  A_.is_null(), std::runtime_error,
137  "Ifpack2::Hiptmair::getComm: "
138  "The input matrix A is null. Please call setMatrix() with a nonnull "
139  "input matrix before calling this method.");
140  return A_->getComm();
141 }
142 
143 template <class MatrixType>
144 Teuchos::RCP<const Tpetra::RowMatrix<typename MatrixType::scalar_type, typename MatrixType::local_ordinal_type, typename MatrixType::global_ordinal_type, typename MatrixType::node_type>>
145 Hiptmair<MatrixType>::getMatrix() const {
146  return A_;
147 }
148 
149 template <class MatrixType>
150 Teuchos::RCP<const Tpetra::Map<typename MatrixType::local_ordinal_type, typename MatrixType::global_ordinal_type, typename MatrixType::node_type>>
151 Hiptmair<MatrixType>::getDomainMap() const {
152  TEUCHOS_TEST_FOR_EXCEPTION(
153  A_.is_null(), std::runtime_error,
154  "Ifpack2::Hiptmair::getDomainMap: "
155  "The input matrix A is null. Please call setMatrix() with a nonnull "
156  "input matrix before calling this method.");
157  return A_->getDomainMap();
158 }
159 
160 template <class MatrixType>
161 Teuchos::RCP<const Tpetra::Map<typename MatrixType::local_ordinal_type, typename MatrixType::global_ordinal_type, typename MatrixType::node_type>>
162 Hiptmair<MatrixType>::getRangeMap() const {
163  TEUCHOS_TEST_FOR_EXCEPTION(
164  A_.is_null(), std::runtime_error,
165  "Ifpack2::Hiptmair::getRangeMap: "
166  "The input matrix A is null. Please call setMatrix() with a nonnull "
167  "input matrix before calling this method.");
168  return A_->getRangeMap();
169 }
170 
171 template <class MatrixType>
172 bool Hiptmair<MatrixType>::hasTransposeApply() const {
173  // FIXME (mfh 17 Jan 2014) apply() does not currently work with mode
174  // != NO_TRANS, so it's correct to return false here.
175  return false;
176 }
177 
178 template <class MatrixType>
179 int Hiptmair<MatrixType>::getNumInitialize() const {
180  return NumInitialize_;
181 }
182 
183 template <class MatrixType>
184 int Hiptmair<MatrixType>::getNumCompute() const {
185  return NumCompute_;
186 }
187 
188 template <class MatrixType>
189 int Hiptmair<MatrixType>::getNumApply() const {
190  return NumApply_;
191 }
192 
193 template <class MatrixType>
194 double Hiptmair<MatrixType>::getInitializeTime() const {
195  return InitializeTime_;
196 }
197 
198 template <class MatrixType>
199 double Hiptmair<MatrixType>::getComputeTime() const {
200  return ComputeTime_;
201 }
202 
203 template <class MatrixType>
204 double Hiptmair<MatrixType>::getApplyTime() const {
205  return ApplyTime_;
206 }
207 
208 template <class MatrixType>
209 Teuchos::RCP<Ifpack2::Preconditioner<typename MatrixType::scalar_type, typename MatrixType::local_ordinal_type, typename MatrixType::global_ordinal_type, typename MatrixType::node_type>> Hiptmair<MatrixType>::getPrec1() {
210  return ifpack2_prec1_;
211 }
212 
213 template <class MatrixType>
214 Teuchos::RCP<Ifpack2::Preconditioner<typename MatrixType::scalar_type, typename MatrixType::local_ordinal_type, typename MatrixType::global_ordinal_type, typename MatrixType::node_type>> Hiptmair<MatrixType>::getPrec2() {
215  return ifpack2_prec2_;
216 }
217 
218 template <class MatrixType>
219 void Hiptmair<MatrixType>::initialize() {
220  using Teuchos::ParameterList;
221  using Teuchos::RCP;
222  using Teuchos::rcp;
223 
224  const char methodName[] = "Ifpack2::Hiptmair::initialize";
225 
226  TEUCHOS_TEST_FOR_EXCEPTION(
227  A_.is_null(), std::runtime_error,
228  "Ifpack2::Hiptmair::initialize: "
229  "The input matrix A is null. Please call setMatrix() with a nonnull "
230  "input matrix before calling this method.");
231 
232  // clear any previous allocation
233  IsInitialized_ = false;
234  IsComputed_ = false;
235 
236  Teuchos::RCP<Teuchos::Time> timer =
237  Teuchos::TimeMonitor::getNewCounter(methodName);
238 
239  double startTime = timer->wallTime();
240 
241  { // The body of code to time
242  Teuchos::TimeMonitor timeMon(*timer);
243 
244  Details::OneLevelFactory<row_matrix_type> factory;
245 
246  ifpack2_prec1_ = factory.create(precType1_, A_);
247  ifpack2_prec1_->initialize();
248  ifpack2_prec1_->setParameters(precList1_);
249 
250  ifpack2_prec2_ = factory.create(precType2_, PtAP_);
251  ifpack2_prec2_->initialize();
252  ifpack2_prec2_->setParameters(precList2_);
253  }
254  IsInitialized_ = true;
255  ++NumInitialize_;
256  InitializeTime_ += (timer->wallTime() - startTime);
257 }
258 
259 template <class MatrixType>
260 void Hiptmair<MatrixType>::compute() {
261  const char methodName[] = "Ifpack2::Hiptmair::initialize";
262 
263  TEUCHOS_TEST_FOR_EXCEPTION(
264  A_.is_null(), std::runtime_error,
265  "Ifpack2::Hiptmair::compute: "
266  "The input matrix A is null. Please call setMatrix() with a nonnull "
267  "input matrix before calling this method.");
268 
269  // Don't time the initialize(); that gets timed separately.
270  if (!isInitialized()) {
271  initialize();
272  }
273 
274  Teuchos::RCP<Teuchos::Time> timer =
275  Teuchos::TimeMonitor::getNewCounter(methodName);
276 
277  double startTime = timer->wallTime();
278  { // The body of code to time
279  Teuchos::TimeMonitor timeMon(*timer);
280  ifpack2_prec1_->compute();
281  ifpack2_prec2_->compute();
282 
283  if (!ImplicitTranspose_ && Pt_.is_null()) {
284  using crs_type = Tpetra::CrsMatrix<typename MatrixType::scalar_type, typename MatrixType::local_ordinal_type, typename MatrixType::global_ordinal_type, typename MatrixType::node_type>;
285  Teuchos::RCP<const crs_type> crsP = Teuchos::rcp_dynamic_cast<const crs_type>(P_);
286  if (!crsP.is_null()) {
287  using transposer_type = Tpetra::RowMatrixTransposer<typename MatrixType::scalar_type, typename MatrixType::local_ordinal_type, typename MatrixType::global_ordinal_type, typename MatrixType::node_type>;
288  Pt_ = transposer_type(crsP).createTranspose();
289  } else {
290  TEUCHOS_TEST_FOR_EXCEPTION(true, std::runtime_error,
291  "Ifpack2::Hiptmair::compute: "
292  "ImplicitTranspose == false, but no Pt was provided and transposing P was not possible.");
293  }
294  }
295  }
296  IsComputed_ = true;
297  ++NumCompute_;
298  ComputeTime_ += (timer->wallTime() - startTime);
299 }
300 
301 template <class MatrixType>
302 void Hiptmair<MatrixType>::
303  apply(const Tpetra::MultiVector<typename MatrixType::scalar_type,
304  typename MatrixType::local_ordinal_type,
305  typename MatrixType::global_ordinal_type,
306  typename MatrixType::node_type>& X,
307  Tpetra::MultiVector<typename MatrixType::scalar_type,
308  typename MatrixType::local_ordinal_type,
309  typename MatrixType::global_ordinal_type,
310  typename MatrixType::node_type>& Y,
311  Teuchos::ETransp mode,
312  typename MatrixType::scalar_type alpha,
313  typename MatrixType::scalar_type beta) const {
314  using Teuchos::RCP;
315  using Teuchos::rcp;
316  using Teuchos::rcpFromRef;
317  typedef Tpetra::MultiVector<scalar_type, local_ordinal_type,
318  global_ordinal_type, node_type>
319  MV;
320  TEUCHOS_TEST_FOR_EXCEPTION(
321  !isComputed(), std::runtime_error,
322  "Ifpack2::Hiptmair::apply: You must call compute() before you may call apply().");
323  TEUCHOS_TEST_FOR_EXCEPTION(
324  X.getNumVectors() != Y.getNumVectors(), std::invalid_argument,
325  "Ifpack2::Hiptmair::apply: The MultiVector inputs X and Y do not have the "
326  "same number of columns. X.getNumVectors() = "
327  << X.getNumVectors()
328  << " != Y.getNumVectors() = " << Y.getNumVectors() << ".");
329 
330  // Catch unimplemented cases: alpha != 1, beta != 0, mode != NO_TRANS.
331  TEUCHOS_TEST_FOR_EXCEPTION(
332  alpha != STS::one(), std::logic_error,
333  "Ifpack2::Hiptmair::apply: alpha != 1 has not been implemented.");
334  TEUCHOS_TEST_FOR_EXCEPTION(
335  beta != STS::zero(), std::logic_error,
336  "Ifpack2::Hiptmair::apply: zero != 0 has not been implemented.");
337  TEUCHOS_TEST_FOR_EXCEPTION(
338  mode != Teuchos::NO_TRANS, std::logic_error,
339  "Ifpack2::Hiptmair::apply: mode != Teuchos::NO_TRANS has not been implemented.");
340 
341  const std::string timerName("Ifpack2::Hiptmair::apply");
342  Teuchos::RCP<Teuchos::Time> timer = Teuchos::TimeMonitor::lookupCounter(timerName);
343  if (timer.is_null()) {
344  timer = Teuchos::TimeMonitor::getNewCounter(timerName);
345  }
346  double startTime = timer->wallTime();
347  { // The body of code to time
348  Teuchos::TimeMonitor timeMon(*timer);
349 
350  // If X and Y are pointing to the same memory location,
351  // we need to create an auxiliary vector, Xcopy
352  RCP<const MV> Xcopy;
353  {
354  if (X.aliases(Y)) {
355  Xcopy = rcp(new MV(X, Teuchos::Copy));
356  } else {
357  Xcopy = rcpFromRef(X);
358  }
359  }
360 
361  RCP<MV> Ycopy = rcpFromRef(Y);
362  if (ZeroStartingSolution_) {
363  Ycopy->putScalar(STS::zero());
364  }
365 
366  // apply Hiptmair Smoothing
367  applyHiptmairSmoother(*Xcopy, *Ycopy);
368  }
369  ++NumApply_;
370  ApplyTime_ += (timer->wallTime() - startTime);
371 }
372 
373 template <class MatrixType>
374 void Hiptmair<MatrixType>::
375  updateCachedMultiVectors(const Teuchos::RCP<const Tpetra::Map<local_ordinal_type, global_ordinal_type, node_type>>& map1,
376  const Teuchos::RCP<const Tpetra::Map<local_ordinal_type, global_ordinal_type, node_type>>& map2,
377  size_t numVecs) const {
378  // Allocate a multivector if the cached one isn't perfect. Checking
379  // for map pointer equality is much cheaper than Map::isSameAs.
380  using MV = Tpetra::MultiVector<scalar_type, local_ordinal_type,
381  global_ordinal_type, node_type>;
382  if (cachedResidual1_.is_null() ||
383  map1.get() != cachedResidual1_->getMap().get() ||
384  cachedResidual1_->getNumVectors() != numVecs) {
385  cachedResidual1_ = Teuchos::rcp(new MV(map1, numVecs, false));
386  cachedSolution1_ = Teuchos::rcp(new MV(map1, numVecs, false));
387  }
388  if (cachedResidual2_.is_null() ||
389  map2.get() != cachedResidual2_->getMap().get() ||
390  cachedResidual2_->getNumVectors() != numVecs) {
391  cachedResidual2_ = Teuchos::rcp(new MV(map2, numVecs, false));
392  cachedSolution2_ = Teuchos::rcp(new MV(map2, numVecs, false));
393  }
394 }
395 
396 template <class MatrixType>
397 void Hiptmair<MatrixType>::
398  applyHiptmairSmoother(const Tpetra::MultiVector<typename MatrixType::scalar_type,
399  typename MatrixType::local_ordinal_type,
400  typename MatrixType::global_ordinal_type,
401  typename MatrixType::node_type>& X,
402  Tpetra::MultiVector<typename MatrixType::scalar_type,
403  typename MatrixType::local_ordinal_type,
404  typename MatrixType::global_ordinal_type,
405  typename MatrixType::node_type>& Y) const {
406  const scalar_type ZERO = STS::zero();
407  const scalar_type ONE = STS::one();
408 
409  const std::string timerName1("Ifpack2::Hiptmair::apply 1");
410  const std::string timerName2("Ifpack2::Hiptmair::apply 2");
411 
412  Teuchos::RCP<Teuchos::Time> timer1 = Teuchos::TimeMonitor::lookupCounter(timerName1);
413  if (timer1.is_null()) {
414  timer1 = Teuchos::TimeMonitor::getNewCounter(timerName1);
415  }
416  Teuchos::RCP<Teuchos::Time> timer2 = Teuchos::TimeMonitor::lookupCounter(timerName2);
417  if (timer2.is_null()) {
418  timer2 = Teuchos::TimeMonitor::getNewCounter(timerName2);
419  }
420 
421  //#define IFPACK2_DEBUG_SMOOTHER
422 #ifdef IFPACK2_DEBUG_SMOOTHER
423  int mypid = X.getMap()->getComm()->getRank();
424  Teuchos::Array<double> ttt(1);
425  printf("\n--------------------------------\n");
426  printf("Coming into matrix Hiptmair\n");
427  Y.norm2(ttt());
428  if (!mypid) printf("\t||x|| = %15.10e\n", ttt[0]);
429  X.norm2(ttt());
430  if (!mypid) printf("\t||rhs|| = %15.10e\n", ttt[0]);
431  {
432  double normA = A_->getFrobeniusNorm();
433  if (!mypid) printf("\t||A|| = %15.10e\n", normA);
434  Tpetra::Vector<typename MatrixType::scalar_type,
435  typename MatrixType::local_ordinal_type,
436  typename MatrixType::global_ordinal_type,
437  typename MatrixType::node_type>
438  d(A_->getRowMap());
439  A_->getLocalDiagCopy(d);
440  d.norm2(ttt);
441  if (!mypid) printf("\t||diag(A)|| = %15.10e\n", ttt[0]);
442  }
443  fflush(stdout);
444 #endif
445 
446  updateCachedMultiVectors(A_->getRowMap(),
447  PtAP_->getRowMap(),
448  X.getNumVectors());
449 
450  if (preOrPost_ == "pre" || preOrPost_ == "both") {
451  // apply initial relaxation to primary space
452  Teuchos::TimeMonitor timeMon(*timer1);
453  Tpetra::Details::residual(*A_, Y, X, *cachedResidual1_);
454  cachedSolution1_->putScalar(ZERO);
455  ifpack2_prec1_->apply(*cachedResidual1_, *cachedSolution1_);
456  Y.update(ONE, *cachedSolution1_, ONE);
457  }
458 
459  {
460  // project to auxiliary space and smooth
461  Teuchos::TimeMonitor timeMon(*timer2);
462  Tpetra::Details::residual(*A_, Y, X, *cachedResidual1_);
463 #ifdef IFPACK2_DEBUG_SMOOTHER
464  if (!mypid) printf(" After smoothing on edges\n");
465  Y.norm2(ttt());
466  if (!mypid) printf("\t||x|| = %15.10e\n", ttt[0]);
467  cachedResidual1_->norm2(ttt());
468  if (!mypid) printf("\t||res|| = %15.10e\n", ttt[0]);
469 #endif
470 
471  if (!Pt_.is_null())
472  Pt_->apply(*cachedResidual1_, *cachedResidual2_, Teuchos::NO_TRANS);
473  else
474  P_->apply(*cachedResidual1_, *cachedResidual2_, Teuchos::TRANS);
475  cachedSolution2_->putScalar(ZERO);
476 
477 #ifdef IFPACK2_DEBUG_SMOOTHER
478  if (!mypid) printf(" Before smoothing on nodes\n");
479  cachedSolution2_->norm2(ttt());
480  if (!mypid) printf("\t||x_nodal|| = %15.10e\n", ttt[0]);
481  cachedResidual2_->norm2(ttt());
482  if (!mypid) printf("\t||rhs_nodal|| = %15.10e\n", ttt[0]);
483  {
484  auto An = ifpack2_prec2_->getMatrix();
485  double normA = An->getFrobeniusNorm();
486  if (!mypid) printf("\t||An|| = %15.10e\n", normA);
487  Tpetra::Vector<typename MatrixType::scalar_type,
488  typename MatrixType::local_ordinal_type,
489  typename MatrixType::global_ordinal_type,
490  typename MatrixType::node_type>
491  d(An->getRowMap());
492  An->getLocalDiagCopy(d);
493  d.norm2(ttt);
494  if (!mypid) printf("\t||diag(An)|| = %15.10e\n", ttt[0]);
495  }
496 
497 #endif
498 
499  ifpack2_prec2_->apply(*cachedResidual2_, *cachedSolution2_);
500 
501 #ifdef IFPACK2_DEBUG_SMOOTHER
502  if (!mypid) printf(" After smoothing on nodes\n");
503  cachedSolution2_->norm2(ttt());
504  if (!mypid) printf("\t||x_nodal|| = %15.10e\n", ttt[0]);
505  cachedResidual2_->norm2(ttt());
506  if (!mypid) printf("\t||rhs_nodal|| = %15.10e\n", ttt[0]);
507 #endif
508 
509  P_->apply(*cachedSolution2_, Y, Teuchos::NO_TRANS, ONE, ONE);
510  }
511 
512  if (preOrPost_ == "post" || preOrPost_ == "both") {
513  // smooth again on primary space
514  Teuchos::TimeMonitor timeMon(*timer1);
515  Tpetra::Details::residual(*A_, Y, X, *cachedResidual1_);
516  cachedSolution1_->putScalar(ZERO);
517  ifpack2_prec1_->apply(*cachedResidual1_, *cachedSolution1_);
518  Y.update(ONE, *cachedSolution1_, ONE);
519  }
520 
521 #ifdef IFPACK2_DEBUG_SMOOTHER
522  if (!mypid) printf(" After updating edge solution\n");
523  Y.norm2(ttt());
524  if (!mypid) printf("\t||x|| = %15.10e\n", ttt[0]);
525  if (!mypid) printf("--------------------------------\n");
526 #endif
527 }
528 
529 template <class MatrixType>
530 std::string Hiptmair<MatrixType>::description() const {
531  std::ostringstream os;
532 
533  // Output is a valid YAML dictionary in flow style. If you don't
534  // like everything on a single line, you should call describe()
535  // instead.
536  os << "\"Ifpack2::Hiptmair\": {";
537  if (this->getObjectLabel() != "") {
538  os << "Label: \"" << this->getObjectLabel() << "\", ";
539  }
540  os << "Initialized: " << (isInitialized() ? "true" : "false") << ", "
541  << "Computed: " << (isComputed() ? "true" : "false") << ", ";
542 
543  if (A_.is_null()) {
544  os << "Matrix: null, ";
545  } else {
546  os << "Matrix: not null"
547  << ", Global matrix dimensions: ["
548  << A_->getGlobalNumRows() << ", " << A_->getGlobalNumCols() << "], ";
549  }
550 
551  os << "Smoother 1: ";
552  os << ifpack2_prec1_->description() << ", ";
553  os << "Smoother 2: ";
554  os << ifpack2_prec2_->description();
555 
556  os << "}";
557  return os.str();
558 }
559 
560 template <class MatrixType>
561 void Hiptmair<MatrixType>::
562  describe(Teuchos::FancyOStream& out,
563  const Teuchos::EVerbosityLevel verbLevel) const {
564  using std::endl;
565  using std::setw;
566  using Teuchos::VERB_DEFAULT;
567  using Teuchos::VERB_EXTREME;
568  using Teuchos::VERB_HIGH;
569  using Teuchos::VERB_LOW;
570  using Teuchos::VERB_MEDIUM;
571  using Teuchos::VERB_NONE;
572 
573  const Teuchos::EVerbosityLevel vl =
574  (verbLevel == VERB_DEFAULT) ? VERB_LOW : verbLevel;
575 
576  if (vl != VERB_NONE) {
577  // describe() always starts with a tab by convention.
578  Teuchos::OSTab tab0(out);
579  out << "\"Ifpack2::Hiptmair\":";
580 
581  Teuchos::OSTab tab1(out);
582  if (this->getObjectLabel() != "") {
583  out << "Label: " << this->getObjectLabel() << endl;
584  }
585  out << "Initialized: " << (isInitialized() ? "true" : "false") << endl
586  << "Computed: " << (isComputed() ? "true" : "false") << endl
587  << "Global number of rows: " << A_->getGlobalNumRows() << endl
588  << "Global number of columns: " << A_->getGlobalNumCols() << endl
589  << "Matrix:";
590  if (A_.is_null()) {
591  out << " null" << endl;
592  } else {
593  A_->describe(out, vl);
594  }
595  out << "Smoother 1: ";
596  ifpack2_prec1_->describe(out, vl);
597  out << "Smoother 2: ";
598  ifpack2_prec2_->describe(out, vl);
599  }
600 }
601 
602 } // namespace Ifpack2
603 
604 #define IFPACK2_HIPTMAIR_INSTANT(S, LO, GO, N) \
605  template class Ifpack2::Hiptmair<Tpetra::RowMatrix<S, LO, GO, N>>;
606 
607 #endif /* IFPACK2_HIPTMAIR_DEF_HPP */
Ifpack2::Hiptmair::initialize
void initialize()
Do any initialization that depends on the input matrix&#39;s structure.
Definition: Ifpack2_Hiptmair_def.hpp:219
Teuchos::VERB_DEFAULT
is_null
bool is_null(const boost::shared_ptr< T > &p)
Ifpack2::Details::OneLevelFactory::create
Teuchos::RCP< prec_type > create(const std::string &precType, const Teuchos::RCP< const row_matrix_type > &matrix) const
Create an instance of Preconditioner given the string name of the preconditioner type.
Definition: Ifpack2_Details_OneLevelFactory_def.hpp:52
Teuchos::VERB_LOW
Teuchos::VERB_NONE
Teuchos::ParameterList::get
T & get(const std::string &name, T def_value)
Ifpack2::Hiptmair::local_ordinal_type
MatrixType::local_ordinal_type local_ordinal_type
The type of local indices in the input MatrixType.
Definition: Ifpack2_Hiptmair_decl.hpp:50
Teuchos::TimeMonitor::getNewCounter
static RCP< Time > getNewCounter(const std::string &name)
Teuchos::TimeMonitor::lookupCounter
static RCP< Time > lookupCounter(const std::string &name)
Ifpack2::Hiptmair::Hiptmair
Hiptmair(const Teuchos::RCP< const row_matrix_type > &A)
Constructor that takes 1 Tpetra matrix (assumes we&#39;ll get the rest off the parameter list) ...
Definition: Ifpack2_Hiptmair_def.hpp:55
TEUCHOS_TEST_FOR_EXCEPTION
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Ifpack2::Hiptmair::scalar_type
MatrixType::scalar_type scalar_type
The type of the entries of the input MatrixType.
Definition: Ifpack2_Hiptmair_decl.hpp:47
Ifpack2::Hiptmair::getComputeTime
double getComputeTime() const
Returns the time spent in Compute().
Definition: Ifpack2_Hiptmair_def.hpp:199
Teuchos::VERB_EXTREME
Ifpack2::Hiptmair::getComm
Teuchos::RCP< const Teuchos::Comm< int > > getComm() const
Returns the operator&#39;s communicator.
Definition: Ifpack2_Hiptmair_def.hpp:134
Ifpack2::Hiptmair::hasTransposeApply
bool hasTransposeApply() const
Whether this object&#39;s apply() method can apply the transpose (or conjugate transpose, if applicable).
Definition: Ifpack2_Hiptmair_def.hpp:172
Teuchos::EVerbosityLevel
EVerbosityLevel
Ifpack2::Hiptmair::describe
void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel=Teuchos::Describable::verbLevel_default) const
Print the object with some verbosity level to an FancyOStream object.
Definition: Ifpack2_Hiptmair_def.hpp:562
Ifpack2::Hiptmair::getApplyTime
double getApplyTime() const
Returns the time spent in apply().
Definition: Ifpack2_Hiptmair_def.hpp:204
Ifpack2::Hiptmair::getPrec1
Teuchos::RCP< Ifpack2::Preconditioner< typename MatrixType::scalar_type, typename MatrixType::local_ordinal_type, typename MatrixType::global_ordinal_type, typename MatrixType::node_type > > getPrec1()
Returns prec 1.
Definition: Ifpack2_Hiptmair_def.hpp:209
Teuchos::basic_OSTab
Ifpack2::Hiptmair::setParameters
void setParameters(const Teuchos::ParameterList &params)
Set the preconditioner&#39;s parameters.
Definition: Ifpack2_Hiptmair_def.hpp:82
Ifpack2::Hiptmair::getMatrix
Teuchos::RCP< const Tpetra::RowMatrix< scalar_type, local_ordinal_type, global_ordinal_type, node_type > > getMatrix() const
Returns a reference to the matrix to be preconditioned.
Definition: Ifpack2_Hiptmair_def.hpp:145
Teuchos::VERB_MEDIUM
Ifpack2::Hiptmair::getRangeMap
Teuchos::RCP< const Tpetra::Map< local_ordinal_type, global_ordinal_type, node_type > > getRangeMap() const
Tpetra::Map representing the range of this operator.
Definition: Ifpack2_Hiptmair_def.hpp:162
Ifpack2::Hiptmair::global_ordinal_type
MatrixType::global_ordinal_type global_ordinal_type
The type of global indices in the input MatrixType.
Definition: Ifpack2_Hiptmair_decl.hpp:53
Ifpack2::Hiptmair::getNumApply
int getNumApply() const
Returns the number of calls to apply().
Definition: Ifpack2_Hiptmair_def.hpp:189
Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Teuchos::VERB_HIGH
Ifpack2::Hiptmair
Wrapper for Hiptmair smoothers.
Definition: Ifpack2_Hiptmair_decl.hpp:38
Teuchos::basic_FancyOStream
Ifpack2::Hiptmair::getNumCompute
int getNumCompute() const
Returns the number of calls to Compute().
Definition: Ifpack2_Hiptmair_def.hpp:184
Ifpack2::Hiptmair::getNumInitialize
int getNumInitialize() const
Returns the number of calls to Initialize().
Definition: Ifpack2_Hiptmair_def.hpp:179
Ifpack2::Hiptmair::node_type
MatrixType::node_type node_type
The Node type used by the input MatrixType.
Definition: Ifpack2_Hiptmair_decl.hpp:56
Ifpack2::Hiptmair::compute
void compute()
Do any initialization that depends on the input matrix&#39;s values.
Definition: Ifpack2_Hiptmair_def.hpp:260
Ifpack2::Hiptmair::~Hiptmair
virtual ~Hiptmair()
Destructor.
Definition: Ifpack2_Hiptmair_def.hpp:79
Ifpack2::Hiptmair::description
std::string description() const
Return a simple one-line description of this object.
Definition: Ifpack2_Hiptmair_def.hpp:530
Ifpack2::Hiptmair::getDomainMap
Teuchos::RCP< const Tpetra::Map< local_ordinal_type, global_ordinal_type, node_type > > getDomainMap() const
Tpetra::Map representing the domain of this operator.
Definition: Ifpack2_Hiptmair_def.hpp:151
Ifpack2::Hiptmair::updateCachedMultiVectors
void updateCachedMultiVectors(const Teuchos::RCP< const Tpetra::Map< local_ordinal_type, global_ordinal_type, node_type >> &map1, const Teuchos::RCP< const Tpetra::Map< local_ordinal_type, global_ordinal_type, node_type >> &map2, size_t numVecs) const
A service routine for updating the cached MultiVectors.
Definition: Ifpack2_Hiptmair_def.hpp:375
Teuchos::as
TypeTo as(const TypeFrom &t)
Ifpack2::Hiptmair::getPrec2
Teuchos::RCP< Ifpack2::Preconditioner< typename MatrixType::scalar_type, typename MatrixType::local_ordinal_type, typename MatrixType::global_ordinal_type, typename MatrixType::node_type > > getPrec2()
Returns prec 2.
Definition: Ifpack2_Hiptmair_def.hpp:214
Ifpack2::Hiptmair::getInitializeTime
double getInitializeTime() const
Returns the time spent in Initialize().
Definition: Ifpack2_Hiptmair_def.hpp:194
Teuchos_TimeMonitor.hpp
Ifpack2::Details::OneLevelFactory
&quot;Factory&quot; for creating single-level preconditioners.
Definition: Ifpack2_Details_OneLevelFactory_decl.hpp:92
Teuchos::Time::wallTime
static double wallTime()
Teuchos::RCP::is_null
bool is_null() const
Ifpack2::Hiptmair::apply
void apply(const Tpetra::MultiVector< scalar_type, local_ordinal_type, global_ordinal_type, node_type > &X, Tpetra::MultiVector< scalar_type, local_ordinal_type, global_ordinal_type, node_type > &Y, Teuchos::ETransp mode=Teuchos::NO_TRANS, scalar_type alpha=Teuchos::ScalarTraits< scalar_type >::one(), scalar_type beta=Teuchos::ScalarTraits< scalar_type >::zero()) const
Apply the preconditioner to X, putting the result in Y.
Definition: Ifpack2_Hiptmair_def.hpp:303
Generated by   doxygen 1.8.5