Ifpack2 Templated Preconditioning Package  Version 1.0
Ifpack2_LocalSparseTriangularSolver_def.hpp
1 /*@HEADER
2 // ***********************************************************************
3 //
4 // Ifpack2: Templated Object-Oriented Algebraic Preconditioner Package
5 // Copyright (2009) Sandia Corporation
6 //
7 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8 // license for use of this work by or on behalf of the U.S. Government.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // Questions? Contact Michael A. Heroux (maherou@sandia.gov)
38 //
39 // ***********************************************************************
40 //@HEADER
41 */
42 
43 #ifndef IFPACK2_LOCALSPARSETRIANGULARSOLVER_DEF_HPP
44 #define IFPACK2_LOCALSPARSETRIANGULARSOLVER_DEF_HPP
45 
46 #include "Tpetra_CrsMatrix.hpp"
47 #include "Tpetra_DefaultPlatform.hpp"
48 
49 namespace Ifpack2 {
50 
51 template<class MatrixType>
53 LocalSparseTriangularSolver (const Teuchos::RCP<const row_matrix_type>& A) :
54  A_ (A),
55  isInitialized_ (false),
56  isComputed_ (false),
57  numInitialize_ (0),
58  numCompute_ (0),
59  numApply_ (0),
60  initializeTime_ (0.0),
61  computeTime_ (0.0),
62  applyTime_ (0.0)
63 {
64  typedef typename Tpetra::CrsMatrix<scalar_type, local_ordinal_type,
65  global_ordinal_type, node_type> crs_matrix_type;
66  if (! A.is_null ()) {
67  Teuchos::RCP<const crs_matrix_type> A_crs =
68  Teuchos::rcp_dynamic_cast<const crs_matrix_type> (A);
69  TEUCHOS_TEST_FOR_EXCEPTION
70  (A_crs.is_null (), std::invalid_argument,
71  "Ifpack2::LocalSparseTriangularSolver constructor: "
72  "The input matrix A is not a Tpetra::CrsMatrix.");
73  A_crs_ = A_crs;
74  }
75 }
76 
77 template<class MatrixType>
79 LocalSparseTriangularSolver (const Teuchos::RCP<const row_matrix_type>& A,
80  const Teuchos::RCP<Teuchos::FancyOStream>& out) :
81  A_ (A),
82  out_ (out),
83  isInitialized_ (false),
84  isComputed_ (false),
85  numInitialize_ (0),
86  numCompute_ (0),
87  numApply_ (0),
88  initializeTime_ (0.0),
89  computeTime_ (0.0),
90  applyTime_ (0.0)
91 {
92  if (! out_.is_null ()) {
93  *out_ << ">>> DEBUG Ifpack2::LocalSparseTriangularSolver constructor"
94  << std::endl;
95  }
96  typedef typename Tpetra::CrsMatrix<scalar_type, local_ordinal_type,
97  global_ordinal_type, node_type> crs_matrix_type;
98  if (! A.is_null ()) {
99  Teuchos::RCP<const crs_matrix_type> A_crs =
100  Teuchos::rcp_dynamic_cast<const crs_matrix_type> (A);
101  TEUCHOS_TEST_FOR_EXCEPTION
102  (A_crs.is_null (), std::invalid_argument,
103  "Ifpack2::LocalSparseTriangularSolver constructor: "
104  "The input matrix A is not a Tpetra::CrsMatrix.");
105  A_crs_ = A_crs;
106  }
107 }
108 
109 template<class MatrixType>
112 {}
113 
114 template<class MatrixType>
115 void
117 setParameters (const Teuchos::ParameterList& /*params*/)
118 {}
119 
120 template<class MatrixType>
121 void
124 {
125  const char prefix[] = "Ifpack2::LocalSparseTriangularSolver::initialize: ";
126  if (! out_.is_null ()) {
127  *out_ << ">>> DEBUG " << prefix << std::endl;
128  }
129 
130  TEUCHOS_TEST_FOR_EXCEPTION
131  (A_.is_null (), std::runtime_error, prefix << "You must call "
132  "setMatrix() with a nonnull input matrix before you may call "
133  "initialize() or compute().");
134  if (A_crs_.is_null ()) {
135  typedef typename Tpetra::CrsMatrix<scalar_type, local_ordinal_type,
136  global_ordinal_type, node_type> crs_matrix_type;
137  Teuchos::RCP<const crs_matrix_type> A_crs =
138  Teuchos::rcp_dynamic_cast<const crs_matrix_type> (A_);
139  TEUCHOS_TEST_FOR_EXCEPTION
140  (A_crs.is_null (), std::invalid_argument, prefix <<
141  "The input matrix A is not a Tpetra::CrsMatrix.");
142  A_crs_ = A_crs;
143  }
144  auto G = A_->getGraph ();
145  TEUCHOS_TEST_FOR_EXCEPTION
146  (G.is_null (), std::logic_error, prefix << "A_ and A_crs_ are nonnull, "
147  "but A_'s RowGraph G is null. "
148  "Please report this bug to the Ifpack2 developers.");
149  // At this point, the graph MUST be fillComplete. The "initialize"
150  // (symbolic) part of setup only depends on the graph structure, so
151  // the matrix itself need not be fill complete.
152  TEUCHOS_TEST_FOR_EXCEPTION
153  (! G->isFillComplete (), std::runtime_error, "If you call this method, "
154  "the matrix's graph must be fill complete. It is not.");
155 
156  isInitialized_ = true;
157  ++numInitialize_;
158 }
159 
160 template<class MatrixType>
161 void
164 {
165  const char prefix[] = "Ifpack2::LocalSparseTriangularSolver::compute: ";
166  if (! out_.is_null ()) {
167  *out_ << ">>> DEBUG " << prefix << std::endl;
168  }
169 
170  TEUCHOS_TEST_FOR_EXCEPTION
171  (A_.is_null (), std::runtime_error, prefix << "You must call "
172  "setMatrix() with a nonnull input matrix before you may call "
173  "initialize() or compute().");
174  TEUCHOS_TEST_FOR_EXCEPTION
175  (A_crs_.is_null (), std::logic_error, prefix << "A_ is nonnull, but "
176  "A_crs_ is null. Please report this bug to the Ifpack2 developers.");
177  // At this point, the matrix MUST be fillComplete.
178  TEUCHOS_TEST_FOR_EXCEPTION
179  (! A_crs_->isFillComplete (), std::runtime_error, "If you call this "
180  "method, the matrix must be fill complete. It is not.");
181 
182  if (! isInitialized_) {
183  initialize ();
184  }
185  TEUCHOS_TEST_FOR_EXCEPTION
186  (! isInitialized_, std::logic_error, prefix << "initialize() should have "
187  "been called by this point, but isInitialized_ is false. "
188  "Please report this bug to the Ifpack2 developers.");
189 
190  isComputed_ = true;
191  ++numCompute_;
192 }
193 
194 template<class MatrixType>
196 apply (const Tpetra::MultiVector<scalar_type, local_ordinal_type,
198  Tpetra::MultiVector<scalar_type, local_ordinal_type,
200  Teuchos::ETransp mode,
201  scalar_type alpha,
202  scalar_type beta) const
203 {
204  using Teuchos::RCP;
205  using Teuchos::rcp;
206  using Teuchos::rcpFromRef;
207  typedef scalar_type ST;
208  typedef Teuchos::ScalarTraits<ST> STS;
209  const char prefix[] = "Ifpack2::LocalSparseTriangularSolver::apply: ";
210  if (! out_.is_null ()) {
211  *out_ << ">>> DEBUG " << prefix;
212  if (A_crs_.is_null ()) {
213  *out_ << "A_crs_ is null!" << std::endl;
214  }
215  else {
216  const std::string uplo = A_crs_->isUpperTriangular () ? "U" :
217  (A_crs_->isLowerTriangular () ? "L" : "N");
218  const std::string trans = (mode == Teuchos::CONJ_TRANS) ? "C" :
219  (mode == Teuchos::TRANS ? "T" : "N");
220  const std::string diag =
221  (A_crs_->getNodeNumDiags () < A_crs_->getNodeNumRows ()) ? "U" : "N";
222  *out_ << "uplo=\"" << uplo
223  << "\", trans=\"" << trans
224  << "\", diag=\"" << diag << "\"" << std::endl;
225  }
226  }
227 
228  TEUCHOS_TEST_FOR_EXCEPTION
229  (! isComputed (), std::runtime_error, prefix << "If compute() has not yet "
230  "been called, or if you have changed the matrix via setMatrix(), you must "
231  "call compute() before you may call this method.");
232  // If isComputed() is true, it's impossible for the matrix to be
233  // null, or for it not to be a Tpetra::CrsMatrix.
234  TEUCHOS_TEST_FOR_EXCEPTION
235  (A_.is_null (), std::logic_error, prefix << "A_ is null. "
236  "Please report this bug to the Ifpack2 developers.");
237  TEUCHOS_TEST_FOR_EXCEPTION
238  (A_crs_.is_null (), std::logic_error, prefix << "A_crs_ is null. "
239  "Please report this bug to the Ifpack2 developers.");
240  // However, it _is_ possible that the user called resumeFill() on
241  // the matrix, after calling compute(). This is NOT allowed.
242  TEUCHOS_TEST_FOR_EXCEPTION
243  (! A_crs_->isFillComplete (), std::runtime_error, "If you call this "
244  "method, the matrix must be fill complete. It is not. This means that "
245  " you must have called resumeFill() on the matrix before calling apply(). "
246  "This is NOT allowed. Note that this class may use the matrix's data in "
247  "place without copying it. Thus, you cannot change the matrix and expect "
248  "the solver to stay the same. If you have changed the matrix, first call "
249  "fillComplete() on it, then call compute() on this object, before you call"
250  " apply(). You do NOT need to call setMatrix, as long as the matrix "
251  "itself (that is, its address in memory) is the same.");
252 
253  auto G = A_->getGraph ();
254  TEUCHOS_TEST_FOR_EXCEPTION
255  (G.is_null (), std::logic_error, prefix << "A_ and A_crs_ are nonnull, "
256  "but A_'s RowGraph G is null. "
257  "Please report this bug to the Ifpack2 developers.");
258  auto importer = G->getImporter ();
259  auto exporter = G->getExporter ();
260 
261  if (! importer.is_null ()) {
262  if (X_colMap_.is_null () || X_colMap_->getNumVectors () != X.getNumVectors ()) {
263  X_colMap_ = rcp (new MV (importer->getTargetMap (), X.getNumVectors ()));
264  }
265  else {
266  X_colMap_->putScalar (STS::zero ());
267  }
268  // See discussion of Github Issue #672 for why the Import needs to
269  // use the ZERO CombineMode. The case where the Export is
270  // nontrivial is likely never exercised.
271  X_colMap_->doImport (X, *importer, Tpetra::ZERO);
272  }
273  RCP<const MV> X_cur = importer.is_null () ? rcpFromRef (X) :
274  Teuchos::rcp_const_cast<const MV> (X_colMap_);
275 
276  if (! exporter.is_null ()) {
277  if (Y_rowMap_.is_null () || Y_rowMap_->getNumVectors () != Y.getNumVectors ()) {
278  Y_rowMap_ = rcp (new MV (exporter->getSourceMap (), Y.getNumVectors ()));
279  }
280  else {
281  Y_rowMap_->putScalar (STS::zero ());
282  }
283  Y_rowMap_->doExport (Y, *importer, Tpetra::ADD);
284  }
285  RCP<MV> Y_cur = exporter.is_null () ? rcpFromRef (Y) : Y_rowMap_;
286 
287  localApply (*X_cur, *Y_cur, mode, alpha, beta);
288 
289  if (! exporter.is_null ()) {
290  Y.putScalar (STS::zero ());
291  Y.doExport (*Y_cur, *exporter, Tpetra::ADD);
292  }
293 
294  ++numApply_;
295 }
296 
297 template<class MatrixType>
298 void
300 localApply (const MV& X,
301  MV& Y,
302  const Teuchos::ETransp mode,
303  const scalar_type& alpha,
304  const scalar_type& beta) const
305 {
306  using Teuchos::RCP;
307  typedef scalar_type ST;
308  typedef Teuchos::ScalarTraits<ST> STS;
309 
310  if (beta == STS::zero ()) {
311  if (alpha == STS::zero ()) {
312  Y.putScalar (STS::zero ()); // Y := 0 * Y (ignore contents of Y)
313  }
314  else { // alpha != 0
315  A_crs_->template localSolve<ST, ST> (X, Y, mode);
316  if (alpha != STS::one ()) {
317  Y.scale (alpha);
318  }
319  }
320  }
321  else { // beta != 0
322  if (alpha == STS::zero ()) {
323  Y.scale (beta); // Y := beta * Y
324  }
325  else { // alpha != 0
326  MV Y_tmp (Y, Teuchos::Copy);
327  A_crs_->template localSolve<ST, ST> (X, Y_tmp, mode); // Y_tmp := M * X
328  Y.update (alpha, Y_tmp, beta); // Y := beta * Y + alpha * Y_tmp
329  }
330  }
331 }
332 
333 
334 template <class MatrixType>
335 int
338  return numInitialize_;
339 }
340 
341 template <class MatrixType>
342 int
344 getNumCompute () const {
345  return numCompute_;
346 }
347 
348 template <class MatrixType>
349 int
351 getNumApply () const {
352  return numApply_;
353 }
354 
355 template <class MatrixType>
356 double
359  return initializeTime_;
360 }
361 
362 template<class MatrixType>
363 double
365 getComputeTime () const {
366  return computeTime_;
367 }
368 
369 template<class MatrixType>
370 double
372 getApplyTime() const {
373  return applyTime_;
374 }
375 
376 template <class MatrixType>
377 std::string
379 description () const
380 {
381  std::ostringstream os;
382 
383  // Output is a valid YAML dictionary in flow style. If you don't
384  // like everything on a single line, you should call describe()
385  // instead.
386  os << "\"Ifpack2::LocalSparseTriangularSolver\": {";
387  if (this->getObjectLabel () != "") {
388  os << "Label: \"" << this->getObjectLabel () << "\", ";
389  }
390  os << "Initialized: " << (isInitialized () ? "true" : "false") << ", "
391  << "Computed: " << (isComputed () ? "true" : "false") << ", ";
392 
393  if (A_.is_null ()) {
394  os << "Matrix: null";
395  }
396  else {
397  os << "Matrix: not null"
398  << ", Global matrix dimensions: ["
399  << A_->getGlobalNumRows () << ", "
400  << A_->getGlobalNumCols () << "]";
401  }
402 
403  os << "}";
404  return os.str ();
405 }
406 
407 template <class MatrixType>
409 describe (Teuchos::FancyOStream& out,
410  const Teuchos::EVerbosityLevel verbLevel) const
411 {
412  using std::endl;
413  // Default verbosity level is VERB_LOW, which prints only on Process
414  // 0 of the matrix's communicator.
415  const Teuchos::EVerbosityLevel vl
416  = (verbLevel == Teuchos::VERB_DEFAULT) ? Teuchos::VERB_LOW : verbLevel;
417 
418  if (vl != Teuchos::VERB_NONE) {
419  // Print only on Process 0 in the matrix's communicator. If the
420  // matrix is null, though, we have to get the communicator from
421  // somewhere, so we ask Tpetra for its default communicator. If
422  // MPI is enabled, this wraps MPI_COMM_WORLD or a clone thereof.
423  auto comm = A_.is_null () ?
424  Tpetra::DefaultPlatform::getDefaultPlatform ().getComm () :
425  A_->getComm ();
426 
427  // Users aren't supposed to do anything with the matrix on
428  // processes where its communicator is null.
429  if (! comm.is_null () && comm->getRank () == 0) {
430  // By convention, describe() should always begin with a tab.
431  Teuchos::OSTab tab0 (out);
432  // Output is in YAML format. We have to escape the class name,
433  // because it has a colon.
434  out << "\"Ifpack2::LocalSparseTriangularSolver\":" << endl;
435  Teuchos::OSTab tab1 (out);
436  out << "Scalar: " << Teuchos::TypeNameTraits<scalar_type>::name () << endl
437  << "LocalOrdinal: " << Teuchos::TypeNameTraits<local_ordinal_type>::name () << endl
438  << "GlobalOrdinal: " << Teuchos::TypeNameTraits<global_ordinal_type>::name () << endl
439  << "Node: " << Teuchos::TypeNameTraits<node_type>::name () << endl;
440  }
441  }
442 }
443 
444 template <class MatrixType>
445 Teuchos::RCP<const typename LocalSparseTriangularSolver<MatrixType>::map_type>
447 getDomainMap () const
448 {
449  TEUCHOS_TEST_FOR_EXCEPTION
450  (A_.is_null (), std::runtime_error,
451  "Ifpack2::LocalSparseTriangularSolver::getDomainMap: "
452  "The matrix is null. Please call setMatrix() with a nonnull input "
453  "before calling this method.");
454  return A_->getDomainMap ();
455 }
456 
457 template <class MatrixType>
458 Teuchos::RCP<const typename LocalSparseTriangularSolver<MatrixType>::map_type>
460 getRangeMap () const
461 {
462  TEUCHOS_TEST_FOR_EXCEPTION
463  (A_.is_null (), std::runtime_error,
464  "Ifpack2::LocalSparseTriangularSolver::getRangeMap: "
465  "The matrix is null. Please call setMatrix() with a nonnull input "
466  "before calling this method.");
467  return A_->getRangeMap ();
468 }
469 
470 template<class MatrixType>
472 setMatrix (const Teuchos::RCP<const row_matrix_type>& A)
473 {
474  const char prefix[] = "Ifpack2::LocalSparseTriangularSolver::setMatrix: ";
475 
476  // If the pointer didn't change, do nothing. This is reasonable
477  // because users are supposed to call this method with the same
478  // object over all participating processes, and pointer identity
479  // implies object identity.
480  if (A.getRawPtr () != A_.getRawPtr ()) {
481  // Check in serial or one-process mode if the matrix is square.
482  TEUCHOS_TEST_FOR_EXCEPTION
483  (! A.is_null () && A->getComm ()->getSize () == 1 &&
484  A->getNodeNumRows () != A->getNodeNumCols (),
485  std::runtime_error, prefix << "If A's communicator only contains one "
486  "process, then A must be square. Instead, you provided a matrix A with "
487  << A->getNodeNumRows () << " rows and " << A->getNodeNumCols ()
488  << " columns.");
489 
490  // It's legal for A to be null; in that case, you may not call
491  // initialize() until calling setMatrix() with a nonnull input.
492  // Regardless, setting the matrix invalidates the preconditioner.
493  isInitialized_ = false;
494  isComputed_ = false;
495 
496  typedef typename Tpetra::CrsMatrix<scalar_type, local_ordinal_type,
497  global_ordinal_type, node_type> crs_matrix_type;
498  if (A.is_null ()) {
499  A_crs_ = Teuchos::null;
500  A_ = Teuchos::null;
501  }
502  else { // A is not null
503  Teuchos::RCP<const crs_matrix_type> A_crs =
504  Teuchos::rcp_dynamic_cast<const crs_matrix_type> (A);
505  TEUCHOS_TEST_FOR_EXCEPTION
506  (A_crs.is_null (), std::invalid_argument, prefix <<
507  "The input matrix A is not a Tpetra::CrsMatrix.");
508  A_crs_ = A_crs;
509  A_ = A;
510  }
511  } // pointers are not the same
512 }
513 
514 } // namespace Ifpack2
515 
516 #define IFPACK2_LOCALSPARSETRIANGULARSOLVER_INSTANT(S,LO,GO,N) \
517  template class Ifpack2::LocalSparseTriangularSolver< Tpetra::RowMatrix<S, LO, GO, N> >;
518 
519 #endif // IFPACK2_LOCALSPARSETRIANGULARSOLVER_DEF_HPP
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, and put the result in Y.
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:196
int getNumInitialize() const
Return the number of calls to initialize().
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:337
Teuchos::RCP< const map_type > getDomainMap() const
The domain of this operator.
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:447
Teuchos::RCP< const map_type > getRangeMap() const
The range of this operator.
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:460
int getNumCompute() const
Return the number of calls to compute().
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:344
double getApplyTime() const
Return the time spent in apply().
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:372
void compute()
"Numeric" phase of setup
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:163
void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel=Teuchos::Describable::verbLevel_default) const
Print this object with given verbosity to the given output stream.
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:409
MatrixType::global_ordinal_type global_ordinal_type
Type of the global indices of the input matrix.
Definition: Ifpack2_LocalSparseTriangularSolver_decl.hpp:99
MatrixType::node_type node_type
Node type of the input matrix.
Definition: Ifpack2_LocalSparseTriangularSolver_decl.hpp:101
double getComputeTime() const
Return the time spent in compute().
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:365
int getNumApply() const
Return the number of calls to apply().
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:351
"Preconditioner" that solves local sparse triangular systems.
Definition: Ifpack2_LocalSparseTriangularSolver_decl.hpp:83
void initialize()
"Symbolic" phase of setup
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:123
virtual void setMatrix(const Teuchos::RCP< const row_matrix_type > &A)
Set this preconditioner&#39;s matrix.
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:472
LocalSparseTriangularSolver(const Teuchos::RCP< const row_matrix_type > &A)
Constructor.
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:53
double getInitializeTime() const
Return the time spent in initialize().
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:358
MatrixType::local_ordinal_type local_ordinal_type
Type of the local indices of the input matrix.
Definition: Ifpack2_LocalSparseTriangularSolver_decl.hpp:97
void setParameters(const Teuchos::ParameterList &params)
Set this object&#39;s parameters.
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:117
MatrixType::scalar_type scalar_type
Type of the entries of the input matrix.
Definition: Ifpack2_LocalSparseTriangularSolver_decl.hpp:95
std::string description() const
A one-line description of this object.
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:379
Preconditioners and smoothers for Tpetra sparse matrices.
Definition: Ifpack2_AdditiveSchwarz_decl.hpp:72
virtual ~LocalSparseTriangularSolver()
Destructor (virtual for memory safety).
Definition: Ifpack2_LocalSparseTriangularSolver_def.hpp:111