Ifpack2_Diagonal_def.hpp

// @HEADER
// *****************************************************************************
//       Ifpack2: Templated Object-Oriented Algebraic Preconditioner Package
//
// Copyright 2009 NTESS and the Ifpack2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef IFPACK2_DIAGONAL_DEF_HPP
#define IFPACK2_DIAGONAL_DEF_HPP
 
#include "Ifpack2_Diagonal_decl.hpp"
#include "Tpetra_CrsMatrix.hpp"
 
namespace Ifpack2 {
 
template <class MatrixType>
Diagonal<MatrixType>::Diagonal(const Teuchos::RCP<const row_matrix_type>& A)
  : matrix_(A)
  , initializeTime_(0.0)
  , computeTime_(0.0)
  , applyTime_(0.0)
  , numInitialize_(0)
  , numCompute_(0)
  , numApply_(0)
  , isInitialized_(false)
  , isComputed_(false) {}
 
template <class MatrixType>
Diagonal<MatrixType>::Diagonal(const Teuchos::RCP<const crs_matrix_type>& A)
  : matrix_(A)
  , initializeTime_(0.0)
  , computeTime_(0.0)
  , applyTime_(0.0)
  , numInitialize_(0)
  , numCompute_(0)
  , numApply_(0)
  , isInitialized_(false)
  , isComputed_(false) {}
 
template <class MatrixType>
Diagonal<MatrixType>::Diagonal(const Teuchos::RCP<const vector_type>& diag)
  : userInverseDiag_(diag)
  , inverseDiag_(diag)
  , initializeTime_(0.0)
  , computeTime_(0.0)
  , applyTime_(0.0)
  , numInitialize_(0)
  , numCompute_(0)
  , numApply_(0)
  , isInitialized_(false)
  , isComputed_(false) {}
 
template <class MatrixType>
Diagonal<MatrixType>::~Diagonal() {}
 
template <class MatrixType>
Teuchos::RCP<const typename Diagonal<MatrixType>::map_type>
Diagonal<MatrixType>::getDomainMap() const {
  if (matrix_.is_null()) {
    if (userInverseDiag_.is_null()) {
      TEUCHOS_TEST_FOR_EXCEPTION(
          true, std::runtime_error,
          "Ifpack2::Diagonal::getDomainMap: "
          "The input matrix A is null, and you did not provide a vector of "
          "inverse diagonal entries.  Please call setMatrix() with a nonnull "
          "input matrix before calling this method.");
    } else {
      return userInverseDiag_->getMap();
    }
  } else {
    return matrix_->getDomainMap();
  }
}
 
template <class MatrixType>
Teuchos::RCP<const typename Diagonal<MatrixType>::map_type>
Diagonal<MatrixType>::getRangeMap() const {
  if (matrix_.is_null()) {
    if (userInverseDiag_.is_null()) {
      TEUCHOS_TEST_FOR_EXCEPTION(
          true, std::runtime_error,
          "Ifpack2::Diagonal::getRangeMap: "
          "The input matrix A is null, and you did not provide a vector of "
          "inverse diagonal entries.  Please call setMatrix() with a nonnull "
          "input matrix before calling this method.");
    } else {
      return userInverseDiag_->getMap();
    }
  } else {
    return matrix_->getRangeMap();
  }
}
 
template <class MatrixType>
void Diagonal<MatrixType>::
    setParameters(const Teuchos::ParameterList& /*params*/) {}
 
template <class MatrixType>
void Diagonal<MatrixType>::reset() {
  inverseDiag_   = Teuchos::null;
  offsets_       = offsets_type();
  isInitialized_ = false;
  isComputed_    = false;
}
 
template <class MatrixType>
void Diagonal<MatrixType>::
    setMatrix(const Teuchos::RCP<const row_matrix_type>& A) {
  if (A.getRawPtr() != matrix_.getRawPtr()) {  // it's a different matrix
    reset();
    matrix_ = A;
  }
}
 
template <class MatrixType>
void Diagonal<MatrixType>::initialize() {
  // Either the matrix to precondition must be nonnull, or the user
  // must have provided a Vector of diagonal entries.
  TEUCHOS_TEST_FOR_EXCEPTION(
      matrix_.is_null() && userInverseDiag_.is_null(), std::runtime_error,
      "Ifpack2::Diagonal::initialize: The matrix to precondition is null, "
      "and you did not provide a Tpetra::Vector of diagonal entries.  "
      "Please call setMatrix() with a nonnull input before calling this method.");
 
  // If the user did provide an input matrix, then that takes
  // precedence over the vector of inverse diagonal entries, if they
  // provided one earlier.  This is only possible if they created this
  // Diagonal instance using the constructor that takes a
  // Tpetra::Vector pointer, and then called setMatrix() with a
  // nonnull input matrix.
  if (!matrix_.is_null()) {
    // If you call initialize(), it means that you are asserting that
    // the structure of the input sparse matrix may have changed.
    // This means we should always recompute the diagonal offsets, if
    // the input matrix is a Tpetra::CrsMatrix.
    Teuchos::RCP<const crs_matrix_type> A_crs =
        Teuchos::rcp_dynamic_cast<const crs_matrix_type>(matrix_);
 
    if (A_crs.is_null()) {
      offsets_ = offsets_type();  // offsets are no longer valid
    } else {
      const size_t lclNumRows = A_crs->getLocalNumRows();
      if (offsets_.extent(0) < lclNumRows) {
        offsets_ = offsets_type();  // clear first to save memory
        offsets_ = offsets_type("offsets", lclNumRows);
      }
      A_crs->getCrsGraph()->getLocalDiagOffsets(offsets_);
    }
  }
 
  isInitialized_ = true;
  ++numInitialize_;
}
 
template <class MatrixType>
void Diagonal<MatrixType>::compute() {
  // Either the matrix to precondition must be nonnull, or the user
  // must have provided a Vector of diagonal entries.
  TEUCHOS_TEST_FOR_EXCEPTION(
      matrix_.is_null() && userInverseDiag_.is_null(), std::runtime_error,
      "Ifpack2::Diagonal::compute: The matrix to precondition is null, "
      "and you did not provide a Tpetra::Vector of diagonal entries.  "
      "Please call setMatrix() with a nonnull input before calling this method.");
 
  if (!isInitialized_) {
    initialize();
  }
 
  // If the user did provide an input matrix, then that takes
  // precedence over the vector of inverse diagonal entries, if they
  // provided one earlier.  This is only possible if they created this
  // Diagonal instance using the constructor that takes a
  // Tpetra::Vector pointer, and then called setMatrix() with a
  // nonnull input matrix.
  if (matrix_.is_null()) {  // accept the user's diagonal
    inverseDiag_ = userInverseDiag_;
  } else {
    Teuchos::RCP<vector_type> tmpVec(new vector_type(matrix_->getRowMap()));
    Teuchos::RCP<const crs_matrix_type> A_crs =
        Teuchos::rcp_dynamic_cast<const crs_matrix_type>(matrix_);
    if (A_crs.is_null()) {
      // Get the diagonal entries from the Tpetra::RowMatrix.
      matrix_->getLocalDiagCopy(*tmpVec);
    } else {
      // Get the diagonal entries from the Tpetra::CrsMatrix using the
      // precomputed offsets.
      A_crs->getLocalDiagCopy(*tmpVec, offsets_);
    }
    tmpVec->reciprocal(*tmpVec);  // invert the diagonal entries
    inverseDiag_ = tmpVec;
  }
 
  isComputed_ = true;
  ++numCompute_;
}
 
template <class MatrixType>
void Diagonal<MatrixType>::
    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*/,
          scalar_type alpha,
          scalar_type beta) const {
  TEUCHOS_TEST_FOR_EXCEPTION(
      !isComputed(), std::runtime_error,
      "Ifpack2::Diagonal::apply: You "
      "must first call compute() before you may call apply().  Once you have "
      "called compute(), you need not call it again unless the values in the "
      "matrix have changed, or unless you have called setMatrix().");
 
  // FIXME (mfh 12 Sep 2014) This assumes that row Map == range Map ==
  // domain Map.  If the preconditioner has a matrix, we should ask
  // the matrix whether we need to do an Import before and/or an
  // Export after.
 
  Y.elementWiseMultiply(alpha, *inverseDiag_, X, beta);
  ++numApply_;
}
 
