Ifpack2_Details_DenseSolver_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_DETAILS_DENSESOLVER_DEF_HPP
#define IFPACK2_DETAILS_DENSESOLVER_DEF_HPP

#include "Ifpack2_LocalFilter.hpp"
#include "Teuchos_LAPACK.hpp"
#include "Ifpack2_Details_DenseSolver.hpp"
#include "Tpetra_Map.hpp"

#ifdef HAVE_MPI
#include <mpi.h>
#include "Teuchos_DefaultMpiComm.hpp"
#else
#include "Teuchos_DefaultSerialComm.hpp"
#endif  // HAVE_MPI

namespace Ifpack2 {
namespace Details {

// Non-stub (full) implementation

template <class MatrixType>
DenseSolver<MatrixType, false>::
    DenseSolver(const Teuchos::RCP<const row_matrix_type>& A)
  : A_(A)
  , initializeTime_(0.0)
  , computeTime_(0.0)
  , applyTime_(0.0)
  , numInitialize_(0)
  , numCompute_(0)
  , numApply_(0)
  , isInitialized_(false)
  , isComputed_(false) {}

template <class MatrixType>
Teuchos::RCP<const typename DenseSolver<MatrixType, false>::map_type>
DenseSolver<MatrixType, false>::getDomainMap() const {
  TEUCHOS_TEST_FOR_EXCEPTION(
      A_.is_null(), std::runtime_error,
      "Ifpack2::Details::DenseSolver::"
      "getDomainMap: The input matrix A is null.  Please call setMatrix() with a "
      "nonnull input matrix before calling this method.");
  // For an input matrix A, DenseSolver solves Ax=b for x.
  // Thus, its Maps are reversed from those of the input matrix.
  return A_->getRangeMap();
}

template <class MatrixType>
Teuchos::RCP<const typename DenseSolver<MatrixType, false>::map_type>
DenseSolver<MatrixType, false>::getRangeMap() const {
  TEUCHOS_TEST_FOR_EXCEPTION(
      A_.is_null(), std::runtime_error,
      "Ifpack2::Details::DenseSolver::"
      "getRangeMap: The input matrix A is null.  Please call setMatrix() with a "
      "nonnull input matrix before calling this method.");
  // For an input matrix A, DenseSolver solves Ax=b for x.
  // Thus, its Maps are reversed from those of the input matrix.
  return A_->getDomainMap();
}

template <class MatrixType>
void DenseSolver<MatrixType, false>::
    setParameters(const Teuchos::ParameterList& params) {
  (void)params;  // this preconditioner doesn't currently take any parameters
}

template <class MatrixType>
bool DenseSolver<MatrixType, false>::isInitialized() const {
  return isInitialized_;
}

template <class MatrixType>
bool DenseSolver<MatrixType, false>::isComputed() const {
  return isComputed_;
}

template <class MatrixType>
int DenseSolver<MatrixType, false>::getNumInitialize() const {
  return numInitialize_;
}

template <class MatrixType>
int DenseSolver<MatrixType, false>::getNumCompute() const {
  return numCompute_;
}

template <class MatrixType>
int DenseSolver<MatrixType, false>::getNumApply() const {
  return numApply_;
}

template <class MatrixType>
double
DenseSolver<MatrixType, false>::getInitializeTime() const {
  return initializeTime_;
}

template <class MatrixType>
double
DenseSolver<MatrixType, false>::getComputeTime() const {
  return computeTime_;
}

template <class MatrixType>
double
DenseSolver<MatrixType, false>::getApplyTime() const {
  return applyTime_;
}

template <class MatrixType>
Teuchos::RCP<const typename DenseSolver<MatrixType, false>::row_matrix_type>
DenseSolver<MatrixType, false>::getMatrix() const {
  return A_;
}

template <class MatrixType>
void DenseSolver<MatrixType, false>::
    reset() {
  isInitialized_ = false;
  isComputed_    = false;
  A_local_       = Teuchos::null;
  A_local_dense_.reshape(0, 0);
  ipiv_.resize(0);
}

template <class MatrixType>
void DenseSolver<MatrixType, false>::
    setMatrix(const Teuchos::RCP<const row_matrix_type>& A) {
  // It's legitimate to call setMatrix() with a null input.  This has
  // the effect of resetting the preconditioner's internal state.
  if (!A_.is_null()) {
    const global_size_t numRows = A->getRangeMap()->getGlobalNumElements();
    const global_size_t numCols = A->getDomainMap()->getGlobalNumElements();
    TEUCHOS_TEST_FOR_EXCEPTION(
        numRows != numCols, std::invalid_argument,
        "Ifpack2::Details::DenseSolver::"
        "setMatrix: Input matrix must be (globally) square.  "
        "The matrix you provided is "
            << numRows << " by " << numCols << ".");
  }
  // Clear any previously computed objects.
  reset();

  // Now that we've cleared the state, we can keep the matrix.
  A_ = A;
}

template <class MatrixType>
void DenseSolver<MatrixType, false>::initialize() {
  using Teuchos::Comm;
  using Teuchos::null;
  using Teuchos::RCP;
  using Teuchos::rcp;
  using Teuchos::Time;
  using Teuchos::TimeMonitor;
  const std::string timerName("Ifpack2::Details::DenseSolver::initialize");

  RCP<Time> timer = TimeMonitor::lookupCounter(timerName);
  if (timer.is_null()) {
    timer = TimeMonitor::getNewCounter(timerName);
  }

  double startTime = timer->wallTime();

  {  // Begin timing here.
    Teuchos::TimeMonitor timeMon(*timer);

    TEUCHOS_TEST_FOR_EXCEPTION(
        A_.is_null(), std::runtime_error,
        "Ifpack2::Details::DenseSolver::"
        "initialize: The input matrix A is null.  Please call setMatrix() "
        "with a nonnull input before calling this method.");

    TEUCHOS_TEST_FOR_EXCEPTION(
        !A_->hasColMap(), std::invalid_argument,
        "Ifpack2::Details::DenseSolver: "
        "The constructor's input matrix must have a column Map, "
        "so that it has local indices.");

    // Clear any previously computed objects.
    reset();

    // Make the local filter of the input matrix A.
    if (A_->getComm()->getSize() > 1) {
      A_local_ = rcp(new LocalFilter<row_matrix_type>(A_));
    } else {
      A_local_ = A_;
    }

    TEUCHOS_TEST_FOR_EXCEPTION(
        A_local_.is_null(), std::logic_error,
        "Ifpack2::Details::DenseSolver::"
        "initialize: A_local_ is null after it was supposed to have been "
        "initialized.  Please report this bug to the Ifpack2 developers.");

    // Allocate the dense local matrix and the pivot array.
    const size_t numRows = A_local_->getLocalNumRows();
    const size_t numCols = A_local_->getLocalNumCols();
    TEUCHOS_TEST_FOR_EXCEPTION(
        numRows != numCols, std::logic_error,
        "Ifpack2::Details::DenseSolver::"
        "initialize: Local filter matrix is not square.  This should never happen.  "
        "Please report this bug to the Ifpack2 developers.");
    A_local_dense_.reshape(numRows, numCols);
    ipiv_.resize(std::min(numRows, numCols));
    std::fill(ipiv_.begin(), ipiv_.end(), 0);

    isInitialized_ = true;
    ++numInitialize_;
  }

  initializeTime_ += (timer->wallTime() - startTime);
}

template <class MatrixType>
DenseSolver<MatrixType, false>::~DenseSolver() {}

template <class MatrixType>
void DenseSolver<MatrixType, false>::compute() {
  using Teuchos::RCP;
  const std::string timerName("Ifpack2::Details::DenseSolver::compute");

  RCP<Teuchos::Time> timer = Teuchos::TimeMonitor::lookupCounter(timerName);
  if (timer.is_null()) {
    timer = Teuchos::TimeMonitor::getNewCounter(timerName);
  }

  double startTime = timer->wallTime();

  // Begin timing here.
  {
    Teuchos::TimeMonitor timeMon(*timer);
    TEUCHOS_TEST_FOR_EXCEPTION(
        A_.is_null(), std::runtime_error,
        "Ifpack2::Details::DenseSolver::"
        "compute: The input matrix A is null.  Please call setMatrix() with a "
        "nonnull input, then call initialize(), before calling this method.");

    TEUCHOS_TEST_FOR_EXCEPTION(
        A_local_.is_null(), std::logic_error,
        "Ifpack2::Details::DenseSolver::"
        "compute: A_local_ is null.  Please report this bug to the Ifpack2 "
        "developers.");

    isComputed_ = false;
    if (!this->isInitialized()) {
      this->initialize();
    }
    extract(A_local_dense_, *A_local_);  // extract the dense local matrix
    factor(A_local_dense_, ipiv_());     // factor the dense local matrix

    isComputed_ = true;
    ++numCompute_;
  }
  computeTime_ += (timer->wallTime() - startTime);
}

template <class MatrixType>
void DenseSolver<MatrixType, false>::
    factor(Teuchos::SerialDenseMatrix<int, scalar_type>& A,
           const Teuchos::ArrayView<int>& ipiv) {
  // Fill the LU permutation array with zeros.
  std::fill(ipiv.begin(), ipiv.end(), 0);

  Teuchos::LAPACK<int, scalar_type> lapack;
  int INFO = 0;
  lapack.GETRF(A.numRows(), A.numCols(), A.values(), A.stride(),
               ipiv.getRawPtr(), &INFO);
  // INFO < 0 is a bug.
  TEUCHOS_TEST_FOR_EXCEPTION(
      INFO < 0, std::logic_error,
      "Ifpack2::Details::DenseSolver::factor: "
      "LAPACK's _GETRF (LU factorization with partial pivoting) was called "
      "incorrectly.  INFO = "
          << INFO << " < 0.  "
                     "Please report this bug to the Ifpack2 developers.");
  // INFO > 0 means the matrix is singular.  This is probably an issue
  // either with the choice of rows the rows we extracted, or with the
  // input matrix itself.
  TEUCHOS_TEST_FOR_EXCEPTION(
      INFO > 0, std::runtime_error,
      "Ifpack2::Details::DenseSolver::factor: "
      "LAPACK's _GETRF (LU factorization with partial pivoting) reports that the "
      "computed U factor is exactly singular.  U("
          << INFO << "," << INFO << ") "
                                    "(one-based index i) is exactly zero.  This probably means that the input "
                                    "matrix has a singular diagonal block.");
}

template <class MatrixType>
void DenseSolver<MatrixType, false>::
    applyImpl(const MV& X,
              MV& Y,
              const Teuchos::ETransp mode,
              const scalar_type alpha,
              const scalar_type beta) const {
  using Teuchos::ArrayRCP;
  using Teuchos::CONJ_TRANS;
  using Teuchos::RCP;
  using Teuchos::rcp;
  using Teuchos::rcpFromRef;
  using Teuchos::TRANS;

  const int numVecs = static_cast<int>(X.getNumVectors());
  if (alpha == STS::zero()) {  // don't need to solve the linear system
    if (beta == STS::zero()) {
      // Use BLAS AXPY semantics for beta == 0: overwrite, clobbering
      // any Inf or NaN values in Y (rather than multiplying them by
      // zero, resulting in NaN values).
      Y.putScalar(STS::zero());
    } else {  // beta != 0
      Y.scale(STS::zero());
    }
  } else {  // alpha != 0; must solve the linear system
    Teuchos::LAPACK<int, scalar_type> lapack;
    // If beta is nonzero, Y is not constant stride, or alpha != 1, we
    // have to use a temporary output multivector Y_tmp.  It gets a
    // copy of alpha*X, since GETRS overwrites its (multi)vector input
    // with its output.
    RCP<MV> Y_tmp;
    if (beta == STS::zero() && Y.isConstantStride() && alpha == STS::one()) {
      deep_copy(Y, X);
      Y_tmp = rcpFromRef(Y);
    } else {
      Y_tmp = rcp(new MV(X, Teuchos::Copy));  // constructor copies X
      if (alpha != STS::one()) {
        Y_tmp->scale(alpha);
      }
    }
    const int Y_stride           = static_cast<int>(Y_tmp->getStride());
    ArrayRCP<scalar_type> Y_view = Y_tmp->get1dViewNonConst();
    scalar_type* const Y_ptr     = Y_view.getRawPtr();
    int INFO                     = 0;
    const char trans =
        (mode == CONJ_TRANS ? 'C' : (mode == TRANS ? 'T' : 'N'));
    lapack.GETRS(trans, A_local_dense_.numRows(), numVecs,
                 A_local_dense_.values(), A_local_dense_.stride(),
                 ipiv_.getRawPtr(), Y_ptr, Y_stride, &INFO);
    TEUCHOS_TEST_FOR_EXCEPTION(
        INFO != 0, std::runtime_error,
        "Ifpack2::Details::DenseSolver::"
        "applyImpl: LAPACK's _GETRS (solve using LU factorization with "
        "partial pivoting) failed with INFO = "
            << INFO << " != 0.");

    if (beta != STS::zero()) {
      Y.update(alpha, *Y_tmp, beta);
    } else if (!Y.isConstantStride()) {
      deep_copy(Y, *Y_tmp);
    }
  }
}

template <class MatrixType>
void DenseSolver<MatrixType, false>::
    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 {
  using Teuchos::ArrayView;
  using Teuchos::as;
  using Teuchos::RCP;
  using Teuchos::rcp;
  using Teuchos::rcpFromRef;

  const std::string timerName("Ifpack2::Details::DenseSolver::apply");
  RCP<Teuchos::Time> timer = Teuchos::TimeMonitor::lookupCounter(timerName);
  if (timer.is_null()) {
    timer = Teuchos::TimeMonitor::getNewCounter(timerName);
  }

  double startTime = timer->wallTime();

  // Begin timing here.
  {
    Teuchos::TimeMonitor timeMon(*timer);

    TEUCHOS_TEST_FOR_EXCEPTION(
        !isComputed_, std::runtime_error,
        "Ifpack2::Details::DenseSolver::apply: "
        "You must have called the compute() method before you may call apply().  "
        "You may call the apply() method as many times as you want after calling "
        "compute() once, but you must have called compute() at least once.");

    const size_t numVecs = X.getNumVectors();

    TEUCHOS_TEST_FOR_EXCEPTION(
        numVecs != Y.getNumVectors(), std::runtime_error,
        "Ifpack2::Details::DenseSolver::apply: X and Y have different numbers "
        "of vectors.  X has "
            << X.getNumVectors() << ", but Y has "
            << X.getNumVectors() << ".");

    if (numVecs == 0) {
      return;  // done! nothing to do
    }

    // Set up "local" views of X and Y.
    RCP<const MV> X_local;
    RCP<MV> Y_local;
    const bool multipleProcs = (A_->getRowMap()->getComm()->getSize() >= 1);
    if (multipleProcs) {
      // Interpret X and Y as "local" multivectors, that is, in the
      // local filter's domain resp. range Maps.  "Interpret" means that
      // we create views with different Maps; we don't have to copy.
      X_local = X.offsetView(A_local_->getDomainMap(), 0);
      Y_local = Y.offsetViewNonConst(A_local_->getRangeMap(), 0);
    } else {  // only one process in A_'s communicator
      // X and Y are already "local"; no need to set up local views.
      X_local = rcpFromRef(X);
      Y_local = rcpFromRef(Y);
    }

    // Apply the local operator:
    // Y_local := beta*Y_local + alpha*M^{-1}*X_local
    this->applyImpl(*X_local, *Y_local, mode, alpha, beta);

    ++numApply_;  // We've successfully finished the work of apply().
  }

  applyTime_ += (timer->wallTime() - startTime);
}

template <class MatrixType>
std::string
DenseSolver<MatrixType, false>::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::Details::DenseSolver\": ";
  out << "{";
  if (this->getObjectLabel() != "") {
    out << "Label: \"" << this->getObjectLabel() << "\", ";
  }
  out << "Initialized: " << (isInitialized() ? "true" : "false") << ", "
      << "Computed: " << (isComputed() ? "true" : "false") << ", ";

