Xpetra_EpetraIntVector.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_EPETRAINTVECTOR_HPP
#define XPETRA_EPETRAINTVECTOR_HPP
 
#include "Xpetra_EpetraConfigDefs.hpp"
 
#include "Xpetra_ConfigDefs.hpp"
#include "Xpetra_MultiVector.hpp"
#include "Xpetra_Vector.hpp"
#include "Xpetra_Exceptions.hpp"
 
#include "Xpetra_EpetraMap.hpp"
#include "Xpetra_EpetraMultiVector.hpp"
#include "Epetra_IntVector.h"
 
#if defined(XPETRA_ENABLE_DEPRECATED_CODE)
#ifdef __GNUC__
#if defined(Xpetra_SHOW_DEPRECATED_WARNINGS)
#warning "The header file Trilinos/packages/xpetra/src/Vector/Xpetra_EpetraIntVector.hpp is deprecated."
#endif
#endif
#else
#error "The header file Trilinos/packages/xpetra/src/Vector/Xpetra_EpetraIntVector.hpp is deprecated."
#endif
 
namespace Xpetra {
 
// TODO: move that elsewhere
template <class GlobalOrdinal, class Node>
XPETRA_DEPRECATED Epetra_IntVector &toEpetra(Vector<int, int, GlobalOrdinal, Node> &);
 
template <class GlobalOrdinal, class Node>
const XPETRA_DEPRECATED Epetra_IntVector &toEpetra(const Vector<int, int, GlobalOrdinal, Node> &);
//
 
// stub implementation for EpetraIntVectorT
template <class EpetraGlobalOrdinal, class Node>
class XPETRA_DEPRECATED EpetraIntVectorT
  : public Vector<int, int, EpetraGlobalOrdinal, Node> {
  typedef int Scalar;
  typedef int LocalOrdinal;
  typedef EpetraGlobalOrdinal GlobalOrdinal;
 
 public:
 
 
  explicit EpetraIntVectorT(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map, bool zeroOut = true) {}
 
  ~EpetraIntVectorT(){};
 
 
 
 
  int dot(const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &a) const {
    XPETRA_MONITOR("EpetraIntVectorT::dot");
    TEUCHOS_TEST_FOR_EXCEPTION(-1, Xpetra::Exceptions::NotImplemented, "TODO");
    TEUCHOS_UNREACHABLE_RETURN(-1);
  }
 
  Teuchos::ScalarTraits<int>::magnitudeType norm1() const {
    XPETRA_MONITOR("EpetraIntVectorT::norm1");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
    TEUCHOS_UNREACHABLE_RETURN(-1);
  }
 
  Teuchos::ScalarTraits<int>::magnitudeType norm2() const {
    XPETRA_MONITOR("EpetraIntVectorT::norm2");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
    TEUCHOS_UNREACHABLE_RETURN(-1);
  }
 
  Teuchos::ScalarTraits<int>::magnitudeType normInf() const {
    XPETRA_MONITOR("EpetraIntVectorT::normInf");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
    TEUCHOS_UNREACHABLE_RETURN(-1);
  }
 
  int meanValue() const {
    XPETRA_MONITOR("EpetraIntVectorT::meanValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
    TEUCHOS_UNREACHABLE_RETURN(-1);
  }
 
  int maxValue() const {
    XPETRA_MONITOR("EpetraIntVectorT::maxValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
    TEUCHOS_UNREACHABLE_RETURN(-1);
  }
 
 
 
 
  void replaceGlobalValue(GlobalOrdinal globalRow, const Scalar &value) {
    XPETRA_MONITOR("EpetraIntVectorT::replaceGlobalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void sumIntoGlobalValue(GlobalOrdinal globalRow, const Scalar &value) {
    XPETRA_MONITOR("EpetraIntVectorT::sumIntoGlobalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void replaceLocalValue(LocalOrdinal myRow, const Scalar &value) {
    XPETRA_MONITOR("EpetraIntVectorT::replaceLocalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void sumIntoLocalValue(LocalOrdinal myRow, const Scalar &value) {
    XPETRA_MONITOR("EpetraIntVectorT::sumIntoLocalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void putScalar(const int &value) {}
 
  void randomize(bool bUseXpetraImplementation = true) {
    XPETRA_MONITOR("EpetraIntVectorT::randomize");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Xpetra::EpetraIntVectorT::randomize(): Functionnality not available in Epetra");
  }
 
  void randomize(const Scalar & /*minVal*/, const Scalar & /*maxVal*/, bool bUseXpetraImplementation = true) {
    XPETRA_MONITOR("EpetraIntVectorT::randomize");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Xpetra::EpetraIntVectorT::randomize(): Functionnality not available in Epetra");
  }
 
 
  void setSeed(unsigned int seed) {
    XPETRA_MONITOR("EpetraIntVectorT::setSeed");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Xpetra::EpetraIntVectorT::setSeed(): Functionnality not available in Epetra");
  }
 
 
 
 
  Teuchos::RCP<const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > getVector(size_t j) const {
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  Teuchos::RCP<Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > getVectorNonConst(size_t j) {
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  Teuchos::ArrayRCP<const int> getData(size_t j) const { return Teuchos::ArrayRCP<const int>(); }
 
  Teuchos::ArrayRCP<int> getDataNonConst(size_t j) { return Teuchos::ArrayRCP<int>(); }
 
 
 
 
  void dot(const MultiVector<int, int, GlobalOrdinal, Node> &A, const Teuchos::ArrayView<int> &dots) const {}
 
  void abs(const MultiVector<int, int, GlobalOrdinal, Node> &A) {}
 
  void reciprocal(const MultiVector<int, int, GlobalOrdinal, Node> &A) {}
 
  void scale(const int &alpha) {}
 
  void scale(Teuchos::ArrayView<const int> alpha) {
    XPETRA_MONITOR("EpetraIntVectorT::scale");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void update(const int &alpha, const MultiVector<int, int, GlobalOrdinal, Node> &A, const int &beta) {
    XPETRA_MONITOR("EpetraIntVectorT::update");
 
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, A, eA, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void update(const int &alpha, const MultiVector<int, int, GlobalOrdinal, Node> &A, const int &beta, const MultiVector<int, int, GlobalOrdinal, Node> &B, const int &gamma) {
    XPETRA_MONITOR("EpetraIntVectorT::update");
 
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, A, eA, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, B, eB, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void norm1(const Teuchos::ArrayView<Teuchos::ScalarTraits<int>::magnitudeType> &norms) const {
    XPETRA_MONITOR("EpetraIntVectorT::norm1");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void norm2(const Teuchos::ArrayView<Teuchos::ScalarTraits<int>::magnitudeType> &norms) const {
    XPETRA_MONITOR("EpetraIntVectorT::norm2");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void normInf(const Teuchos::ArrayView<Teuchos::ScalarTraits<int>::magnitudeType> &norms) const {
    XPETRA_MONITOR("EpetraIntVectorT::normInf");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void meanValue(const Teuchos::ArrayView<int> &means) const {
    XPETRA_MONITOR("EpetraIntVectorT::meanValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void maxValue(const Teuchos::ArrayView<int> &maxs) const {
    XPETRA_MONITOR("EpetraIntVectorT::maxValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void multiply(Teuchos::ETransp transA, Teuchos::ETransp transB, const int &alpha, const MultiVector<int, int, GlobalOrdinal, Node> &A, const MultiVector<int, int, GlobalOrdinal, Node> &B, const int &beta) {
    XPETRA_MONITOR("EpetraIntVectorT::multiply");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Not available in Epetra");
  }
 
  void elementWiseMultiply(int scalarAB, const Vector<int, int, GlobalOrdinal, Node> &A, const MultiVector<int, int, GlobalOrdinal, Node> &B, int scalarThis) {
    XPETRA_MONITOR("EpetraIntVectorT::elementWiseMultiply");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Xpetra_EpetraIntVector: elementWiseMultiply not implemented because Epetra_IntVector does not support this operation");
  }
 
 
 
 
  void replaceGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar &value) {
    XPETRA_MONITOR("EpetraIntVectorT::replaceGlobalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void sumIntoGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar &value) {
    XPETRA_MONITOR("EpetraIntVectorT::sumIntoGlobalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void replaceLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar &value) {
    XPETRA_MONITOR("EpetraIntVectorT::replaceLocalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void sumIntoLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar &value) {
    XPETRA_MONITOR("EpetraIntVectorT::sumIntoLocalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
 
 
 
  size_t getNumVectors() const {
    XPETRA_MONITOR("EpetraIntVectorT::getNumVectors");
    return 1;
  }
 
  size_t getLocalLength() const { return 0; }
 
  global_size_t getGlobalLength() const { return 0; }
 
  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 {}
 
 
  RCP<Epetra_IntVector> getEpetra_IntVector() const { return Teuchos::null; }
 
  const RCP<const Comm<int> > getComm() const {
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO getComm Epetra MultiVector not implemented");
  }
 
  // Implementing DistObject
  Teuchos::RCP<const Map<int, GlobalOrdinal, Node> > getMap() const {
    return Teuchos::null;
  }
 
  void doImport(const DistObject<int, int, GlobalOrdinal, Node> &source,
                const Import<int, GlobalOrdinal, Node> &importer, CombineMode CM) {}
 
  void doExport(const DistObject<int, LocalOrdinal, GlobalOrdinal, Node> &dest,
                const Import<int, GlobalOrdinal, Node> &importer, CombineMode CM) {}
 
  void doImport(const DistObject<int, LocalOrdinal, GlobalOrdinal, Node> &source,
                const Export<int, GlobalOrdinal, Node> &exporter, CombineMode CM) {}
 
  void doExport(const DistObject<int, LocalOrdinal, GlobalOrdinal, Node> &dest,
                const Export<int, GlobalOrdinal, Node> &exporter, CombineMode CM) {}
 
  void replaceMap(const RCP<const Map<int, GlobalOrdinal, Node> > &map) {
    // do nothing
  }
 
 protected:
  virtual void
  assign(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &rhs) {}
 
 private:
  // RCP< Epetra_IntVector > vec_;
 
};  // class EpetraIntVectorT
 
// specialization on GO=int and Node=Serial
#ifndef XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES
template <>
class EpetraIntVectorT<int, EpetraNode>
  : public virtual Vector<int, int, int, EpetraNode> {
  typedef int Scalar;
  typedef int LocalOrdinal;
  typedef int GlobalOrdinal;
  typedef EpetraNode Node;
 
 public:
 
 
  explicit EpetraIntVectorT(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map, bool zeroOut = true) {
    vec_ = rcp(new Epetra_IntVector(toEpetra<GlobalOrdinal, Node>(map), zeroOut));
  }
 
  ~EpetraIntVectorT(){};
 
 
 
 
  int dot(const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> & /* a */) const {
    XPETRA_MONITOR("EpetraIntVectorT::dot");
    TEUCHOS_TEST_FOR_EXCEPTION(-1, Xpetra::Exceptions::NotImplemented, "TODO");
    TEUCHOS_UNREACHABLE_RETURN(-1);
  }
 
  Teuchos::ScalarTraits<int>::magnitudeType norm1() const {
    XPETRA_MONITOR("EpetraIntVectorT::norm1");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
    TEUCHOS_UNREACHABLE_RETURN(-1);
  }
 
  Teuchos::ScalarTraits<int>::magnitudeType norm2() const {
    XPETRA_MONITOR("EpetraIntVectorT::norm2");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
    TEUCHOS_UNREACHABLE_RETURN(-1);
  }
 
  Teuchos::ScalarTraits<int>::magnitudeType normInf() const {
    XPETRA_MONITOR("EpetraIntVectorT::normInf");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
    TEUCHOS_UNREACHABLE_RETURN(-1);
  }
 
  int meanValue() const {
    XPETRA_MONITOR("EpetraIntVectorT::meanValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
    TEUCHOS_UNREACHABLE_RETURN(-1);
  }
 
  int maxValue() const {
    XPETRA_MONITOR("EpetraIntVectorT::maxValue");
    return vec_->MaxValue();
  }
 
 
 
 
  void replaceGlobalValue(GlobalOrdinal /* globalRow */, const Scalar & /* value */) {
    XPETRA_MONITOR("EpetraIntVectorT::replaceGlobalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void sumIntoGlobalValue(GlobalOrdinal /* globalRow */, const Scalar & /* value */) {
    XPETRA_MONITOR("EpetraIntVectorT::sumIntoGlobalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void replaceLocalValue(LocalOrdinal myRow, const Scalar &value) {
    XPETRA_MONITOR("EpetraIntVectorT::replaceLocalValue");
    (*vec_)[myRow] = value;
  }
 
  void sumIntoLocalValue(LocalOrdinal myRow, const Scalar &value) {
    XPETRA_MONITOR("EpetraIntVectorT::sumIntoLocalValue");
    (*vec_)[myRow] += value;
  }
 
  void putScalar(const int &value) { vec_->PutValue(value); }
 
  void randomize(bool /* bUseXpetraImplementation */ = true) {
    XPETRA_MONITOR("EpetraIntVectorT::randomize");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Xpetra::EpetraIntVectorT::randomize(): Functionnality not available in Epetra");
  }
 
  void randomize(const Scalar & /*minVal*/, const Scalar & /*maxVal*/, bool /* bUseXpetraImplementation */ = true) {
    XPETRA_MONITOR("EpetraIntVectorT::randomize");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Xpetra::EpetraIntVectorT::randomize(): Functionnality not available in Epetra");
  }
 
 
  void setSeed(unsigned int /* seed */) {
    XPETRA_MONITOR("EpetraIntVectorT::setSeed");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Xpetra::EpetraIntVectorT::setSeed(): Functionnality not available in Epetra");
  }
 
  typedef typename Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::dual_view_type dual_view_type;
 
  typename dual_view_type::t_host_const_um getLocalViewHost(Access::ReadOnlyStruct) const override { return getLocalViewHost(Access::ReadWrite); }
 
  typename dual_view_type::t_dev_const_um getLocalViewDevice(Access::ReadOnlyStruct) const override { return getLocalViewDevice(Access::ReadWrite); }
 
  typename dual_view_type::t_host_um getLocalViewHost(Access::OverwriteAllStruct) const override { return getLocalViewHost(Access::ReadWrite); }
 
  typename dual_view_type::t_dev_um getLocalViewDevice(Access::OverwriteAllStruct) const override { return getLocalViewDevice(Access::ReadWrite); }
 
  typename dual_view_type::t_host_um getLocalViewHost(Access::ReadWriteStruct) const override {
    typedef Kokkos::View<typename dual_view_type::t_host::data_type,
                         Kokkos::LayoutLeft,
                         typename dual_view_type::t_host::device_type,
                         Kokkos::MemoryUnmanaged>
        epetra_view_type;
    // access Epetra vector data
    Scalar *data = NULL;
    vec_->ExtractView(&data);
    int localLength = vec_->MyLength();
 
    // create view
    epetra_view_type test                  = epetra_view_type(data, localLength, 1);
    typename dual_view_type::t_host_um ret = subview(test, Kokkos::ALL(), Kokkos::ALL());
    return ret;
  }
 
  typename dual_view_type::t_dev_um getLocalViewDevice(Access::ReadWriteStruct) const override { return getLocalViewHost(Access::ReadWrite); }
 
 
 
 
  Teuchos::RCP<const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > getVector(size_t /* j */) const {
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  Teuchos::RCP<Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > getVectorNonConst(size_t /* j */) {
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  Teuchos::ArrayRCP<const int> getData(size_t /* j */) const {
    XPETRA_MONITOR("EpetraIntVectorT::getData");
 
    int *data       = vec_->Values();
    int localLength = vec_->MyLength();
 
    return ArrayRCP<int>(data, 0, localLength, false);  // not ownership
  }
 
  Teuchos::ArrayRCP<int> getDataNonConst(size_t /* j */) {
    XPETRA_MONITOR("EpetraIntVectorT::getDataNonConst");
 
    int *data       = vec_->Values();
    int localLength = vec_->MyLength();
 
    return ArrayRCP<int>(data, 0, localLength, false);  // not ownership
  }
 
 
 
 
  void dot(const MultiVector<int, int, GlobalOrdinal, Node> & /* A */, const Teuchos::ArrayView<int> & /* dots */) const {
    XPETRA_MONITOR("EpetraIntVectorT::dot");
 
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, A, eA, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void abs(const MultiVector<int, int, GlobalOrdinal, Node> & /* A */) {
    XPETRA_MONITOR("EpetraIntVectorT::abs");
 
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, A, eA, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void reciprocal(const MultiVector<int, int, GlobalOrdinal, Node> & /* A */) {
    XPETRA_MONITOR("EpetraIntVectorT::reciprocal");
 
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, A, eA, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void scale(const int & /* alpha */) {
    XPETRA_MONITOR("EpetraIntVectorT::scale");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void scale(Teuchos::ArrayView<const int> /* alpha */) {
    XPETRA_MONITOR("EpetraIntVectorT::scale");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void update(const int & /* alpha */, const MultiVector<int, int, GlobalOrdinal, Node> & /* A */, const int & /* beta */) {
    XPETRA_MONITOR("EpetraIntVectorT::update");
 
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, A, eA, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void update(const int & /* alpha */, const MultiVector<int, int, GlobalOrdinal, Node> & /* A */, const int & /* beta */, const MultiVector<int, int, GlobalOrdinal, Node> & /* B */, const int & /* gamma */) {
    XPETRA_MONITOR("EpetraIntVectorT::update");
 
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, A, eA, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, B, eB, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void norm1(const Teuchos::ArrayView<Teuchos::ScalarTraits<int>::magnitudeType> & /* norms */) const {
    XPETRA_MONITOR("EpetraIntVectorT::norm1");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void norm2(const Teuchos::ArrayView<Teuchos::ScalarTraits<int>::magnitudeType> & /* norms */) const {
    XPETRA_MONITOR("EpetraIntVectorT::norm2");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void normInf(const Teuchos::ArrayView<Teuchos::ScalarTraits<int>::magnitudeType> & /* norms */) const {
    XPETRA_MONITOR("EpetraIntVectorT::normInf");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void meanValue(const Teuchos::ArrayView<int> & /* means */) const {
    XPETRA_MONITOR("EpetraIntVectorT::meanValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void maxValue(const Teuchos::ArrayView<int> & /* maxs */) const {
    XPETRA_MONITOR("EpetraIntVectorT::maxValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void multiply(Teuchos::ETransp /* transA */, Teuchos::ETransp /* transB */, const int & /* alpha */, const MultiVector<int, int, GlobalOrdinal, Node> & /* A */, const MultiVector<int, int, GlobalOrdinal, Node> & /* B */, const int & /* beta */) {
    XPETRA_MONITOR("EpetraIntVectorT::multiply");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Not available in Epetra");
  }
 
  void elementWiseMultiply(int /* scalarAB */, const Vector<int, int, GlobalOrdinal, Node> & /* A */, const MultiVector<int, int, GlobalOrdinal, Node> & /* B */, int /* scalarThis */) {
    XPETRA_MONITOR("EpetraIntVectorT::elementWiseMultiply");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Xpetra_EpetraIntVector: elementWiseMultiply not implemented because Epetra_IntVector does not support this operation");
  }
 
 
 
 
  void replaceGlobalValue(GlobalOrdinal /* globalRow */, size_t /* vectorIndex */, const Scalar & /* value */) {
    XPETRA_MONITOR("EpetraIntVectorT::replaceGlobalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void sumIntoGlobalValue(GlobalOrdinal /* globalRow */, size_t /* vectorIndex */, const Scalar & /* value */) {
    XPETRA_MONITOR("EpetraIntVectorT::sumIntoGlobalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void replaceLocalValue(LocalOrdinal /* myRow */, size_t /* vectorIndex */, const Scalar & /* value */) {
    XPETRA_MONITOR("EpetraIntVectorT::replaceLocalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void sumIntoLocalValue(LocalOrdinal /* myRow */, size_t /* vectorIndex */, const Scalar & /* value */) {
    XPETRA_MONITOR("EpetraIntVectorT::sumIntoLocalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
 
 
 
  size_t getNumVectors() const {
    XPETRA_MONITOR("EpetraIntVectorT::getNumVectors");
    return 1;
  }
 
  size_t getLocalLength() const { return vec_->MyLength(); }
 
  global_size_t getGlobalLength() const { return vec_->GlobalLength64(); }
 
  bool isSameSize(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &vec) const {
    XPETRA_MONITOR("EpetraIntVectorT::isSameSize");
    const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> *asvec = dynamic_cast<const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> *>(&vec);
    if (!asvec) return false;
    auto vv = toEpetra(*asvec);
    return ((vec_->MyLength() == vv.MyLength()) && (getNumVectors() == vec.getNumVectors()));
  }
 
 
 
 
  std::string description() const {
    XPETRA_MONITOR("EpetraIntVectorT::description");
 
    // This implementation come from Epetra_Vector_def.hpp (without modification)
    std::ostringstream oss;
    oss << Teuchos::Describable::description();
    oss << "{length=" << this->getGlobalLength()
        << "}";
    return oss.str();
  }
 
  void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel = Teuchos::Describable::verbLevel_default) const {
    XPETRA_MONITOR("EpetraIntVectorT::describe");
 
    // This implementation come from Tpetra_Vector_def.hpp (without modification) // JG: true?
    using std::endl;
    using std::setw;
    using Teuchos::VERB_DEFAULT;
    using Teuchos::VERB_EXTREME;
    using Teuchos::VERB_HIGH;
    using Teuchos::VERB_LOW;
    using Teuchos::VERB_MEDIUM;
    using Teuchos::VERB_NONE;
 
    if (verbLevel > Teuchos::VERB_NONE)
      vec_->Print(out);
  }
 
 
  RCP<Epetra_IntVector> getEpetra_IntVector() const { return vec_; }
 
  const RCP<const Comm<int> > getComm() const {
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO getComm Epetra MultiVector not implemented");
  }
 
  // Implementing DistObject
  Teuchos::RCP<const Map<int, GlobalOrdinal, Node> > getMap() const {
    RCP<const Epetra_BlockMap> map = rcp(new Epetra_BlockMap(vec_->Map()));
    return rcp(new Xpetra::EpetraMapT<GlobalOrdinal, Node>(map));
  }
 
  void doImport(const DistObject<int, int, GlobalOrdinal, Node> &source,
                const Import<int, GlobalOrdinal, Node> &importer, CombineMode CM) {
    XPETRA_MONITOR("EpetraIntVectorT::doImport");
 
    XPETRA_DYNAMIC_CAST(const EpetraIntVectorT<GlobalOrdinal XPETRA_COMMA Node>, source, tSource, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraIntVectorT as input arguments.");
    XPETRA_DYNAMIC_CAST(const EpetraImportT<GlobalOrdinal XPETRA_COMMA Node>, importer, tImporter, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraImportT as input arguments.");
 
    const Epetra_IntVector &v = *tSource.getEpetra_IntVector();
    int err                   = vec_->Import(v, *tImporter.getEpetra_Import(), toEpetra(CM));
    TEUCHOS_TEST_FOR_EXCEPTION(err != 0, std::runtime_error, "Catch error code returned by Epetra.");
  }
 
  void doExport(const DistObject<int, LocalOrdinal, GlobalOrdinal, Node> &dest,
                const Import<int, GlobalOrdinal, Node> &importer, CombineMode CM) {
    XPETRA_MONITOR("EpetraIntVectorT::doExport");
 
    XPETRA_DYNAMIC_CAST(const EpetraIntVectorT<GlobalOrdinal XPETRA_COMMA Node>, dest, tDest, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraIntVectorT as input arguments.");
    XPETRA_DYNAMIC_CAST(const EpetraImportT<GlobalOrdinal XPETRA_COMMA Node>, importer, tImporter, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraImportT as input arguments.");
 
    const Epetra_IntVector &v = *tDest.getEpetra_IntVector();
    int err                   = vec_->Import(v, *tImporter.getEpetra_Import(), toEpetra(CM));
    TEUCHOS_TEST_FOR_EXCEPTION(err != 0, std::runtime_error, "Catch error code returned by Epetra.");
  }
 
  void doImport(const DistObject<int, LocalOrdinal, GlobalOrdinal, Node> &source,
                const Export<int, GlobalOrdinal, Node> &exporter, CombineMode CM) {
    XPETRA_MONITOR("EpetraIntVectorT::doImport");
 
    XPETRA_DYNAMIC_CAST(const EpetraIntVectorT<GlobalOrdinal XPETRA_COMMA Node>, source, tSource, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraIntVectorT as input arguments.");
    XPETRA_DYNAMIC_CAST(const EpetraExportT<GlobalOrdinal XPETRA_COMMA Node>, exporter, tExporter, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraImportT as input arguments.");
 
    const Epetra_IntVector &v = *tSource.getEpetra_IntVector();
    int err                   = vec_->Import(v, *tExporter.getEpetra_Export(), toEpetra(CM));
    TEUCHOS_TEST_FOR_EXCEPTION(err != 0, std::runtime_error, "Catch error code returned by Epetra.");
  }
 
  void doExport(const DistObject<int, LocalOrdinal, GlobalOrdinal, Node> &dest,
                const Export<int, GlobalOrdinal, Node> &exporter, CombineMode CM) {
    XPETRA_MONITOR("EpetraIntVectorT::doExport");
 
    XPETRA_DYNAMIC_CAST(const EpetraIntVectorT<GlobalOrdinal XPETRA_COMMA Node>, dest, tDest, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraIntVectorT as input arguments.");
    XPETRA_DYNAMIC_CAST(const EpetraExportT<GlobalOrdinal XPETRA_COMMA Node>, exporter, tExporter, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraImportT as input arguments.");
 
    const Epetra_IntVector &v = *tDest.getEpetra_IntVector();
    int err                   = vec_->Export(v, *tExporter.getEpetra_Export(), toEpetra(CM));
    TEUCHOS_TEST_FOR_EXCEPTION(err != 0, std::runtime_error, "Catch error code returned by Epetra.");
  }
 
  void replaceMap(const RCP<const Map<int, GlobalOrdinal, Node> > & /* map */) {
    // do nothing
  }
 
 protected:
  virtual void
  assign(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &rhs) {
    typedef EpetraIntVectorT<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::EpetraIntVectorT "
        "(which means it wraps an Epetra_IntVector), but the RHS has some "
        "other type.  This probably means that the RHS wraps either an "
        "Tpetra::MultiVector, or an Epetra_MultiVector.  Xpetra::MultiVector "
        "does not currently implement assignment from a Tpetra object to an "
        "Epetra object, though this could be added with sufficient interest.");
 
    RCP<const Epetra_IntVector> rhsImpl = rhsPtr->getEpetra_IntVector();
    RCP<Epetra_IntVector> lhsImpl       = this->getEpetra_IntVector();
 
    TEUCHOS_TEST_FOR_EXCEPTION(
        rhsImpl.is_null(), std::logic_error,
        "Xpetra::MultiVector::operator= "
        "(in Xpetra::EpetraIntVectorT::assign): *this (the right-hand side of "
        "the assignment) has a null RCP<Epetra_IntVector> inside.  Please "
        "report this bug to the Xpetra developers.");
    TEUCHOS_TEST_FOR_EXCEPTION(
        lhsImpl.is_null(), std::logic_error,
        "Xpetra::MultiVector::operator= "
        "(in Xpetra::EpetraIntVectorT::assign): The left-hand side of the "
        "assignment has a null RCP<Epetra_IntVector> inside.  Please report "
        "this bug to the Xpetra developers.");
 
    // Epetra_IntVector's assignment operator does a deep copy.
    *lhsImpl = *rhsImpl;
  }
 
 private:
  RCP<Epetra_IntVector> vec_;
};
#endif
 
// specialization on GO=long long and Node=Serial
#ifndef XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES
template <>
class EpetraIntVectorT<long long, EpetraNode>
  : public virtual Vector<int, int, long long, EpetraNode> {
  typedef int Scalar;
  typedef int LocalOrdinal;
  typedef long long GlobalOrdinal;
  typedef EpetraNode Node;
 
 public:
 
 
  explicit EpetraIntVectorT(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node> > &map, bool zeroOut = true) {
    vec_ = rcp(new Epetra_IntVector(toEpetra<GlobalOrdinal, Node>(map), zeroOut));
  }
 
  ~EpetraIntVectorT(){};
 
 
 
 
  int dot(const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> & /* a */) const {
    XPETRA_MONITOR("EpetraIntVectorT::dot");
    TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::NotImplemented, "TODO"); /* return -1; */
  }
 
  Teuchos::ScalarTraits<int>::magnitudeType norm1() const {
    XPETRA_MONITOR("EpetraIntVectorT::norm1");
    TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::NotImplemented, "TODO"); /* return -1; */
  }
 
  Teuchos::ScalarTraits<int>::magnitudeType norm2() const {
    XPETRA_MONITOR("EpetraIntVectorT::norm2");
    TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::NotImplemented, "TODO"); /* return -1; */
  }
 
  Teuchos::ScalarTraits<int>::magnitudeType normInf() const {
    XPETRA_MONITOR("EpetraIntVectorT::normInf");
    TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::NotImplemented, "TODO"); /* return -1; */
  }
 
  int meanValue() const {
    XPETRA_MONITOR("EpetraIntVectorT::meanValue");
    TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::NotImplemented, "TODO"); /* return -1; */
  }
 
  int maxValue() const {
    XPETRA_MONITOR("EpetraIntVectorT::maxValue");
    return Teuchos::as<int>(vec_->MaxValue());
  }
 
 
 
 
  void replaceGlobalValue(GlobalOrdinal /* globalRow */, const Scalar & /* value */) {
    XPETRA_MONITOR("EpetraIntVectorT::replaceGlobalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void sumIntoGlobalValue(GlobalOrdinal /* globalRow */, const Scalar & /* value */) {
    XPETRA_MONITOR("EpetraIntVectorT::sumIntoGlobalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void replaceLocalValue(LocalOrdinal myRow, const Scalar &value) {
    XPETRA_MONITOR("EpetraIntVectorT::replaceLocalValue");
    (*vec_)[myRow] = value;
  }
 
  void sumIntoLocalValue(LocalOrdinal myRow, const Scalar &value) {
    XPETRA_MONITOR("EpetraIntVectorT::sumIntoLocalValue");
    (*vec_)[myRow] += value;
  }
 
  void putScalar(const int &value) { vec_->PutValue(value); }
 
  void randomize(bool /* bUseXpetraImplementation */ = true) {
    XPETRA_MONITOR("EpetraIntVectorT::randomize");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Xpetra::EpetraIntVectorT::randomize(): Functionnality not available in Epetra");
  }
 
  void randomize(const Scalar & /*minVal*/, const Scalar & /*maxVal*/, bool /* bUseXpetraImplementation */ = true) {
    XPETRA_MONITOR("EpetraIntVectorT::randomize");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Xpetra::EpetraIntVectorT::randomize(): Functionnality not available in Epetra");
  }
 
 
  void setSeed(unsigned int /* seed */) {
    XPETRA_MONITOR("EpetraIntVectorT::setSeed");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Xpetra::EpetraIntVectorT::setSeed(): Functionnality not available in Epetra");
  }
 
 
 
 
  Teuchos::RCP<const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > getVector(size_t /* j */) const {
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  Teuchos::RCP<Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > getVectorNonConst(size_t /* j */) {
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  Teuchos::ArrayRCP<const int> getData(size_t /* j */) const {
    XPETRA_MONITOR("EpetraIntVectorT::getData");
 
    int *data       = vec_->Values();
    int localLength = vec_->MyLength();
 
    return ArrayRCP<int>(data, 0, localLength, false);  // not ownership
  }
 
  Teuchos::ArrayRCP<int> getDataNonConst(size_t /* j */) {
    XPETRA_MONITOR("EpetraIntVectorT::getDataNonConst");
 
    int *data       = vec_->Values();
    int localLength = vec_->MyLength();
 
    return ArrayRCP<int>(data, 0, localLength, false);  // not ownership
  }
 
 
 
 
  void dot(const MultiVector<int, int, GlobalOrdinal, Node> & /* A */, const Teuchos::ArrayView<int> & /* dots */) const {
    XPETRA_MONITOR("EpetraIntVectorT::dot");
 
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, A, eA, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void abs(const MultiVector<int, int, GlobalOrdinal, Node> & /* A */) {
    XPETRA_MONITOR("EpetraIntVectorT::abs");
 
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, A, eA, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void reciprocal(const MultiVector<int, int, GlobalOrdinal, Node> & /* A */) {
    XPETRA_MONITOR("EpetraIntVectorT::reciprocal");
 
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, A, eA, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void scale(const int & /* alpha */) {
    XPETRA_MONITOR("EpetraIntVectorT::scale");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void scale(Teuchos::ArrayView<const int> /* alpha */) {
    XPETRA_MONITOR("EpetraIntVectorT::scale");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void update(const int & /* alpha */, const MultiVector<int, int, GlobalOrdinal, Node> & /* A */, const int & /* beta */) {
    XPETRA_MONITOR("EpetraIntVectorT::update");
 
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, A, eA, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void update(const int & /* alpha */, const MultiVector<int, int, GlobalOrdinal, Node> & /* A */, const int & /* beta */, const MultiVector<int, int, GlobalOrdinal, Node> & /* B */, const int & /* gamma */) {
    XPETRA_MONITOR("EpetraIntVectorT::update");
 
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, A, eA, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    // XPETRA_DYNAMIC_CAST(const EpetraMultiVectorT, B, eB, "This Xpetra::EpetraMultiVectorT method only accept Xpetra::EpetraMultiVectorT as input arguments.");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void norm1(const Teuchos::ArrayView<Teuchos::ScalarTraits<int>::magnitudeType> & /* norms */) const {
    XPETRA_MONITOR("EpetraIntVectorT::norm1");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void norm2(const Teuchos::ArrayView<Teuchos::ScalarTraits<int>::magnitudeType> & /* norms */) const {
    XPETRA_MONITOR("EpetraIntVectorT::norm2");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void normInf(const Teuchos::ArrayView<Teuchos::ScalarTraits<int>::magnitudeType> & /* norms */) const {
    XPETRA_MONITOR("EpetraIntVectorT::normInf");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void meanValue(const Teuchos::ArrayView<int> & /* means */) const {
    XPETRA_MONITOR("EpetraIntVectorT::meanValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void maxValue(const Teuchos::ArrayView<int> & /* maxs */) const {
    XPETRA_MONITOR("EpetraIntVectorT::maxValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void multiply(Teuchos::ETransp /* transA */, Teuchos::ETransp /* transB */, const int & /* alpha */, const MultiVector<int, int, GlobalOrdinal, Node> & /* A */, const MultiVector<int, int, GlobalOrdinal, Node> & /* B */, const int & /* beta */) {
    XPETRA_MONITOR("EpetraIntVectorT::multiply");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Not available in Epetra");
  }
 
  void elementWiseMultiply(int /* scalarAB */, const Vector<int, int, GlobalOrdinal, Node> & /* A */, const MultiVector<int, int, GlobalOrdinal, Node> & /* B */, int /* scalarThis */) {
    XPETRA_MONITOR("EpetraIntVectorT::elementWiseMultiply");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "Xpetra_EpetraIntVector: elementWiseMultiply not implemented because Epetra_IntVector does not support this operation");
  }
 
 
 
 
  void replaceGlobalValue(GlobalOrdinal /* globalRow */, size_t /* vectorIndex */, const Scalar & /* value */) {
    XPETRA_MONITOR("EpetraIntVectorT::replaceGlobalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void sumIntoGlobalValue(GlobalOrdinal /* globalRow */, size_t /* vectorIndex */, const Scalar & /* value */) {
    XPETRA_MONITOR("EpetraIntVectorT::sumIntoGlobalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void replaceLocalValue(LocalOrdinal /* myRow */, size_t /* vectorIndex */, const Scalar & /* value */) {
    XPETRA_MONITOR("EpetraIntVectorT::replaceLocalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
  void sumIntoLocalValue(LocalOrdinal /* myRow */, size_t /* vectorIndex */, const Scalar & /* value */) {
    XPETRA_MONITOR("EpetraIntVectorT::sumIntoLocalValue");
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO");
  }
 
 
 
 
  size_t getNumVectors() const {
    XPETRA_MONITOR("EpetraIntVectorT::getNumVectors");
    return 1;
  }
 
  size_t getLocalLength() const { return vec_->MyLength(); }
 
  global_size_t getGlobalLength() const { return vec_->GlobalLength64(); }
 
  bool isSameSize(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &vec) const {
    XPETRA_MONITOR("EpetraIntVectorT::isSameSize");
    const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> *asvec = dynamic_cast<const Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> *>(&vec);
    if (!asvec) return false;
    auto vv = toEpetra(*asvec);
    return ((vec_->MyLength() == vv.MyLength()) && (getNumVectors() == vec.getNumVectors()));
  }
 
 
 
  std::string description() const {
    XPETRA_MONITOR("EpetraIntVectorT::description");
 
    // This implementation come from Epetra_Vector_def.hpp (without modification)
    std::ostringstream oss;
    oss << Teuchos::Describable::description();
    oss << "{length=" << this->getGlobalLength()
        << "}";
    return oss.str();
  }
 
  void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel = Teuchos::Describable::verbLevel_default) const {
    XPETRA_MONITOR("EpetraIntVectorT::describe");
 
    // This implementation come from Tpetra_Vector_def.hpp (without modification) // JG: true?
    using std::endl;
    using std::setw;
    using Teuchos::VERB_DEFAULT;
    using Teuchos::VERB_EXTREME;
    using Teuchos::VERB_HIGH;
    using Teuchos::VERB_LOW;
    using Teuchos::VERB_MEDIUM;
    using Teuchos::VERB_NONE;
 
    if (verbLevel > Teuchos::VERB_NONE)
      vec_->Print(out);
  }
 
 
  RCP<Epetra_IntVector> getEpetra_IntVector() const { return vec_; }
 
  const RCP<const Comm<int> > getComm() const {
    TEUCHOS_TEST_FOR_EXCEPTION(1, Xpetra::Exceptions::NotImplemented, "TODO getComm Epetra MultiVector not implemented");
  }
 
  // Implementing DistObject
  Teuchos::RCP<const Map<int, GlobalOrdinal, Node> > getMap() const {
    RCP<const Epetra_BlockMap> map = rcp(new Epetra_BlockMap(vec_->Map()));
    return rcp(new Xpetra::EpetraMapT<GlobalOrdinal, Node>(map));
  }
 
  void doImport(const DistObject<int, int, GlobalOrdinal, Node> &source,
                const Import<int, GlobalOrdinal, Node> &importer, CombineMode CM) {
    XPETRA_MONITOR("EpetraIntVectorT::doImport");
 
    XPETRA_DYNAMIC_CAST(const EpetraIntVectorT<GlobalOrdinal XPETRA_COMMA Node>, source, tSource, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraIntVectorT as input arguments.");
    XPETRA_DYNAMIC_CAST(const EpetraImportT<GlobalOrdinal XPETRA_COMMA Node>, importer, tImporter, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraImportT as input arguments.");
 
    const Epetra_IntVector &v = *tSource.getEpetra_IntVector();
    int err                   = vec_->Import(v, *tImporter.getEpetra_Import(), toEpetra(CM));
    TEUCHOS_TEST_FOR_EXCEPTION(err != 0, std::runtime_error, "Catch error code returned by Epetra.");
  }
 
  void doExport(const DistObject<int, LocalOrdinal, GlobalOrdinal, Node> &dest,
                const Import<int, GlobalOrdinal, Node> &importer, CombineMode CM) {
    XPETRA_MONITOR("EpetraIntVectorT::doExport");
 
    XPETRA_DYNAMIC_CAST(const EpetraIntVectorT<GlobalOrdinal XPETRA_COMMA Node>, dest, tDest, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraIntVectorT as input arguments.");
    XPETRA_DYNAMIC_CAST(const EpetraImportT<GlobalOrdinal XPETRA_COMMA Node>, importer, tImporter, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraImportT as input arguments.");
 
    const Epetra_IntVector &v = *tDest.getEpetra_IntVector();
    int err                   = vec_->Import(v, *tImporter.getEpetra_Import(), toEpetra(CM));
    TEUCHOS_TEST_FOR_EXCEPTION(err != 0, std::runtime_error, "Catch error code returned by Epetra.");
  }
 
  void doImport(const DistObject<int, LocalOrdinal, GlobalOrdinal, Node> &source,
                const Export<int, GlobalOrdinal, Node> &exporter, CombineMode CM) {
    XPETRA_MONITOR("EpetraIntVectorT::doImport");
 
    XPETRA_DYNAMIC_CAST(const EpetraIntVectorT<GlobalOrdinal XPETRA_COMMA Node>, source, tSource, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraIntVectorT as input arguments.");
    XPETRA_DYNAMIC_CAST(const EpetraExportT<GlobalOrdinal XPETRA_COMMA Node>, exporter, tExporter, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraImportT as input arguments.");
 
    const Epetra_IntVector &v = *tSource.getEpetra_IntVector();
    int err                   = vec_->Import(v, *tExporter.getEpetra_Export(), toEpetra(CM));
    TEUCHOS_TEST_FOR_EXCEPTION(err != 0, std::runtime_error, "Catch error code returned by Epetra.");
  }
 
  void doExport(const DistObject<int, LocalOrdinal, GlobalOrdinal, Node> &dest,
                const Export<int, GlobalOrdinal, Node> &exporter, CombineMode CM) {
    XPETRA_MONITOR("EpetraIntVectorT::doExport");
 
    XPETRA_DYNAMIC_CAST(const EpetraIntVectorT<GlobalOrdinal XPETRA_COMMA Node>, dest, tDest, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraIntVectorT as input arguments.");
    XPETRA_DYNAMIC_CAST(const EpetraExportT<GlobalOrdinal XPETRA_COMMA Node>, exporter, tExporter, "Xpetra::EpetraIntVectorT::doImport only accept Xpetra::EpetraImportT as input arguments.");
 
    const Epetra_IntVector &v = *tDest.getEpetra_IntVector();
    int err                   = vec_->Export(v, *tExporter.getEpetra_Export(), toEpetra(CM));
    TEUCHOS_TEST_FOR_EXCEPTION(err != 0, std::runtime_error, "Catch error code returned by Epetra.");
  }
 
  void replaceMap(const RCP<const Map<int, GlobalOrdinal, Node> > & /* map */) {
    // do nothing
  }
 
 protected:
  virtual void
  assign(const MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> &rhs) {
    typedef EpetraIntVectorT<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::EpetraIntVectorT "
        "(which means it wraps an Epetra_IntVector), but the RHS has some "
        "other type.  This probably means that the RHS wraps either an "
        "Tpetra::MultiVector, or an Epetra_MultiVector.  Xpetra::MultiVector "
        "does not currently implement assignment from a Tpetra object to an "
        "Epetra object, though this could be added with sufficient interest.");
 
    RCP<const Epetra_IntVector> rhsImpl = rhsPtr->getEpetra_IntVector();
    RCP<Epetra_IntVector> lhsImpl       = this->getEpetra_IntVector();
 
    TEUCHOS_TEST_FOR_EXCEPTION(
        rhsImpl.is_null(), std::logic_error,
        "Xpetra::MultiVector::operator= "
        "(in Xpetra::EpetraIntVectorT::assign): *this (the right-hand side of "
        "the assignment) has a null RCP<Epetra_IntVector> inside.  Please "
        "report this bug to the Xpetra developers.");
    TEUCHOS_TEST_FOR_EXCEPTION(
        lhsImpl.is_null(), std::logic_error,
        "Xpetra::MultiVector::operator= "
        "(in Xpetra::EpetraIntVectorT::assign): The left-hand side of the "
        "assignment has a null RCP<Epetra_IntVector> inside.  Please report "
        "this bug to the Xpetra developers.");
 
    // Epetra_IntVector's assignment operator does a deep copy.
    *lhsImpl = *rhsImpl;
  }
 
 private:
  RCP<Epetra_IntVector> vec_;
};
#endif
 
}  // namespace Xpetra
 
#endif  // XPETRA_EPETRAINTVECTOR_HPP