template <class MatrixType>
int Diagonal<MatrixType>::getNumInitialize() const {
  return numInitialize_;
}
 
template <class MatrixType>
int Diagonal<MatrixType>::getNumCompute() const {
  return numCompute_;
}
 
template <class MatrixType>
int Diagonal<MatrixType>::getNumApply() const {
  return numApply_;
}
 
template <class MatrixType>
double Diagonal<MatrixType>::getInitializeTime() const {
  return initializeTime_;
}
 
template <class MatrixType>
double Diagonal<MatrixType>::getComputeTime() const {
  return computeTime_;
}
 
template <class MatrixType>
double Diagonal<MatrixType>::getApplyTime() const {
  return applyTime_;
}
 
template <class MatrixType>
std::string Diagonal<MatrixType>::description() const {
  std::ostringstream out;
 
  // Output is a valid YAML dictionary in flow style.  If you don't
  // like everything on a single line, you should call describe()
  // instead.
  out << "\"Ifpack2::Diagonal\": "
      << "{";
  if (this->getObjectLabel() != "") {
    out << "Label: \"" << this->getObjectLabel() << "\", ";
  }
  if (matrix_.is_null()) {
    out << "Matrix: null";
  } else {
    out << "Matrix: not null"
        << ", Global matrix dimensions: ["
        << matrix_->getGlobalNumRows() << ", "
        << matrix_->getGlobalNumCols() << "]";
  }
 
  out << "}";
  return out.str();
}
 
template <class MatrixType>
void Diagonal<MatrixType>::
    describe(Teuchos::FancyOStream& out,
             const Teuchos::EVerbosityLevel verbLevel) const {
  using std::endl;
 
  const Teuchos::EVerbosityLevel vl =
      (verbLevel == Teuchos::VERB_DEFAULT) ? Teuchos::VERB_LOW : verbLevel;
  if (vl != Teuchos::VERB_NONE) {
    Teuchos::OSTab tab0(out);
    out << "\"Ifpack2::Diagonal\":";
    Teuchos::OSTab tab1(out);
    out << "Template parameter: "
        << Teuchos::TypeNameTraits<MatrixType>::name() << endl;
    if (this->getObjectLabel() != "") {
      out << "Label: \"" << this->getObjectLabel() << "\", ";
    }
    out << "Number of initialize calls: " << numInitialize_ << endl
        << "Number of compute calls: " << numCompute_ << endl
        << "Number of apply calls: " << numApply_ << endl;
  }
}
 
}  // namespace Ifpack2
 
#define IFPACK2_DIAGONAL_INSTANT(S, LO, GO, N) \
  template class Ifpack2::Diagonal<Tpetra::RowMatrix<S, LO, GO, N> >;
 
#endif