  if (A_.is_null()) {
    out << "Matrix: null";
  } else {
    out << "Matrix: not null"
        << ", Global matrix dimensions: ["
        << A_->getGlobalNumRows() << ", " << A_->getGlobalNumCols() << "]";
  }

  out << "}";
  return out.str();
}

template <class MatrixType>
void DenseSolver<MatrixType, false>::
    describeLocal(Teuchos::FancyOStream& out,
                  const Teuchos::EVerbosityLevel verbLevel) const {
  using std::endl;
  using Teuchos::FancyOStream;
  using Teuchos::OSTab;
  using Teuchos::RCP;
  using Teuchos::rcpFromRef;

  if (verbLevel == Teuchos::VERB_NONE) {
    return;
  } else {
    RCP<FancyOStream> ptrOut = rcpFromRef(out);
    OSTab tab1(ptrOut);
    if (this->getObjectLabel() != "") {
      out << "label: " << this->getObjectLabel() << endl;
    }
    out << "initialized: " << (isInitialized_ ? "true" : "false") << endl
        << "computed: " << (isComputed_ ? "true" : "false") << endl
        << "number of initialize calls: " << numInitialize_ << endl
        << "number of compute calls: " << numCompute_ << endl
        << "number of apply calls: " << numApply_ << endl
        << "total time in seconds in initialize: " << initializeTime_ << endl
        << "total time in seconds in compute: " << computeTime_ << endl
        << "total time in seconds in apply: " << applyTime_ << endl;
    if (verbLevel >= Teuchos::VERB_EXTREME) {
      out << "A_local_dense_:" << endl;
      {
        OSTab tab2(ptrOut);
        out << "[";
        for (int i = 0; i < A_local_dense_.numRows(); ++i) {
          for (int j = 0; j < A_local_dense_.numCols(); ++j) {
            out << A_local_dense_(i, j);
            if (j + 1 < A_local_dense_.numCols()) {
              out << ", ";
            }
          }
          if (i + 1 < A_local_dense_.numRows()) {
            out << ";" << endl;
          }
        }
        out << "]" << endl;
      }
      out << "ipiv_: " << Teuchos::toString(ipiv_) << endl;
    }
  }
}

template <class MatrixType>
void DenseSolver<MatrixType, false>::
    describe(Teuchos::FancyOStream& out,
             const Teuchos::EVerbosityLevel verbLevel) const {
  using std::endl;
  using Teuchos::FancyOStream;
  using Teuchos::OSTab;
  using Teuchos::RCP;
  using Teuchos::rcpFromRef;

  RCP<FancyOStream> ptrOut = rcpFromRef(out);
  OSTab tab0(ptrOut);
  if (A_.is_null()) {
    // If A_ is null, we don't have a communicator, so we can't
    // safely print local data on all processes.  Just print the
    // local data without arbitration between processes, and hope
    // for the best.
    if (verbLevel > Teuchos::VERB_NONE) {
      out << "Ifpack2::Details::DenseSolver:" << endl;
    }
    describeLocal(out, verbLevel);
  } else {
    // If A_ is not null, we have a communicator, so we can
    // arbitrate among all processes to print local data.
    const Teuchos::Comm<int>& comm = *(A_->getRowMap()->getComm());
    const int myRank               = comm.getRank();
    const int numProcs             = comm.getSize();
    if (verbLevel > Teuchos::VERB_NONE && myRank == 0) {
      out << "Ifpack2::Details::DenseSolver:" << endl;
    }
    OSTab tab1(ptrOut);
    for (int p = 0; p < numProcs; ++p) {
      if (myRank == p) {
        out << "Process " << myRank << ":" << endl;
        describeLocal(out, verbLevel);
      }
      comm.barrier();
      comm.barrier();
      comm.barrier();
    }  // for p = 0 .. numProcs-1
  }
}

template <class MatrixType>
void DenseSolver<MatrixType, false>::
    extract(Teuchos::SerialDenseMatrix<int, scalar_type>& A_local_dense,
            const row_matrix_type& A_local) {
  using Teuchos::Array;
  using Teuchos::ArrayView;
  typedef local_ordinal_type LO;
  typedef typename Teuchos::ArrayView<LO>::size_type size_type;

  // Fill the local dense matrix with zeros.
  A_local_dense.putScalar(STS::zero());

  //
  // Map both row and column indices to local indices.  We can use the
  // row Map's local indices for row indices, and the column Map's
  // local indices for column indices.  It doesn't really matter;
  // either way is just a permutation of rows and columns.
  //
  const map_type& rowMap = *(A_local.getRowMap());

  // Temporary arrays to hold the indices and values of the entries in
  // each row of A_local.
  const size_type maxNumRowEntries =
      static_cast<size_type>(A_local.getLocalMaxNumRowEntries());
  nonconst_local_inds_host_view_type localIndices("localIndices", maxNumRowEntries);
  nonconst_values_host_view_type values("values", maxNumRowEntries);

  const LO numLocalRows = static_cast<LO>(rowMap.getLocalNumElements());
  const LO minLocalRow  = rowMap.getMinLocalIndex();
  // This slight complication of computing the upper loop bound avoids
  // issues if the row Map has zero entries on the calling process.
  const LO maxLocalRow = minLocalRow + numLocalRows;  // exclusive bound
  for (LO localRow = minLocalRow; localRow < maxLocalRow; ++localRow) {
    // The LocalFilter automatically excludes "off-process" entries.
    // That means all the column indices in this row belong to the
    // domain Map.  We can, therefore, just use the local row and
    // column indices to put each entry directly in the dense matrix.
    // It's OK if the column Map puts the local indices in a different
    // order; the Import will bring them into the correct order.
    const size_type numEntriesInRow =
        static_cast<size_type>(A_local.getNumEntriesInLocalRow(localRow));
    size_t numEntriesOut = 0;  // ignored
    A_local.getLocalRowCopy(localRow,
                            localIndices,
                            values,
                            numEntriesOut);
    for (LO k = 0; k < numEntriesInRow; ++k) {
      const LO localCol     = localIndices[k];
      const scalar_type val = values[k];
      // We use += instead of =, in case there are duplicate entries
      // in the row.  There should not be, but why not be general?
      A_local_dense(localRow, localCol) += val;
    }
  }
}

// Stub implementation

template <class MatrixType>
DenseSolver<MatrixType, true>::
    DenseSolver(const Teuchos::RCP<const row_matrix_type>& A) {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
Teuchos::RCP<const typename DenseSolver<MatrixType, true>::map_type>
DenseSolver<MatrixType, true>::getDomainMap() const {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
Teuchos::RCP<const typename DenseSolver<MatrixType, true>::map_type>
DenseSolver<MatrixType, true>::getRangeMap() const {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
void DenseSolver<MatrixType, true>::
    setParameters(const Teuchos::ParameterList& params) {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
bool DenseSolver<MatrixType, true>::isInitialized() const {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
bool DenseSolver<MatrixType, true>::isComputed() const {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
int DenseSolver<MatrixType, true>::getNumInitialize() const {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
int DenseSolver<MatrixType, true>::getNumCompute() const {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
int DenseSolver<MatrixType, true>::getNumApply() const {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
double
DenseSolver<MatrixType, true>::getInitializeTime() const {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
double
DenseSolver<MatrixType, true>::getComputeTime() const {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
double
DenseSolver<MatrixType, true>::getApplyTime() const {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
Teuchos::RCP<const typename DenseSolver<MatrixType, true>::row_matrix_type>
DenseSolver<MatrixType, true>::getMatrix() const {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
void DenseSolver<MatrixType, true>::
    setMatrix(const Teuchos::RCP<const row_matrix_type>& A) {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
void DenseSolver<MatrixType, true>::initialize() {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
DenseSolver<MatrixType, true>::~DenseSolver() {
  // Destructors should never throw exceptions.
}

template <class MatrixType>
void DenseSolver<MatrixType, true>::compute() {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
void DenseSolver<MatrixType, true>::
    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(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
std::string
DenseSolver<MatrixType, true>::description() const {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

template <class MatrixType>
void DenseSolver<MatrixType, true>::
    describe(Teuchos::FancyOStream& out,
             const Teuchos::EVerbosityLevel verbLevel) const {
  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Not implemented");
}

}  // namespace Details
}  // namespace Ifpack2

#define IFPACK2_DETAILS_DENSESOLVER_INSTANT(S, LO, GO, N) \
  template class Ifpack2::Details::DenseSolver<Tpetra::RowMatrix<S, LO, GO, N> >;

#endif  // IFPACK2_DETAILS_DENSESOLVER_HPP