Xpetra_TpetraMultiVector_def.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//             Xpetra: A linear algebra interface package
//
// Copyright 2012 NTESS and the Xpetra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#ifndef XPETRA_TPETRAMULTIVECTOR_DEF_HPP
#define XPETRA_TPETRAMULTIVECTOR_DEF_HPP
#include "Xpetra_TpetraConfigDefs.hpp"

#include "Xpetra_TpetraMap.hpp"  //TMP
#include "Xpetra_Utils.hpp"
#include "Xpetra_TpetraImport.hpp"
#include "Xpetra_TpetraExport.hpp"

#include "Xpetra_TpetraMultiVector_decl.hpp"
#include "Tpetra_MultiVector.hpp"
#include "Tpetra_Vector.hpp"
#include "Tpetra_Details_Random.hpp"

namespace Xpetra {

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::TpetraMultiVector(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map, size_t NumVectors, bool zeroOut)
  : vec_(Teuchos::rcp(new Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(toTpetra(map), NumVectors, zeroOut))) {
  // TAW 1/30/2016: even though Tpetra allows numVecs == 0, Epetra does not. Introduce exception to keep behavior of Epetra and Tpetra consistent.
  TEUCHOS_TEST_FOR_EXCEPTION(NumVectors < 1, std::invalid_argument, "Xpetra::TpetraMultiVector(map,numVecs,zeroOut): numVecs = " << NumVectors << " < 1.");
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    TpetraMultiVector(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Teuchos::DataAccess copyOrView)
  : vec_(Teuchos::rcp(new Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(toTpetra(source), copyOrView))) {}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    TpetraMultiVector(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map, const Teuchos::ArrayView<const Scalar> &A, size_t LDA, size_t NumVectors)
  : vec_(Teuchos::rcp(new Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(toTpetra(map), A, LDA, NumVectors))) {
  // TAW 1/30/2016: even though Tpetra allows numVecs == 0, Epetra does not. Introduce exception to keep behavior of Epetra and Tpetra consistent.
  TEUCHOS_TEST_FOR_EXCEPTION(NumVectors < 1, std::invalid_argument, "Xpetra::TpetraMultiVector(map,A,LDA,numVecs): numVecs = " << NumVectors << " < 1.");
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    TpetraMultiVector(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map, const Teuchos::ArrayView<const Teuchos::ArrayView<const Scalar> > &ArrayOfPtrs, size_t NumVectors)
  : vec_(Teuchos::rcp(new Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(toTpetra(map), ArrayOfPtrs, NumVectors))) {
  // TAW 1/30/2016: even though Tpetra allows numVecs == 0, Epetra does not. Introduce exception to keep behavior of Epetra and Tpetra consistent.
  TEUCHOS_TEST_FOR_EXCEPTION(NumVectors < 1, std::invalid_argument, "Xpetra::TpetraMultiVector(map,ArrayOfPtrs,numVecs): numVecs = " << NumVectors << " < 1.");
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    ~TpetraMultiVector() {}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    replaceGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar &value) {
  XPETRA_MONITOR("TpetraMultiVector::replaceGlobalValue");
  vec_->replaceGlobalValue(globalRow, vectorIndex, value);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    sumIntoGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar &value) {
  XPETRA_MONITOR("TpetraMultiVector::sumIntoGlobalValue");
  vec_->sumIntoGlobalValue(globalRow, vectorIndex, value);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    replaceLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar &value) {
  XPETRA_MONITOR("TpetraMultiVector::replaceLocalValue");
  vec_->replaceLocalValue(myRow, vectorIndex, value);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    sumIntoLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar &value) {
  XPETRA_MONITOR("TpetraMultiVector::sumIntoLocalValue");
  vec_->sumIntoLocalValue(myRow, vectorIndex, value);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    putScalar(const Scalar &value) {
  XPETRA_MONITOR("TpetraMultiVector::putScalar");
  vec_->putScalar(value);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    reduce() {
  XPETRA_MONITOR("TpetraMultiVector::reduce");
  vec_->reduce();
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::RCP<const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> >
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getVector(size_t j) const {
  XPETRA_MONITOR("TpetraMultiVector::getVector");
  return toXpetra(vec_->getVector(j));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::RCP<Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> >
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getVectorNonConst(size_t j) {
  XPETRA_MONITOR("TpetraMultiVector::getVectorNonConst");
  return toXpetra(vec_->getVectorNonConst(j));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::ArrayRCP<const Scalar>
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getData(size_t j) const {
  XPETRA_MONITOR("TpetraMultiVector::getData");
  return vec_->getData(j);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::ArrayRCP<Scalar>
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getDataNonConst(size_t j) {
  XPETRA_MONITOR("TpetraMultiVector::getDataNonConst");
  return vec_->getDataNonConst(j);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    get1dCopy(Teuchos::ArrayView<Scalar> A, size_t LDA) const {
  XPETRA_MONITOR("TpetraMultiVector::get1dCopy");
  vec_->get1dCopy(A, LDA);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    get2dCopy(Teuchos::ArrayView<const Teuchos::ArrayView<Scalar> > ArrayOfPtrs) const {
  XPETRA_MONITOR("TpetraMultiVector::get2dCopy");
  vec_->get2dCopy(ArrayOfPtrs);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::ArrayRCP<const Scalar>
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    get1dView() const {
  XPETRA_MONITOR("TpetraMultiVector::get1dView");
  return vec_->get1dView();
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::ArrayRCP<Teuchos::ArrayRCP<const Scalar> >
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    get2dView() const {
  XPETRA_MONITOR("TpetraMultiVector::get2dView");
  return vec_->get2dView();
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::ArrayRCP<Scalar>
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    get1dViewNonConst() {
  XPETRA_MONITOR("TpetraMultiVector::get1dViewNonConst");
  return vec_->get1dViewNonConst();
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::ArrayRCP<Teuchos::ArrayRCP<Scalar> >
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    get2dViewNonConst() {
  XPETRA_MONITOR("TpetraMultiVector::get2dViewNonConst");
  return vec_->get2dViewNonConst();
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    dot(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const Teuchos::ArrayView<Scalar> &dots) const {
  XPETRA_MONITOR("TpetraMultiVector::dot");
  vec_->dot(toTpetra(A), dots);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    abs(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A) {
  XPETRA_MONITOR("TpetraMultiVector::abs");
  vec_->abs(toTpetra(A));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    reciprocal(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A) {
  XPETRA_MONITOR("TpetraMultiVector::reciprocal");
  vec_->reciprocal(toTpetra(A));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    scale(const Scalar &alpha) {
  XPETRA_MONITOR("TpetraMultiVector::scale");
  vec_->scale(alpha);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    scale(Teuchos::ArrayView<const Scalar> alpha) {
  XPETRA_MONITOR("TpetraMultiVector::scale");
  vec_->scale(alpha);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    scale(const Scalar &alpha, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A) {
  XPETRA_MONITOR("TpetraMultiVector::scale");
  vec_->scale(alpha, toTpetra(A));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    update(const Scalar &alpha, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const Scalar &beta) {
  XPETRA_MONITOR("TpetraMultiVector::update");
  vec_->update(alpha, toTpetra(A), beta);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    update(const Scalar &alpha, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const Scalar &beta, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &B, const Scalar &gamma) {
  XPETRA_MONITOR("TpetraMultiVector::update");
  vec_->update(alpha, toTpetra(A), beta, toTpetra(B), gamma);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    norm1(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> &norms) const {
  XPETRA_MONITOR("TpetraMultiVector::norm1");
  vec_->norm1(norms);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    norm2(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> &norms) const {
  XPETRA_MONITOR("TpetraMultiVector::norm2");
  vec_->norm2(norms);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    normInf(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> &norms) const {
  XPETRA_MONITOR("TpetraMultiVector::normInf");
  vec_->normInf(norms);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    meanValue(const Teuchos::ArrayView<Scalar> &means) const {
  XPETRA_MONITOR("TpetraMultiVector::meanValue");
  vec_->meanValue(means);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    multiply(Teuchos::ETransp transA, Teuchos::ETransp transB, const Scalar &alpha, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &B, const Scalar &beta) {
  XPETRA_MONITOR("TpetraMultiVector::multiply");
  vec_->multiply(transA, transB, alpha, toTpetra(A), toTpetra(B), beta);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
size_t TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getNumVectors() const {
  XPETRA_MONITOR("TpetraMultiVector::getNumVectors");
  return vec_->getNumVectors();
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
size_t TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getLocalLength() const {
  XPETRA_MONITOR("TpetraMultiVector::getLocalLength");
  return vec_->getLocalLength();
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
global_size_t TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getGlobalLength() const {
  XPETRA_MONITOR("TpetraMultiVector::getGlobalLength");
  return vec_->getGlobalLength();
}

// \brief Checks to see if the local length, number of vectors and size of Scalar type match
template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
bool TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    isSameSize(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &vec) const {
  XPETRA_MONITOR("TpetraMultiVector::isSameSize");
  return vec_->isSameSize(toTpetra(vec));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
std::string TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    description() const {
  XPETRA_MONITOR("TpetraMultiVector::description");
  return vec_->description();
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const {
  XPETRA_MONITOR("TpetraMultiVector::describe");
  vec_->describe(out, verbLevel);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    randomize(bool bUseXpetraImplementation) {
  XPETRA_MONITOR("TpetraMultiVector::randomize");

  if (bUseXpetraImplementation)
    MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Xpetra_randomize();
  else
    vec_->randomize();
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    randomize(const Scalar &minVal, const Scalar &maxVal, bool bUseXpetraImplementation) {
  XPETRA_MONITOR("TpetraMultiVector::randomize");

  if (bUseXpetraImplementation)
    MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Xpetra_randomize(minVal, maxVal);
  else
    vec_->randomize(minVal, maxVal);
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> >
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getMap() const {
  XPETRA_MONITOR("TpetraMultiVector::getMap");
  return toXpetra(vec_->getMap());
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    doImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {
  XPETRA_MONITOR("TpetraMultiVector::doImport");

  XPETRA_DYNAMIC_CAST(const TpetraMultiVectorClass, source, tSource, "Xpetra::TpetraMultiVector::doImport only accept Xpetra::TpetraMultiVector as input arguments.");  // TODO: remove and use toTpetra()
  RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v = tSource.getTpetra_MultiVector();
  this->getTpetra_MultiVector()->doImport(*v, toTpetra(importer), toTpetra(CM));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    beginImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {
  XPETRA_MONITOR("TpetraMultiVector::beginImport");

  XPETRA_DYNAMIC_CAST(const TpetraMultiVectorClass, source, tSource, "Xpetra::TpetraMultiVector::doImport only accept Xpetra::TpetraMultiVector as input arguments.");  // TODO: remove and use toTpetra()
  RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v = tSource.getTpetra_MultiVector();
  this->getTpetra_MultiVector()->beginImport(*v, toTpetra(importer), toTpetra(CM));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    endImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {
  XPETRA_MONITOR("TpetraMultiVector::endImport");

  XPETRA_DYNAMIC_CAST(const TpetraMultiVectorClass, source, tSource, "Xpetra::TpetraMultiVector::doImport only accept Xpetra::TpetraMultiVector as input arguments.");  // TODO: remove and use toTpetra()
  RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v = tSource.getTpetra_MultiVector();
  this->getTpetra_MultiVector()->endImport(*v, toTpetra(importer), toTpetra(CM));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    doExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {
  XPETRA_MONITOR("TpetraMultiVector::doExport");

  XPETRA_DYNAMIC_CAST(const TpetraMultiVectorClass, dest, tDest, "Xpetra::TpetraMultiVector::doImport only accept Xpetra::TpetraMultiVector as input arguments.");  // TODO: remove and use toTpetra()
  RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v = tDest.getTpetra_MultiVector();
  this->getTpetra_MultiVector()->doExport(*v, toTpetra(importer), toTpetra(CM));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    beginExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {
  XPETRA_MONITOR("TpetraMultiVector::beginExport");

  XPETRA_DYNAMIC_CAST(const TpetraMultiVectorClass, dest, tDest, "Xpetra::TpetraMultiVector::doImport only accept Xpetra::TpetraMultiVector as input arguments.");  // TODO: remove and use toTpetra()
  RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v = tDest.getTpetra_MultiVector();
  this->getTpetra_MultiVector()->beginExport(*v, toTpetra(importer), toTpetra(CM));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    endExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {
  XPETRA_MONITOR("TpetraMultiVector::endExport");

  XPETRA_DYNAMIC_CAST(const TpetraMultiVectorClass, dest, tDest, "Xpetra::TpetraMultiVector::doImport only accept Xpetra::TpetraMultiVector as input arguments.");  // TODO: remove and use toTpetra()
  RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v = tDest.getTpetra_MultiVector();
  this->getTpetra_MultiVector()->endExport(*v, toTpetra(importer), toTpetra(CM));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    doImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {
  XPETRA_MONITOR("TpetraMultiVector::doImport");

  XPETRA_DYNAMIC_CAST(const TpetraMultiVectorClass, source, tSource, "Xpetra::TpetraMultiVector::doImport only accept Xpetra::TpetraMultiVector as input arguments.");  // TODO: remove and use toTpetra()
  RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v = tSource.getTpetra_MultiVector();
  this->getTpetra_MultiVector()->doImport(*v, toTpetra(exporter), toTpetra(CM));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    beginImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {
  XPETRA_MONITOR("TpetraMultiVector::beginImport");

  XPETRA_DYNAMIC_CAST(const TpetraMultiVectorClass, source, tSource, "Xpetra::TpetraMultiVector::doImport only accept Xpetra::TpetraMultiVector as input arguments.");  // TODO: remove and use toTpetra()
  RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v = tSource.getTpetra_MultiVector();
  this->getTpetra_MultiVector()->beginImport(*v, toTpetra(exporter), toTpetra(CM));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    endImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {
  XPETRA_MONITOR("TpetraMultiVector::endImport");

  XPETRA_DYNAMIC_CAST(const TpetraMultiVectorClass, source, tSource, "Xpetra::TpetraMultiVector::doImport only accept Xpetra::TpetraMultiVector as input arguments.");  // TODO: remove and use toTpetra()
  RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v = tSource.getTpetra_MultiVector();
  this->getTpetra_MultiVector()->endImport(*v, toTpetra(exporter), toTpetra(CM));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    doExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {
  XPETRA_MONITOR("TpetraMultiVector::doExport");

  XPETRA_DYNAMIC_CAST(const TpetraMultiVectorClass, dest, tDest, "Xpetra::TpetraMultiVector::doImport only accept Xpetra::TpetraMultiVector as input arguments.");  // TODO: remove and use toTpetra()
  RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v = tDest.getTpetra_MultiVector();
  this->getTpetra_MultiVector()->doExport(*v, toTpetra(exporter), toTpetra(CM));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    beginExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {
  XPETRA_MONITOR("TpetraMultiVector::beginExport");

  XPETRA_DYNAMIC_CAST(const TpetraMultiVectorClass, dest, tDest, "Xpetra::TpetraMultiVector::doImport only accept Xpetra::TpetraMultiVector as input arguments.");  // TODO: remove and use toTpetra()
  RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v = tDest.getTpetra_MultiVector();
  this->getTpetra_MultiVector()->beginExport(*v, toTpetra(exporter), toTpetra(CM));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    endExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {
  XPETRA_MONITOR("TpetraMultiVector::endExport");

  XPETRA_DYNAMIC_CAST(const TpetraMultiVectorClass, dest, tDest, "Xpetra::TpetraMultiVector::doImport only accept Xpetra::TpetraMultiVector as input arguments.");  // TODO: remove and use toTpetra()
  RCP<const Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > v = tDest.getTpetra_MultiVector();
  this->getTpetra_MultiVector()->endExport(*v, toTpetra(exporter), toTpetra(CM));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    replaceMap(const RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map) {
  XPETRA_MONITOR("TpetraMultiVector::replaceMap");
  this->getTpetra_MultiVector()->replaceMap(toTpetra(map));
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    TpetraMultiVector(const Teuchos::RCP<Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > &vec)
  : vec_(vec) {}  // TODO removed const

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
RCP<Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> >
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getTpetra_MultiVector() const { return vec_; }

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    setSeed(unsigned int seed) {
  XPETRA_MONITOR("TpetraMultiVector::seedrandom");
  Teuchos::ScalarTraits<Scalar>::seedrandom(seed);
  // Tell Tpetra to update its RNG pool for the new random seed
  Tpetra::Details::Static_Random_XorShift64_Pool<typename Node::device_type::execution_space>::resetPool(getMap()->getComm()->getRank());
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
typename TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::dual_view_type::t_host_const_um
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getHostLocalView(Access::ReadOnlyStruct) const {
  return subview(vec_->getLocalViewHost(Tpetra::Access::ReadOnly), Kokkos::ALL(), Kokkos::ALL());
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
typename TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::dual_view_type::t_dev_const_um
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getDeviceLocalView(Access::ReadOnlyStruct) const {
  return subview(vec_->getLocalViewDevice(Tpetra::Access::ReadOnly), Kokkos::ALL(), Kokkos::ALL());
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
typename TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::dual_view_type::t_host_um
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getHostLocalView(Access::OverwriteAllStruct) const {
  return subview(vec_->getLocalViewHost(Tpetra::Access::OverwriteAll), Kokkos::ALL(), Kokkos::ALL());
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
typename TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::dual_view_type::t_dev_um
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getDeviceLocalView(Access::OverwriteAllStruct) const {
  return subview(vec_->getLocalViewDevice(Tpetra::Access::OverwriteAll), Kokkos::ALL(), Kokkos::ALL());
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
typename TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::dual_view_type::t_host_um
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getHostLocalView(Access::ReadWriteStruct) const {
  return subview(vec_->getLocalViewHost(Tpetra::Access::ReadWrite), Kokkos::ALL(), Kokkos::ALL());
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
typename TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::dual_view_type::t_dev_um
TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    getDeviceLocalView(Access::ReadWriteStruct) const {
  return subview(vec_->getLocalViewDevice(Tpetra::Access::ReadWrite), Kokkos::ALL(), Kokkos::ALL());
}

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    assign(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &rhs) {
  typedef TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> this_type;
  const this_type *rhsPtr = dynamic_cast<const this_type *>(&rhs);
  TEUCHOS_TEST_FOR_EXCEPTION(
      rhsPtr == NULL, std::invalid_argument,
      "Xpetra::MultiVector::operator=:"
      " The left-hand side (LHS) of the assignment has a different type than "
      "the right-hand side (RHS).  The LHS has type Xpetra::TpetraMultiVector"
      " (which means it wraps a Tpetra::MultiVector), but the RHS has some "
      "other type.  This probably means that the RHS wraps an "
      "Epetra_MultiVector.  Xpetra::MultiVector does not currently implement "
      "assignment from an Epetra object to a Tpetra object, though this could"
      " be added with sufficient interest.");

  typedef Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> TMV;
  RCP<const TMV> rhsImpl = rhsPtr->getTpetra_MultiVector();
  RCP<TMV> lhsImpl       = this->getTpetra_MultiVector();

  TEUCHOS_TEST_FOR_EXCEPTION(
      rhsImpl.is_null(), std::logic_error,
      "Xpetra::MultiVector::operator= "
      "(in Xpetra::TpetraMultiVector::assign): *this (the right-hand side of "
      "the assignment) has a null RCP<Tpetra::MultiVector> inside.  Please "
      "report this bug to the Xpetra developers.");
  TEUCHOS_TEST_FOR_EXCEPTION(
      lhsImpl.is_null(), std::logic_error,
      "Xpetra::MultiVector::operator= "
      "(in Xpetra::TpetraMultiVector::assign): The left-hand side of the "
      "assignment has a null RCP<Tpetra::MultiVector> inside.  Please report "
      "this bug to the Xpetra developers.");

  Tpetra::deep_copy(*lhsImpl, *rhsImpl);
}

#ifdef HAVE_XPETRA_EPETRA

#if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_INT))) || \
     (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_INT))))

// specialization for TpetraMultiVector on EpetraNode and GO=int
template <class Scalar>
class TpetraMultiVector<Scalar, int, int, EpetraNode>
  : public virtual MultiVector<Scalar, int, int, EpetraNode> {
  typedef int LocalOrdinal;
  typedef int GlobalOrdinal;
  typedef EpetraNode Node;

  // The following typedef are used by the XPETRA_DYNAMIC_CAST() macro.
  typedef TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> TpetraMultiVectorClass;

 public:


  TpetraMultiVector() {
    XPETRA_TPETRA_ETI_EXCEPTION(typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), "int", typeid(EpetraNode).name());
  }

  TpetraMultiVector(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map, size_t NumVectors, bool zeroOut = true) {
    XPETRA_TPETRA_ETI_EXCEPTION(typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), "int", typeid(EpetraNode).name());
  }

  TpetraMultiVector(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Teuchos::DataAccess copyOrView) {
    XPETRA_TPETRA_ETI_EXCEPTION(typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), "int", typeid(EpetraNode).name());
  }

  TpetraMultiVector(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map, const Teuchos::ArrayView<const Scalar> &A, size_t LDA, size_t NumVectors) {
    XPETRA_TPETRA_ETI_EXCEPTION(typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), "int", typeid(EpetraNode).name());
  }

  TpetraMultiVector(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map, const Teuchos::ArrayView<const Teuchos::ArrayView<const Scalar> > &ArrayOfPtrs, size_t NumVectors) {
    XPETRA_TPETRA_ETI_EXCEPTION(typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), "int", typeid(EpetraNode).name());
  }

  virtual ~TpetraMultiVector() {}




  void replaceGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar &value) {}

  void sumIntoGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar &value) {}

  void replaceLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar &value) {}

  void sumIntoLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar &value) {}

  void putScalar(const Scalar &value) {}

  void reduce() {}




  Teuchos::RCP<const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > getVector(size_t j) const { return Teuchos::null; }

  Teuchos::RCP<Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > getVectorNonConst(size_t j) { return Teuchos::null; }

  Teuchos::ArrayRCP<const Scalar> getData(size_t j) const { return Teuchos::ArrayRCP<const Scalar>(); }

  Teuchos::ArrayRCP<Scalar> getDataNonConst(size_t j) { return Teuchos::ArrayRCP<Scalar>(); }

  void get1dCopy(Teuchos::ArrayView<Scalar> A, size_t LDA) const {}

  void get2dCopy(Teuchos::ArrayView<const Teuchos::ArrayView<Scalar> > ArrayOfPtrs) const {}

  Teuchos::ArrayRCP<const Scalar> get1dView() const { return Teuchos::ArrayRCP<const Scalar>(); }

  Teuchos::ArrayRCP<Teuchos::ArrayRCP<const Scalar> > get2dView() const { return Teuchos::ArrayRCP<Teuchos::ArrayRCP<const Scalar> >(); }

  Teuchos::ArrayRCP<Scalar> get1dViewNonConst() { return Teuchos::ArrayRCP<Scalar>(); }

  Teuchos::ArrayRCP<Teuchos::ArrayRCP<Scalar> > get2dViewNonConst() { return Teuchos::ArrayRCP<Teuchos::ArrayRCP<Scalar> >(); }




  void dot(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const Teuchos::ArrayView<Scalar> &dots) const {}

  void abs(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A) {}

  void reciprocal(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A) {}

  void scale(const Scalar &alpha) {}

  void scale(Teuchos::ArrayView<const Scalar> alpha) {}

  void scale(const Scalar &alpha, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A) {}

  void update(const Scalar &alpha, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const Scalar &beta) {}

  void update(const Scalar &alpha, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const Scalar &beta, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &B, const Scalar &gamma) {}

  void norm1(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> &norms) const {}

  void norm2(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> &norms) const {}

  void normInf(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> &norms) const {}

  void meanValue(const Teuchos::ArrayView<Scalar> &means) const {}

  void multiply(Teuchos::ETransp transA, Teuchos::ETransp transB, const Scalar &alpha, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &B, const Scalar &beta) {}




  size_t getNumVectors() const { return 0; }

  size_t getLocalLength() const { return 0; }

  global_size_t getGlobalLength() const { return 0; }

  // \! Checks to see if the local length, number of vectors and size of Scalar type match
  bool isSameSize(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &vec) const { return false; }




  std::string description() const { return std::string(""); }

  void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel = Teuchos::Describable::verbLevel_default) const {}


  void elementWiseMultiply(Scalar scalarAB, const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &B, Scalar scalarThis){};

  void randomize(bool bUseXpetraImplementation = false) {}

  void randomize(const Scalar &minVal, const Scalar &maxVal, bool bUseXpetraImplementation = false) {}

  //{@
  // Implements DistObject interface

  Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > getMap() const { return Teuchos::null; }

  void doImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {}

  void beginImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {}

  void endImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {}

  void doExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {}

  void beginExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {}

  void endExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {}

  void doImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {}

  void beginImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {}

  void endImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {}

  void doExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {}

  void beginExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {}

  void endExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {}

  void replaceMap(const RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map) {}




  TpetraMultiVector(const Teuchos::RCP<Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > &vec) {
    XPETRA_TPETRA_ETI_EXCEPTION(typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), "int", typeid(EpetraNode).name());
  }

  RCP<Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > getTpetra_MultiVector() const { return Teuchos::null; }

  void setSeed(unsigned int seed) {}


 protected:
  virtual void
  assign(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &rhs) {}
};  // TpetraMultiVector class (specialization GO=int, NO=EpetraNode)
#endif

#if ((defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_OPENMP) || !defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
     (!defined(EPETRA_HAVE_OMP) && (!defined(HAVE_TPETRA_INST_SERIAL) || !defined(HAVE_TPETRA_INST_INT_LONG_LONG))))

// specialization for TpetraMultiVector on EpetraNode and GO=long long
template <class Scalar>
class TpetraMultiVector<Scalar, int, long long, EpetraNode>
  : public virtual MultiVector<Scalar, int, long long, EpetraNode> {
  typedef int LocalOrdinal;
  typedef long long GlobalOrdinal;
  typedef EpetraNode Node;

  // The following typedef are used by the XPETRA_DYNAMIC_CAST() macro.
  typedef TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> TpetraMultiVectorClass;

 public:


  TpetraMultiVector(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map, size_t NumVectors, bool zeroOut = true) {
    XPETRA_TPETRA_ETI_EXCEPTION(typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), "long long", typeid(EpetraNode).name());
  }

  TpetraMultiVector(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Teuchos::DataAccess copyOrView) {
    XPETRA_TPETRA_ETI_EXCEPTION(typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), "long long", typeid(EpetraNode).name());
  }

  TpetraMultiVector(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map, const Teuchos::ArrayView<const Scalar> &A, size_t LDA, size_t NumVectors) {
    XPETRA_TPETRA_ETI_EXCEPTION(typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), "long long", typeid(EpetraNode).name());
  }

  TpetraMultiVector(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map, const Teuchos::ArrayView<const Teuchos::ArrayView<const Scalar> > &ArrayOfPtrs, size_t NumVectors) {
    XPETRA_TPETRA_ETI_EXCEPTION(typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), "long long", typeid(EpetraNode).name());
  }

  virtual ~TpetraMultiVector() {}




  void replaceGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar &value) {}

  void sumIntoGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar &value) {}

  void replaceLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar &value) {}

  void sumIntoLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar &value) {}

  void putScalar(const Scalar &value) {}

  void reduce() {}




  Teuchos::RCP<const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > getVector(size_t j) const { return Teuchos::null; }

  Teuchos::RCP<Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > getVectorNonConst(size_t j) { return Teuchos::null; }

  Teuchos::ArrayRCP<const Scalar> getData(size_t j) const { return Teuchos::ArrayRCP<const Scalar>(); }

  Teuchos::ArrayRCP<Scalar> getDataNonConst(size_t j) { return Teuchos::ArrayRCP<Scalar>(); }

  void get1dCopy(Teuchos::ArrayView<Scalar> A, size_t LDA) const {}

  void get2dCopy(Teuchos::ArrayView<const Teuchos::ArrayView<Scalar> > ArrayOfPtrs) const {}

  Teuchos::ArrayRCP<const Scalar> get1dView() const { return Teuchos::ArrayRCP<const Scalar>(); }

  Teuchos::ArrayRCP<Teuchos::ArrayRCP<const Scalar> > get2dView() const { return Teuchos::ArrayRCP<Teuchos::ArrayRCP<const Scalar> >(); }

  Teuchos::ArrayRCP<Scalar> get1dViewNonConst() { return Teuchos::ArrayRCP<Scalar>(); }

  Teuchos::ArrayRCP<Teuchos::ArrayRCP<Scalar> > get2dViewNonConst() { return Teuchos::ArrayRCP<Teuchos::ArrayRCP<Scalar> >(); }




  void dot(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const Teuchos::ArrayView<Scalar> &dots) const {}

  void abs(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A) {}

  void reciprocal(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A) {}

  void scale(const Scalar &alpha) {}

  void scale(Teuchos::ArrayView<const Scalar> alpha) {}

  void scale(const Scalar &alpha, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A) {}

  void update(const Scalar &alpha, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const Scalar &beta) {}

  void update(const Scalar &alpha, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const Scalar &beta, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &B, const Scalar &gamma) {}

  void norm1(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> &norms) const {}

  void norm2(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> &norms) const {}

  void normInf(const Teuchos::ArrayView<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> &norms) const {}

  void meanValue(const Teuchos::ArrayView<Scalar> &means) const {}

  void multiply(Teuchos::ETransp transA, Teuchos::ETransp transB, const Scalar &alpha, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &B, const Scalar &beta) {}




  size_t getNumVectors() const { return 0; }

  size_t getLocalLength() const { return 0; }

  global_size_t getGlobalLength() const { return 0; }

  // \! Checks to see if the local length, number of vectors and size of Scalar type match
  bool isSameSize(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &vec) const { return false; }




  std::string description() const { return std::string(""); }

  void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel = Teuchos::Describable::verbLevel_default) const {}


  void elementWiseMultiply(Scalar scalarAB, const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A, const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &B, Scalar scalarThis){};

  void randomize(bool bUseXpetraImplementation = false) {}

  void randomize(const Scalar &minVal, const Scalar &maxVal, bool bUseXpetraImplementation = false) {}

  //{@
  // Implements DistObject interface

  Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > getMap() const { return Teuchos::null; }

  void doImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {}

  void beginImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {}

  void endImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {}

  void doExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {}

  void beginExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {}

  void endExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Import<LocalOrdinal, GlobalOrdinal, Node> &importer, CombineMode CM) {}

  void doImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {}

  void beginImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {}

  void endImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &source, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {}

  void doExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {}

  void beginExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {}

  void endExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node> &dest, const Export<LocalOrdinal, GlobalOrdinal, Node> &exporter, CombineMode CM) {}

  void replaceMap(const RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map) {}




  TpetraMultiVector(const Teuchos::RCP<Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > &vec) {
    XPETRA_TPETRA_ETI_EXCEPTION(typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), typeid(TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, EpetraNode>).name(), "long long", typeid(EpetraNode).name());
  }

  RCP<Tpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > getTpetra_MultiVector() const { return Teuchos::null; }

  void setSeed(unsigned int seed) {}


 protected:
  virtual void
  assign(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &rhs) {}
};  // TpetraMultiVector class (specialization GO=int, NO=EpetraNode)

#endif  // TpetraMultiVector class (specialization GO=long long, NO=EpetraNode)

#endif  // HAVE_XPETRA_EPETRA

}  // namespace Xpetra

// Following header file inculsion is needed for the dynamic_cast to TpetraVector in
// elementWiseMultiply (because we cannot dynamic_cast if target is not a complete type)
// It is included here to avoid circular dependency between Vector and MultiVector
// TODO: there is certainly a more elegant solution...
#include "Xpetra_TpetraVector.hpp"

namespace Xpetra {

template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>
void TpetraMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::
    elementWiseMultiply(Scalar scalarAB,
                        const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &A,
                        const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &B,
                        Scalar scalarThis) {
  XPETRA_MONITOR("TpetraMultiVector::elementWiseMultiply");

  // XPETRA_DYNAMIC_CAST won't take TpetraVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>
  // as an argument, hence the following typedef.
  typedef TpetraVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> tpv;
  XPETRA_DYNAMIC_CAST(const tpv, A, tA, "Xpetra::TpetraMultiVectorMatrix->multiply() only accept Xpetra::TpetraMultiVector as input arguments.");
  XPETRA_DYNAMIC_CAST(const TpetraMultiVector, B, tB, "Xpetra::TpetraMultiVectorMatrix->multiply() only accept Xpetra::TpetraMultiVector as input arguments.");
  vec_->elementWiseMultiply(scalarAB, *tA.getTpetra_Vector(), *tB.getTpetra_MultiVector(), scalarThis);
}

}  // namespace Xpetra

#define XPETRA_TPETRAMULTIVECTOR_SHORT
#endif  // XPETRA_TPETRAMULTIVECTOR_HPP