43 #ifndef IFPACK2_BANDEDCONTAINER_DEF_HPP 44 #define IFPACK2_BANDEDCONTAINER_DEF_HPP 47 #include "Tpetra_CrsMatrix.hpp" 55 # include "Teuchos_DefaultSerialComm.hpp" 60 template<
class MatrixType,
class LocalScalarType>
61 BandedContainer<MatrixType, LocalScalarType, true>::
66 scalar_type DampingFactor) :
67 Container<MatrixType>(matrix, partitions, importer, OverlapLevel, DampingFactor),
68 ipiv_(this->partitions_.size()),
69 kl_(this->numBlocks_, -1),
70 ku_(this->numBlocks_, -1),
72 scalarOffsets_(this->numBlocks_)
75 ! matrix->hasColMap (), std::invalid_argument,
"Ifpack2::BandedContainer: " 76 "The constructor's input matrix must have a column Map.");
79 const map_type& rowMap = * (matrix->getRowMap ());
80 for(
int i = 0; i < this->numBlocks_; i++)
83 for(local_ordinal_type j = 0; j < this->blockRows_[i]; j++)
86 !rowMap.isNodeLocalElement(localRows[j]),
87 std::invalid_argument,
"Ifpack2::BandedContainer: " 88 "On process " << rowMap.getComm ()->getRank () <<
" of " 89 << rowMap.getComm ()->getSize () <<
", in the given set of local row " 91 "entry is not valid local row indices on the calling process: " 92 << localRows[j] <<
".");
95 IsInitialized_ =
false;
99 template<
class MatrixType,
class LocalScalarType>
100 BandedContainer<MatrixType, LocalScalarType, true>::
103 Container<MatrixType>(matrix, localRows),
104 ipiv_(this->blockRows_[0]),
111 "The constructor's input matrix must have a column Map.");
114 const map_type& rowMap = *(matrix->getRowMap());
115 for(local_ordinal_type j = 0; j < this->blockRows_[0]; j++)
118 !rowMap.isNodeLocalElement(localRows[j]),
119 std::invalid_argument,
"Ifpack2::BandedContainer: " 120 "On process " << rowMap.getComm()->getRank() <<
" of " 121 << rowMap.getComm()->getSize() <<
", in the given set of local row " 123 "entry is not valid local row indices on the calling process: " 124 << localRows[j] <<
".");
126 IsInitialized_ =
false;
130 template<
class MatrixType,
class LocalScalarType>
131 BandedContainer<MatrixType, LocalScalarType, true>::
138 template<
class MatrixType,
class LocalScalarType>
139 void BandedContainer<MatrixType, LocalScalarType, true>::
143 if(List.
isParameter(
"relaxation: banded container superdiagonals"))
144 kl_[0] = List.
get<
int>(
"relaxation: banded container superdiagonals");
145 if(List.
isParameter(
"relaxation: banded container subdiagonals"))
146 ku_[0] = List.
get<
int>(
"relaxation: banded container subdiagonals");
148 for(local_ordinal_type b = 1; b < this->numBlocks_; b++)
156 for(local_ordinal_type b = 0; b < this->numBlocks_; b++)
158 if (ku_[b] == -1 || kl_[b] == -1)
161 const size_type numRows = localRows.
size();
164 for(size_type i = 0; i < numRows; ++i)
168 this->inputMatrix_->getLocalRowView(localRows[i], indices, values);
170 size_type min_col_it = numRows > 0 ? numRows - 1 : 0;
171 size_type max_col_it = 0;
173 size_type cntCols = 0;
176 for(size_type c = 0; c < indices.
size(); c++)
178 const local_ordinal_type lColIdx = indices[c];
180 for(size_type j = 0; j < numRows; j++)
182 if (localRows[j] == lColIdx)
184 if(localRows[min_col_it] > lColIdx)
186 if(localRows[max_col_it] < lColIdx)
191 if(cntCols == numRows)
194 ku_[b] = std::max(ku_[b], Teuchos::as<local_ordinal_type>(max_col_it - i));
195 kl_[b] = std::max(kl_[b], Teuchos::as<local_ordinal_type>(i - min_col_it));
199 (kl_[b] == -1 || ku_[b] == -1, std::invalid_argument,
200 "Ifpack2::BandedContainer::setParameters: the user must provide the number" 201 " of sub- and superdiagonals in the 'kl' and 'ku' parameters.");
205 template<
class MatrixType,
class LocalScalarType>
207 BandedContainer<MatrixType, LocalScalarType, true>::
212 for(local_ordinal_type b = 0; b < this->numBlocks_; b++)
215 (kl_[b] == -1 || ku_[b] == -1, std::invalid_argument,
216 "Ifpack2::BandedContainer::initialize: the user must provide the number of" 217 " sub- and superdiagonals in the 'kl' and 'ku' parameters. Make sure that " 218 "you call BandedContainer<T>::setParameters!");
220 global_ordinal_type totalScalars = 0;
221 for(local_ordinal_type b = 0; b < this->numBlocks_; b++)
223 local_ordinal_type stride = 2 * kl_[b] + ku_[b] + 1;
224 scalarOffsets_[b] = totalScalars;
225 totalScalars += stride * this->blockRows_[b];
227 scalars_ =
new local_scalar_type[totalScalars];
228 for(
int b = 0; b < this->numBlocks_; b++)
230 local_ordinal_type nrows = this->blockRows_[b];
231 diagBlocks_.emplace_back(Teuchos::View, scalars_ + scalarOffsets_[b], 2 * kl_[b] + ku_[b] + 1, nrows, nrows, kl_[b], kl_[b] + ku_[b]);
236 IsInitialized_ =
false;
238 std::fill (ipiv_.begin (), ipiv_.end (), 0);
239 IsInitialized_ =
true;
242 template<
class MatrixType,
class LocalScalarType>
244 BandedContainer<MatrixType, LocalScalarType, true>::
248 ipiv_.size () != this->partitions_.size(), std::logic_error,
249 "Ifpack2::BandedContainer::compute: ipiv_ array has the wrong size. " 250 "Please report this bug to the Ifpack2 developers.");
253 if (! this->isInitialized ()) {
264 template<
class MatrixType,
class LocalScalarType>
266 BandedContainer<MatrixType, LocalScalarType, true>::
269 std::vector<HostViewLocal> empty1;
270 std::swap(empty1, X_local);
271 std::vector<HostViewLocal> empty2;
272 std::swap(empty2, Y_local);
273 Container<MatrixType>::clearBlocks ();
276 template<
class MatrixType,
class LocalScalarType>
278 BandedContainer<MatrixType, LocalScalarType, true>::
284 for(
int i = 0; i < this->numBlocks_; i++)
288 "BandedContainer<T>::factor: Diagonal block is an empty SerialBandDenseMatrix<T>!");
290 "BandedContainer<T>::factor: Diagonal block needs kl additional superdiagonals for factorization! However, the number of superdiagonals is smaller than the number of subdiagonals!");
291 int* blockIpiv = &ipiv_[this->partitionIndices_[i]];
292 lapack.
GBTRF (diagBlocks_[i].numRows(),
293 diagBlocks_[i].numCols(),
294 diagBlocks_[i].lowerBandwidth(),
295 diagBlocks_[i].upperBandwidth() - diagBlocks_[i].lowerBandwidth(),
296 diagBlocks_[i].values(),
297 diagBlocks_[i].stride(),
303 INFO < 0, std::logic_error,
"Ifpack2::BandedContainer::factor: " 304 "LAPACK's _GBTRF (LU factorization with partial pivoting) was called " 305 "incorrectly. INFO = " << INFO <<
" < 0. " 306 "Please report this bug to the Ifpack2 developers.");
311 INFO > 0, std::runtime_error,
"Ifpack2::BandedContainer::factor: " 312 "LAPACK's _GBTRF (LU factorization with partial pivoting) reports that the " 313 "computed U factor is exactly singular. U(" << INFO <<
"," << INFO <<
") " 314 "(one-based index i) is exactly zero. This probably means that the input " 315 "matrix has a singular diagonal block.");
319 template<
class MatrixType,
class LocalScalarType>
321 BandedContainer<MatrixType, LocalScalarType, true>::
322 applyImpl (HostViewLocal& X,
327 const local_scalar_type alpha,
328 const local_scalar_type beta)
const 335 using Teuchos::rcpFromRef;
338 X.dimension_0 () != Y.dimension_0 (),
339 std::logic_error,
"Ifpack2::BandedContainer::applyImpl: X and Y have " 340 "incompatible dimensions (" << X.dimension_0 () <<
" resp. " 341 << Y.dimension_0 () <<
"). Please report this bug to " 342 "the Ifpack2 developers.");
344 X.dimension_0 () !=
static_cast<size_t> (mode ==
Teuchos::NO_TRANS ? diagBlocks_[blockIndex].numCols() : diagBlocks_[blockIndex].numRows()),
345 std::logic_error,
"Ifpack2::BandedContainer::applyImpl: The input " 346 "multivector X has incompatible dimensions from those of the " 347 "inverse operator (" << X.dimension_0 () <<
" vs. " 348 << (mode ==
Teuchos::NO_TRANS ? diagBlocks_[blockIndex].numCols() : diagBlocks_[blockIndex].numRows())
349 <<
"). Please report this bug to the Ifpack2 developers.");
351 Y.dimension_0 () !=
static_cast<size_t> (mode ==
Teuchos::NO_TRANS ? diagBlocks_[blockIndex].numRows() : diagBlocks_[blockIndex].numCols()),
352 std::logic_error,
"Ifpack2::BandedContainer::applyImpl: The output " 353 "multivector Y has incompatible dimensions from those of the " 354 "inverse operator (" << Y.dimension_0 () <<
" vs. " 355 << (mode ==
Teuchos::NO_TRANS ? diagBlocks_[blockIndex].numRows() : diagBlocks_[blockIndex].numCols())
356 <<
"). Please report this bug to the Ifpack2 developers.");
358 size_t numVecs = (int) X.dimension_1 ();
366 for(
size_t j = 0; j < Y.dimension_0(); j++)
367 for(
size_t i = 0; i < Y.dimension_1(); i++)
371 for(
size_t j = 0; j < Y.dimension_0(); j++)
372 for(
size_t i = 0; i < Y.dimension_1(); i++)
381 Ptr<HostViewLocal> Y_tmp;
382 bool deleteYT =
false;
388 Y_tmp = ptr (
new HostViewLocal (
"", X.dimension_0 (), X.dimension_1 ()));
390 Kokkos::deep_copy(*Y_tmp, X);
393 local_scalar_type*
const Y_ptr = (local_scalar_type*) Y_tmp->ptr_on_device();
398 const int* blockIpiv = &ipiv_[this->partitionIndices_[blockIndex]];
400 diagBlocks_[blockIndex].numCols(),
401 diagBlocks_[blockIndex].lowerBandwidth(),
403 diagBlocks_[blockIndex].upperBandwidth() - diagBlocks_[blockIndex].lowerBandwidth(),
405 diagBlocks_[blockIndex].values(),
406 diagBlocks_[blockIndex].stride(),
408 Y_ptr, stride, &INFO);
411 INFO != 0, std::runtime_error,
"Ifpack2::BandedContainer::applyImpl: " 412 "LAPACK's _GBTRS (solve using LU factorization with partial pivoting) " 413 "failed with INFO = " << INFO <<
" != 0.");
416 for(
size_t j = 0; j < Y.dimension_1(); j++)
417 for(
size_t i = 0; i < Y.dimension_0(); i++)
418 Y(i, j) = beta * Y(i, j) + alpha * (*Y_tmp)(i, j);
425 template<
class MatrixType,
class LocalScalarType>
427 BandedContainer<MatrixType, LocalScalarType, true>::
434 scalar_type beta)
const 448 Details::MultiVectorLocalGatherScatter<mv_type, local_mv_type> mvgs;
449 const size_t numVecs = X.dimension_1();
452 ! IsComputed_, std::runtime_error,
"Ifpack2::BandedContainer::apply: " 453 "You must have called the compute() method before you may call apply(). " 454 "You may call the apply() method as many times as you want after calling " 455 "compute() once, but you must have called compute() at least once.");
457 X.dimension_1() != Y.dimension_1(), std::runtime_error,
458 "Ifpack2::BandedContainer::apply: X and Y have different numbers of " 459 "vectors. X has " << X.dimension_1()
460 <<
", but Y has " << Y.dimension_1() <<
".");
481 if(X_local.size() == 0)
485 for(
int i = 0; i < this->numBlocks_; i++)
487 X_local.emplace_back(
"", this->blockRows_[i], numVecs);
489 for(
int i = 0; i < this->numBlocks_; i++)
491 Y_local.emplace_back(
"", this->blockRows_[i], numVecs);
495 ArrayView<const local_ordinal_type> localRows = this->getLocalRows(blockIndex);
497 mvgs.gatherViewToView(X_local[blockIndex], X, localRows);
504 mvgs.gatherViewToView (Y_local[blockIndex], Y, localRows);
508 this->applyImpl (X_local[blockIndex], Y_local[blockIndex], blockIndex, stride, mode, as<local_scalar_type>(alpha),
509 as<local_scalar_type>(beta));
513 mvgs.scatterViewToView(Y, Y_local[blockIndex], localRows);
516 template<
class MatrixType,
class LocalScalarType>
518 BandedContainer<MatrixType, LocalScalarType, true>::
519 weightedApply (HostView& X,
526 scalar_type beta)
const 535 using Teuchos::rcp_const_cast;
540 true, std::runtime_error,
"Ifpack2::BandedContainer::" 541 "weightedApply: This code is not tested and not used. Expect bugs.");
554 Details::MultiVectorLocalGatherScatter<mv_type, local_mv_type> mvgs;
555 const size_t numVecs = X.dimension_1();
558 ! IsComputed_, std::runtime_error,
"Ifpack2::BandedContainer::" 559 "weightedApply: You must have called the compute() method before you may " 560 "call apply(). You may call the apply() method as many times as you want " 561 "after calling compute() once, but you must have called compute() at least " 564 numVecs != Y.dimension_1(), std::runtime_error,
565 "Ifpack2::BandedContainer::weightedApply: X and Y have different numbers " 566 "of vectors. X has " << X.dimension_1() <<
", but Y has " 567 << Y.dimension_1() <<
".");
597 const size_t numRows = this->blockRows_[blockIndex];
599 if(X_local.size() == 0)
603 for(
int i = 0; i < this->numBlocks_; i++)
605 X_local.emplace_back(
"", this->blockRows_[i], numVecs);
607 for(
int i = 0; i < this->numBlocks_; i++)
609 Y_local.emplace_back(
"", this->blockRows_[i], numVecs);
613 HostViewLocal D_local(
"", numRows, 1);
614 HostViewLocal X_scaled(
"", numRows, numVecs);
616 ArrayView<const local_ordinal_type> localRows = this->getLocalRows(blockIndex);
617 mvgs.gatherViewToView (X_local[blockIndex], X, localRows);
624 mvgs.gatherViewToView (Y_local[blockIndex], Y, localRows);
636 mvgs.gatherViewToView (D_local, D, localRows);
638 for(
size_t j = 0; j < numVecs; j++)
639 for(
size_t i = 0; i < numRows; i++)
640 X_scaled(i, j) = X_local[blockIndex](i, j) * D_local(i, 0);
647 Ptr<HostViewLocal> Y_temp;
648 bool deleteYT =
false;
650 Y_temp = ptr(&Y_local[blockIndex]);
653 Y_temp = ptr(
new HostViewLocal(
"", numRows, numVecs));
658 applyImpl(X_scaled, *Y_temp, blockIndex, stride, mode, one, one);
665 for(
size_t j = 0; j < numVecs; j++)
666 for(
size_t i = 0; i < numRows; i++)
667 Y_local[blockIndex](i, j) = Y_local[blockIndex](i, j) * (local_impl_scalar_type) beta + (local_impl_scalar_type) alpha * (*Y_temp)(i, j) * D_local(i, 0);
674 mvgs.scatterViewToView (Y, Y_local[blockIndex], localRows);
677 template<
class MatrixType,
class LocalScalarType>
679 BandedContainer<MatrixType, LocalScalarType, true>::
680 print (std::ostream& os)
const 683 fos.setOutputToRootOnly (0);
688 template<
class MatrixType,
class LocalScalarType>
690 BandedContainer<MatrixType, LocalScalarType, true>::
693 std::ostringstream oss;
695 if (isInitialized()) {
697 oss <<
"{status = initialized, computed";
700 oss <<
"{status = initialized, not computed";
704 oss <<
"{status = not initialized, not computed";
710 template<
class MatrixType,
class LocalScalarType>
712 BandedContainer<MatrixType, LocalScalarType, true>::
717 os <<
"================================================================================" << std::endl;
718 os <<
"Ifpack2::BandedContainer" << std::endl;
719 for(
int i = 0; i < this->numBlocks_; i++)
721 os <<
"Block " << i <<
": Number of rows = " << this->blockRows_[i] << std::endl;
722 os <<
"Block " << i <<
": Number of subdiagonals = " << diagBlocks_[i].lowerBandwidth() << std::endl;
723 os <<
"Block " << i <<
": Number of superdiagonals = " << diagBlocks_[i].upperBandwidth() << std::endl;
725 os <<
"isInitialized() = " << IsInitialized_ << std::endl;
726 os <<
"isComputed() = " << IsComputed_ << std::endl;
727 os <<
"================================================================================" << std::endl;
731 template<
class MatrixType,
class LocalScalarType>
733 BandedContainer<MatrixType, LocalScalarType, true>::
739 auto& A = *this->inputMatrix_;
740 const size_t inputMatrixNumRows = A.getNodeNumRows ();
744 const int myRank = A.getRowMap()->getComm()->getRank();
745 const int numProcs = A.getRowMap()->getComm()->getSize();
747 for(
int blockIndex = 0; blockIndex < this->numBlocks_; blockIndex++)
749 const local_ordinal_type numRows_ = this->blockRows_[blockIndex];
752 ArrayView<const local_ordinal_type> localRows = this->getLocalRows(blockIndex);
753 for(local_ordinal_type j = 0; j < numRows_; j++)
757 static_cast<size_t> (localRows[j]) >= inputMatrixNumRows,
758 std::runtime_error,
"Ifpack2::BandedContainer::extract: On process " <<
759 myRank <<
" of " << numProcs <<
", localRows[j=" << j <<
"] = " <<
760 localRows[j] <<
", which is out of the valid range of local row indices " 761 "indices [0, " << (inputMatrixNumRows - 1) <<
"] for the input matrix.");
774 const map_type& globalRowMap = *(A.getRowMap ());
775 const map_type& globalColMap = *(A.getColMap ());
776 const map_type& globalDomMap = *(A.getDomainMap ());
778 bool rowIndsValid =
true;
779 bool colIndsValid =
true;
780 Array<local_ordinal_type> localCols (numRows_);
783 Array<local_ordinal_type> invalidLocalRowInds;
784 Array<global_ordinal_type> invalidGlobalColInds;
785 for(local_ordinal_type i = 0; i < numRows_; i++)
788 const local_ordinal_type ii_local = localRows[i];
793 const global_ordinal_type jj_global = globalRowMap.getGlobalElement(ii_local);
801 rowIndsValid =
false;
802 invalidLocalRowInds.push_back(ii_local);
807 if(globalDomMap.isNodeGlobalElement(jj_global))
817 const local_ordinal_type jj_local = globalColMap.getLocalElement(jj_global);
820 colIndsValid =
false;
821 invalidGlobalColInds.push_back(jj_global);
824 localCols[i] = jj_local;
828 ! rowIndsValid, std::logic_error,
"Ifpack2::BandedContainer::extract: " 829 "On process " << myRank <<
", at least one row index in the set of local " 830 "row indices given to the constructor is not a valid local row index in " 831 "the input matrix's row Map on this process. This should be impossible " 832 "because the constructor checks for this case. Here is the complete set " 833 "of invalid local row indices: " <<
toString(invalidLocalRowInds) <<
". " 834 "Please report this bug to the Ifpack2 developers.");
836 ! colIndsValid, std::runtime_error,
"Ifpack2::BandedContainer::extract: " 837 "On process " << myRank <<
", " 838 "At least one row index in the set of row indices given to the constructor " 839 "does not have a corresponding column index in the input matrix's column " 840 "Map. This probably means that the column(s) in question is/are empty on " 841 "this process, which would make the submatrix to extract structurally " 842 "singular. Here is the compete set of invalid global column indices: " 843 <<
toString(invalidGlobalColInds) <<
".");
845 const size_t maxNumEntriesInRow = A.getNodeMaxNumRowEntries();
846 Array<scalar_type> val(maxNumEntriesInRow);
847 Array<local_ordinal_type> ind(maxNumEntriesInRow);
850 for (local_ordinal_type i = 0; i < numRows_; i++)
852 const local_ordinal_type localRow = this->partitions_[this->partitionIndices_[blockIndex] + i];
854 A.getLocalRowCopy(localRow, ind(), val(), numEntries);
855 for (
size_t k = 0; k < numEntries; ++k)
857 const local_ordinal_type localCol = ind[k];
867 if(localCol >= 0 && static_cast<size_t>(localCol) < inputMatrixNumRows)
871 local_ordinal_type jj = INVALID;
872 for (
size_t kk = 0; kk < (size_t) numRows_; kk++)
874 if(localRows[kk] == localCol)
878 diagBlocks_[blockIndex](i, jj) += val[k];
885 template<
class MatrixType,
class LocalScalarType>
886 std::string BandedContainer<MatrixType, LocalScalarType, true>::getName()
891 template<
class MatrixType,
class LocalScalarType>
892 BandedContainer<MatrixType, LocalScalarType, false>::
897 scalar_type DampingFactor) :
898 Container<MatrixType>(matrix, partitions, importer, OverlapLevel, DampingFactor)
901 (
true, std::logic_error,
"Ifpack2::BandedContainer: Not implemented for " 906 template<
class MatrixType,
class LocalScalarType>
907 BandedContainer<MatrixType, LocalScalarType, false>::
910 Container<MatrixType>(matrix, localRows)
913 (
true, std::logic_error,
"Ifpack2::BandedContainer: Not implemented for " 918 template<
class MatrixType,
class LocalScalarType>
919 BandedContainer<MatrixType, LocalScalarType, false>::
920 ~BandedContainer () {}
922 template<
class MatrixType,
class LocalScalarType>
923 void BandedContainer<MatrixType, LocalScalarType, false>::
926 template<
class MatrixType,
class LocalScalarType>
928 BandedContainer<MatrixType, LocalScalarType, false>::
931 template<
class MatrixType,
class LocalScalarType>
933 BandedContainer<MatrixType, LocalScalarType, false>::
936 template<
class MatrixType,
class LocalScalarType>
938 BandedContainer<MatrixType, LocalScalarType, false>::
941 template<
class MatrixType,
class LocalScalarType>
943 BandedContainer<MatrixType, LocalScalarType, false>::
946 template<
class MatrixType,
class LocalScalarType>
948 BandedContainer<MatrixType, LocalScalarType, false>::
949 applyImpl (HostViewLocal& X,
954 const local_scalar_type alpha,
955 const local_scalar_type beta)
const {}
957 template<
class MatrixType,
class LocalScalarType>
959 BandedContainer<MatrixType, LocalScalarType, false>::
966 scalar_type beta)
const {}
968 template<
class MatrixType,
class LocalScalarType>
970 BandedContainer<MatrixType, LocalScalarType, false>::
971 weightedApply (HostView& X,
978 scalar_type beta)
const {}
980 template<
class MatrixType,
class LocalScalarType>
982 BandedContainer<MatrixType, LocalScalarType, false>::
983 print (std::ostream& os)
const 988 template<
class MatrixType,
class LocalScalarType>
990 BandedContainer<MatrixType, LocalScalarType, false>::
996 template<
class MatrixType,
class LocalScalarType>
998 BandedContainer<MatrixType, LocalScalarType, false>::
1002 template<
class MatrixType,
class LocalScalarType>
1004 BandedContainer<MatrixType, LocalScalarType, false>::
1007 template<
class MatrixType,
class LocalScalarType>
1008 std::string BandedContainer<MatrixType, LocalScalarType, false>::getName()
1015 #define IFPACK2_BANDEDCONTAINER_INSTANT(S,LO,GO,N) \ 1016 template class Ifpack2::BandedContainer< Tpetra::RowMatrix<S, LO, GO, N>, S >; 1018 #endif // IFPACK2_BANDEDCONTAINER_HPP
T & get(const std::string &name, T def_value)
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
virtual std::string description() const
void GBTRS(const char TRANS, const OrdinalType n, const OrdinalType kl, const OrdinalType ku, const OrdinalType nrhs, const ScalarType *A, const OrdinalType lda, const OrdinalType *IPIV, ScalarType *B, const OrdinalType ldb, OrdinalType *info) const
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
LinearOp zero(const VectorSpace &vs)
TEUCHOSCORE_LIB_DLL_EXPORT std::string toString(const EVerbosityLevel verbLevel)
TypeTo as(const TypeFrom &t)
void GBTRF(const OrdinalType m, const OrdinalType n, const OrdinalType kl, const OrdinalType ku, ScalarType *A, const OrdinalType lda, OrdinalType *IPIV, OrdinalType *info) const
bool isParameter(const std::string &name) const
Preconditioners and smoothers for Tpetra sparse matrices.
Definition: Ifpack2_AdditiveSchwarz_decl.hpp:72