docs/xpetra/Xpetra__BlockedVector__def_8hpp_source.html

// @HEADER

// *****************************************************************************

//             Xpetra: A linear algebra interface package

//

// Copyright 2012 NTESS and the Xpetra contributors.

// SPDX-License-Identifier: BSD-3-Clause

// *****************************************************************************

// @HEADER


#ifndef XPETRA_BLOCKEDVECTOR_DEF_HPP

#define XPETRA_BLOCKEDVECTOR_DEF_HPP


#include "Xpetra_BlockedVector_decl.hpp"


#include "Xpetra_BlockedMultiVector.hpp"

#include "Xpetra_Exceptions.hpp"


namespace Xpetra {


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    BlockedVector(const Teuchos::RCP<const Xpetra::BlockedMap<LocalOrdinal, GlobalOrdinal, Node>>& map, bool zeroOut)

  : Xpetra::BlockedMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(map, 1, zeroOut) {}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    BlockedVector(Teuchos::RCP<const Xpetra::BlockedMap<LocalOrdinal, GlobalOrdinal, Node>> bmap,

                  Teuchos::RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> v)

  : Xpetra::BlockedMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(bmap, v) {}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    BlockedVector(Teuchos::RCP<const Xpetra::MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node>> mapExtractor,

                  Teuchos::RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> v)

  : Xpetra::BlockedMultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>(mapExtractor, v) {}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    ~BlockedVector() {}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>&


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

operator=(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& rhs) {

  assign(rhs);  // dispatch to protected virtual method

  return *this;

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

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

  BlockedMultiVector::replaceGlobalValue(globalRow, vectorIndex, value);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

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

  BlockedMultiVector::sumIntoGlobalValue(globalRow, vectorIndex, value);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

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

  BlockedMultiVector::replaceLocalValue(myRow, vectorIndex, value);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

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

  BlockedMultiVector::sumIntoLocalValue(myRow, vectorIndex, value);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    replaceGlobalValue(GlobalOrdinal globalRow, const Scalar& value) {

  BlockedMultiVector::replaceGlobalValue(globalRow, 0, value);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    sumIntoGlobalValue(GlobalOrdinal globalRow, const Scalar& value) {

  BlockedMultiVector::sumIntoGlobalValue(globalRow, 0, value);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    replaceLocalValue(LocalOrdinal myRow, const Scalar& value) {

  BlockedMultiVector::replaceLocalValue(myRow, 0, value);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    sumIntoLocalValue(LocalOrdinal myRow, const Scalar& value) {

  BlockedMultiVector::sumIntoLocalValue(myRow, 0, value);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    putScalar(const Scalar& value) {

  BlockedMultiVector::putScalar(value);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

Teuchos::RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    getVector(size_t j) const {

  return BlockedMultiVector::getVector(j);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

Teuchos::RCP<Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    getVectorNonConst(size_t j) {

  return BlockedMultiVector::getVectorNonConst(j);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

Teuchos::ArrayRCP<const Scalar>


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    getData(size_t j) const {

  return BlockedMultiVector::getData(j);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

Teuchos::ArrayRCP<Scalar>


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    getDataNonConst(size_t j) {

  return BlockedMultiVector::getDataNonConst(j);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    dot(const MultiVector& A, const Teuchos::ArrayView<Scalar>& dots) const {

  BlockedMultiVector::dot(A, dots);

  return;

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

Scalar


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    dot(const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A) const {

  Teuchos::Array<Scalar> dots = Teuchos::Array<Scalar>(1);

  BlockedMultiVector::dot(A, dots);

  return dots[0];

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    abs(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A) {

  BlockedMultiVector::abs(A);

  return;

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    reciprocal(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A) {

  BlockedMultiVector::reciprocal(A);

  return;

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    scale(const Scalar& alpha) {

  BlockedMultiVector::scale(alpha);

  return;

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

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

  BlockedMultiVector::scale(alpha);

  return;

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    update(const Scalar& alpha,

           const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A,

           const Scalar& beta) {

  BlockedMultiVector::update(alpha, A, beta);

  return;

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    update(const Scalar& alpha,

           const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A,

           const Scalar& beta,

           const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& B,

           const Scalar& gamma) {

  BlockedMultiVector::update(alpha, A, beta, B, gamma);

  return;

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

typename Teuchos::ScalarTraits<Scalar>::magnitudeType


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    norm1() const {

  using Array = Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>;

  Array norm  = Array(1);

  this->norm1(norm);

  return norm[0];

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

typename Teuchos::ScalarTraits<Scalar>::magnitudeType


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    norm2() const {

  Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> norm =

      Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>(1);

  this->norm2(norm);

  return norm[0];

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

typename Teuchos::ScalarTraits<Scalar>::magnitudeType


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    normInf() const {

  Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>

      norm = Teuchos::Array<typename Teuchos::ScalarTraits<Scalar>::magnitudeType>(1);

  this->normInf(norm);

  return norm[0];

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

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

  BlockedMultiVector::norm1(norms);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

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

  BlockedMultiVector::norm2(norms);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

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

  BlockedMultiVector::normInf(norms);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    meanValue(const Teuchos::ArrayView<Scalar>& /* means */) const {

  throw Xpetra::Exceptions::RuntimeError("BlockedVector::meanValue: Not (yet) supported by BlockedVector.");

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

Scalar


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    meanValue() const {

  throw Xpetra::Exceptions::RuntimeError("BlockedVector::meanValue: Not (yet) supported by BlockedVector.");

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    multiply(Teuchos::ETransp /* transA */,

             Teuchos::ETransp /* transB */,

             const Scalar& /* alpha */,

             const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* A */,

             const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* B */,

             const Scalar& /* beta */) {

  throw Xpetra::Exceptions::RuntimeError("BlockedVector::multiply: Not (yet) supported by BlockedVector.");

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    multiply(Teuchos::ETransp /* transA */,

             Teuchos::ETransp /* transB */,

             const Scalar& /* alpha */,

             const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* A */,

             const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* B */,

             const Scalar& /* beta */) {

  throw Xpetra::Exceptions::RuntimeError("BlockedVector::multiply: Not (yet) supported by BlockedVector.");

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    elementWiseMultiply(Scalar /* scalarAB */,

                        const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* A */,

                        const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* B */,

                        Scalar /* scalarThis */) {

  throw Xpetra::Exceptions::RuntimeError("BlockedVector::elementWiseMultiply: Not (yet) supported by BlockedVector.");

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    elementWiseMultiply(Scalar /* scalarAB */,

                        const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& A,

                        const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& B,

                        Scalar /* scalarThis */) {

  XPETRA_TEST_FOR_EXCEPTION(B.getMap()->isSameAs(*(this->getMap())) == false,

                            Xpetra::Exceptions::RuntimeError,

                            "BlockedVector::elementWiseMultipy: B must have same blocked map than this.");

  TEUCHOS_TEST_FOR_EXCEPTION(A.getMap()->getLocalNumElements() != B.getMap()->getLocalNumElements(),

                             Xpetra::Exceptions::RuntimeError,

                             "BlockedVector::elementWiseMultipy: A has "

                                 << A.getMap()->getLocalNumElements() << " elements, B has " << B.getMap()->getLocalNumElements()

                                 << ".");

  TEUCHOS_TEST_FOR_EXCEPTION(A.getMap()->getGlobalNumElements() != B.getMap()->getGlobalNumElements(),

                             Xpetra::Exceptions::RuntimeError,

                             "BlockedVector::elementWiseMultipy: A has " << A.getMap()->getGlobalNumElements()

                                                                         << " elements, B has "

                                                                         << B.getMap()->getGlobalNumElements() << ".");


  RCP<const BlockedMap> bmap                                                 = this->getBlockedMap();

  RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> rcpA  = Teuchos::rcpFromRef(A);

  RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> bmvec = Teuchos::rcpFromRef(B);

  RCP<const BlockedVector> bbmvec                                            = Teuchos::rcp_dynamic_cast<const BlockedVector>(bmvec);

  TEUCHOS_TEST_FOR_EXCEPTION(bbmvec.is_null() == true,

                             Xpetra::Exceptions::RuntimeError,

                             "BlockedVector::elementWiseMultipy: B must be a BlockedVector.");


  // TODO implement me

  /*RCP<Xpetra::MapExtractor<Scalar,LocalOrdinal,GlobalOrdinal,Node> > me = Teuchos::rcp(new

  Xpetra::MapExtractor<Scalar,LocalOrdinal,GlobalOrdinal,Node>(bmap));


  for(size_t m = 0; m < bmap->getNumMaps(); m++) {

    // TODO introduce BlockedVector objects and "skip" this expensive ExtractVector call

    RCP<const Xpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> > pd = me->ExtractVector(rcpA,m,bmap->getThyraMode());

    XPETRA_TEST_FOR_EXCEPTION(pd->getMap()->isSameAs(*(this->getBlockedMap()->getMap(m,bmap->getThyraMode())))==false,

  Xpetra::Exceptions::RuntimeError, "BlockedVector::elementWiseMultipy: sub map of B does not fit with sub map of this.");

    this->getMultiVector(m,bmap->getThyraMode())->elementWiseMultiply(scalarAB,*pd,*(bbmvec->getMultiVector(m,bmap->getThyraMode())),scalarThis);

  }*/

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

size_t


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    getNumVectors() const {

  return 1;

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

size_t


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    getLocalLength() const {

  throw Xpetra::Exceptions::RuntimeError(

      "BlockedVector::getLocalLength: routine not implemented. It has no value as one must iterate on the partial vectors.");

  TEUCHOS_UNREACHABLE_RETURN(0);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

global_size_t


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    getGlobalLength() const {

  return this->getBlockedMap()->getFullMap()->getGlobalNumElements();

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


bool BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    isSameSize(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* vec */) const {

  throw Xpetra::Exceptions::RuntimeError(

      "BlockedVector::isSameSize: routine not implemented. It has no value as one must iterate on the partial vectors.");

  TEUCHOS_UNREACHABLE_RETURN(0);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

std::string


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    description() const {

  return std::string("BlockedVector");

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    describe(Teuchos::FancyOStream& out, const Teuchos::EVerbosityLevel verbLevel) const {

  out << description() << std::endl;

  for (size_t r = 0; r < this->getBlockedMap()->getNumMaps(); r++) {

    getMultiVector(r)->describe(out, verbLevel);

  }

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    replaceMap(const RCP<const Map>& map) {

  BlockedMultiVector::replaceMap(map);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    doImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* source */,

             const Import& /* importer */,

             CombineMode /* CM */) {

  throw Xpetra::Exceptions::RuntimeError("BlockedVector::doImport: Not supported by BlockedVector.");

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    doExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* dest */,

             const Import& /* importer */,

             CombineMode /* CM */) {

  throw Xpetra::Exceptions::RuntimeError("BlockedVector::doExport: Not supported by BlockedVector.");

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    doImport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* source */,

             const Export& /* exporter */,

             CombineMode /* CM */) {

  throw Xpetra::Exceptions::RuntimeError("BlockedVector::doImport: Not supported by BlockedVector.");

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    doExport(const DistObject<Scalar, LocalOrdinal, GlobalOrdinal, Node>& /* dest */,

             const Export& /* exporter */,

             CombineMode /* CM */) {

  throw Xpetra::Exceptions::RuntimeError("BlockedVector::doExport: Not supported by BlockedVector.");

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    setSeed(unsigned int seed) {

  for (size_t r = 0; r < this->getBlockedMap()->getNumMaps(); ++r) {

    getMultiVector(r)->setSeed(seed);

  }

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    randomize(bool bUseXpetraImplementation) {

  for (size_t r = 0; r < this->getBlockedMap()->getNumMaps(); ++r) {

    getMultiVector(r)->randomize(bUseXpetraImplementation);

  }

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    randomize(const Scalar& minVal, const Scalar& maxVal, bool bUseXpetraImplementation) {

  for (size_t r = 0; r < this->getBlockedMap()->getNumMaps(); ++r) {

    getMultiVector(r)->randomize(minVal, maxVal, bUseXpetraImplementation);

  }

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    Xpetra_randomize() {

  {

    Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Xpetra_randomize();

  }

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    Xpetra_randomize(const Scalar& minVal, const Scalar& maxVal) {

  {

    Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Xpetra_randomize(minVal, maxVal);

  }

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

Teuchos::RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>>


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    getMap() const {

  XPETRA_MONITOR("BlockedVector::getMap");

  return this->getBlockedMap();

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

Teuchos::RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    getMultiVector(size_t r) const {

  return BlockedMultiVector::getMultiVector(r);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

Teuchos::RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    getMultiVector(size_t r, bool bThyraMode) const {

  return BlockedMultiVector::getMultiVector(r, bThyraMode);

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    setMultiVector(size_t r,

                   Teuchos::RCP<const Xpetra::Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node>> v,

                   bool bThyraMode) {

  BlockedMultiVector::setMultiVector(r, v, bThyraMode);

  return;

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

Teuchos::RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>>


BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    Merge() const {

  return BlockedMultiVector::Merge();

}


template <class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>


void BlockedVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>::

    assign(const Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& rhs) {

  BlockedMultiVector::assign(rhs);

}


// template<class Scalar, class LocalOrdinal, class GlobalOrdinal, class Node>

// virtual void BlockedVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>::

// assign (const XpetrA::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node>& rhs)

// {

//     throw Xpetra::Exceptions::RuntimeError("BlockedVector::assign: Not supported by BlockedVector.");

// }


}  // namespace Xpetra


#endif  // XPETRA_BLOCKEDVECTOR_DEF_HPP

Xpetra_BlockedVector_decl.hpp

XPETRA_MONITOR
#define XPETRA_MONITOR(funcName)
Definition Xpetra_ConfigDefs.hpp:96

XPETRA_TEST_FOR_EXCEPTION
#define XPETRA_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Definition Xpetra_ConfigDefs.hpp:107

Xpetra_Exceptions.hpp

Teuchos::ArrayRCP

Teuchos::ArrayView

Teuchos::Array

Teuchos::RCP

Teuchos::RCP::is_null
bool is_null() const

Teuchos::basic_FancyOStream

Xpetra::BlockedMap
Definition Xpetra_BlockedMap_decl.hpp:23

Xpetra::BlockedMultiVector
Definition Xpetra_BlockedMultiVector_decl.hpp:38

Xpetra::BlockedMultiVector::putScalar
virtual void putScalar(const Scalar &value)
Set all values in the multivector with the given value.
Definition Xpetra_BlockedMultiVector_def.hpp:169

Xpetra::BlockedMultiVector::sumIntoLocalValue
virtual void sumIntoLocalValue(LocalOrdinal, size_t, const Scalar &)
Add value to existing value, using local (row) index.
Definition Xpetra_BlockedMultiVector_def.hpp:163

Xpetra::BlockedMultiVector::getData
virtual Teuchos::ArrayRCP< const Scalar > getData(size_t j) const
Const view of the local values in a particular vector of this multivector.
Definition Xpetra_BlockedMultiVector_def.hpp:203

Xpetra::BlockedMultiVector::getMultiVector
Teuchos::RCP< MultiVector > getMultiVector(size_t r) const
return partial multivector associated with block row r
Definition Xpetra_BlockedMultiVector_def.hpp:679

Xpetra::BlockedMultiVector::setMultiVector
void setMultiVector(size_t r, Teuchos::RCP< const MultiVector > v, bool bThyraMode)
set partial multivector associated with block row r
Definition Xpetra_BlockedMultiVector_def.hpp:705

Xpetra::BlockedMultiVector::getVector
virtual Teuchos::RCP< const Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getVector(size_t j) const
Return a Vector which is a const view of column j.
Definition Xpetra_BlockedMultiVector_def.hpp:179

Xpetra::BlockedMultiVector::getDataNonConst
virtual Teuchos::ArrayRCP< Scalar > getDataNonConst(size_t j)
View of the local values in a particular vector of this multivector.
Definition Xpetra_BlockedMultiVector_def.hpp:214

Xpetra::BlockedMultiVector::dot
virtual void dot(const MultiVector &, const Teuchos::ArrayView< Scalar > &) const
Compute dot product of each corresponding pair of vectors, dots[i] = this[i].dot(A[i]).
Definition Xpetra_BlockedMultiVector_def.hpp:224

Xpetra::BlockedMultiVector::reciprocal
virtual void reciprocal(const MultiVector &)
Put element-wise reciprocal values of input Multi-vector in target, this(i,j) = 1/A(i,...
Definition Xpetra_BlockedMultiVector_def.hpp:236

Xpetra::BlockedMultiVector::sumIntoGlobalValue
virtual void sumIntoGlobalValue(GlobalOrdinal, size_t, const Scalar &)
Add value to existing value, using global (row) index.
Definition Xpetra_BlockedMultiVector_def.hpp:151

Xpetra::BlockedMultiVector::replaceLocalValue
virtual void replaceLocalValue(LocalOrdinal, size_t, const Scalar &)
Replace value, using local (row) index.
Definition Xpetra_BlockedMultiVector_def.hpp:157

Xpetra::BlockedMultiVector::Merge
Teuchos::RCP< MultiVector > Merge() const
merge BlockedMultiVector blocks to a single MultiVector
Definition Xpetra_BlockedMultiVector_def.hpp:731

Xpetra::BlockedMultiVector::getVectorNonConst
virtual Teuchos::RCP< Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getVectorNonConst(size_t j)
Return a Vector which is a nonconst view of column j.
Definition Xpetra_BlockedMultiVector_def.hpp:194

Xpetra::BlockedMultiVector::replaceGlobalValue
virtual void replaceGlobalValue(GlobalOrdinal, size_t, const Scalar &)
Replace value, using global (row) index.
Definition Xpetra_BlockedMultiVector_def.hpp:145

Xpetra::BlockedMultiVector::norm2
virtual void norm2(const Teuchos::ArrayView< typename Teuchos::ScalarTraits< Scalar >::magnitudeType > &norms) const
Definition Xpetra_BlockedMultiVector_def.hpp:413

Xpetra::BlockedMultiVector::assign
virtual void assign(const MultiVector &rhs)
Implementation of the assignment operator (operator=); does a deep copy.
Definition Xpetra_BlockedMultiVector_def.hpp:754

Xpetra::BlockedMultiVector::scale
virtual void scale(const Scalar &alpha)
Scale the current values of a multi-vector, this = alpha*this.
Definition Xpetra_BlockedMultiVector_def.hpp:242

Xpetra::BlockedMultiVector::normInf
virtual void normInf(const Teuchos::ArrayView< typename Teuchos::ScalarTraits< Scalar >::magnitudeType > &norms) const
Compute Inf-norm of each vector in multi-vector.
Definition Xpetra_BlockedMultiVector_def.hpp:434

Xpetra::BlockedMultiVector::update
virtual void update(const Scalar &alpha, const MultiVector &A, const Scalar &beta)
Update multi-vector values with scaled values of A, this = beta*this + alpha*A.
Definition Xpetra_BlockedMultiVector_def.hpp:264

Xpetra::BlockedMultiVector::abs
virtual void abs(const MultiVector &)
Put element-wise absolute values of input Multi-vector in target: A = abs(this).
Definition Xpetra_BlockedMultiVector_def.hpp:230

Xpetra::BlockedMultiVector::norm1
virtual void norm1(const Teuchos::ArrayView< typename Teuchos::ScalarTraits< Scalar >::magnitudeType > &norms) const
Compute 1-norm of each vector in multi-vector.
Definition Xpetra_BlockedMultiVector_def.hpp:396

Xpetra::BlockedMultiVector::replaceMap
virtual void replaceMap(const RCP< const Map > &map)
Definition Xpetra_BlockedMultiVector_def.hpp:566

Xpetra::BlockedVector
Definition Xpetra_BlockedVector_decl.hpp:30

Xpetra::BlockedVector::multiply
virtual void multiply(Teuchos::ETransp, Teuchos::ETransp, const Scalar &, const Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, const Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, const Scalar &)
Matrix-matrix multiplication: this = beta*this + alpha*op(A)*op(B).
Definition Xpetra_BlockedVector_def.hpp:258

Xpetra::BlockedVector::Merge
Teuchos::RCP< Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > Merge() const
merge BlockedVector blocks to a single Vector
Definition Xpetra_BlockedVector_def.hpp:487

Xpetra::BlockedVector::getLocalLength
virtual size_t getLocalLength() const
Local number of rows on the calling process.
Definition Xpetra_BlockedVector_def.hpp:338

Xpetra::BlockedVector::replaceMap
virtual void replaceMap(const RCP< const Map > &map)
Definition Xpetra_BlockedVector_def.hpp:377

Xpetra::BlockedVector::description
virtual std::string description() const
A simple one-line description of this object.
Definition Xpetra_BlockedVector_def.hpp:362

Xpetra::BlockedVector::operator=
BlockedVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > & operator=(const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &rhs)
Assignment operator: Does a deep copy.
Definition Xpetra_BlockedVector_def.hpp:44

Xpetra::BlockedVector::Xpetra_randomize
virtual void Xpetra_randomize()
Set vector values to random numbers. XPetra implementation.
Definition Xpetra_BlockedVector_def.hpp:439

Xpetra::BlockedVector::getVector
virtual Teuchos::RCP< const Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getVector(size_t j) const
Return a Vector which is a const view of column j.
Definition Xpetra_BlockedVector_def.hpp:106

Xpetra::BlockedVector::getData
virtual Teuchos::ArrayRCP< const Scalar > getData(size_t j) const
Const view of the local values in a particular vector of this vector.
Definition Xpetra_BlockedVector_def.hpp:120

Xpetra::BlockedVector::randomize
virtual void randomize(bool bUseXpetraImplementation=false)
Set multi-vector values to random numbers.
Definition Xpetra_BlockedVector_def.hpp:423

Xpetra::BlockedVector::getMap
Teuchos::RCP< const Map > getMap() const
Access function for the underlying Map this DistObject was constructed with.
Definition Xpetra_BlockedVector_def.hpp:456

Xpetra::BlockedVector::dot
virtual void dot(const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &A, const Teuchos::ArrayView< Scalar > &dots) const
Compute dot product of each corresponding pair of vectors, dots[i] = this[i].dot(A[i]).
Definition Xpetra_BlockedVector_def.hpp:133

Xpetra::BlockedVector::norm2
virtual Teuchos::ScalarTraits< Scalar >::magnitudeType norm2() const
Compute 2-norm of vector.
Definition Xpetra_BlockedVector_def.hpp:208

Xpetra::BlockedVector::sumIntoLocalValue
virtual void sumIntoLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar &value)
Add value to existing value, using local (row) index.
Definition Xpetra_BlockedVector_def.hpp:69

Xpetra::BlockedVector::getVectorNonConst
virtual Teuchos::RCP< Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getVectorNonConst(size_t j)
Return a Vector which is a nonconst view of column j.
Definition Xpetra_BlockedVector_def.hpp:113

Xpetra::BlockedVector::setMultiVector
void setMultiVector(size_t r, Teuchos::RCP< const Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > v, bool bThyraMode)
set partial Vector associated with block row r
Definition Xpetra_BlockedVector_def.hpp:477

Xpetra::BlockedVector::reciprocal
virtual void reciprocal(const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &A)
Put element-wise reciprocal values of input vector in target, this(i,j) = 1/A(i,j).
Definition Xpetra_BlockedVector_def.hpp:156

Xpetra::BlockedVector::putScalar
virtual void putScalar(const Scalar &value)
Set all values in the vector with the given value.
Definition Xpetra_BlockedVector_def.hpp:99

Xpetra::BlockedVector::setSeed
virtual void setSeed(unsigned int seed)
Set seed for Random function.
Definition Xpetra_BlockedVector_def.hpp:415

Xpetra::BlockedVector::doExport
virtual void doExport(const DistObject< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, const Import &, CombineMode)
Export.
Definition Xpetra_BlockedVector_def.hpp:391

Xpetra::BlockedVector::BlockedVector
BlockedVector(const Teuchos::RCP< const BlockedMap > &map, bool zeroOut=true)
Constructor.
Definition Xpetra_BlockedVector_def.hpp:22

Xpetra::BlockedVector::norm1
virtual Teuchos::ScalarTraits< Scalar >::magnitudeType norm1() const
Compute 1-norm of vector.
Definition Xpetra_BlockedVector_def.hpp:198

Xpetra::BlockedVector::replaceLocalValue
virtual void replaceLocalValue(LocalOrdinal myRow, size_t vectorIndex, const Scalar &value)
Replace value, using local (row) index.
Definition Xpetra_BlockedVector_def.hpp:63

Xpetra::BlockedVector::describe
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel=Teuchos::Describable::verbLevel_default) const
Print the object with the given verbosity level to a FancyOStream.
Definition Xpetra_BlockedVector_def.hpp:368

Xpetra::BlockedVector::sumIntoGlobalValue
virtual void sumIntoGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar &value)
Add value to existing value, using global (row) index.
Definition Xpetra_BlockedVector_def.hpp:57

Xpetra::BlockedVector::scale
virtual void scale(const Scalar &alpha)
Scale the current values of a vector, this = alpha*this.
Definition Xpetra_BlockedVector_def.hpp:163

Xpetra::BlockedVector::replaceGlobalValue
virtual void replaceGlobalValue(GlobalOrdinal globalRow, size_t vectorIndex, const Scalar &value)
Replace value, using global (row) index.
Definition Xpetra_BlockedVector_def.hpp:51

Xpetra::BlockedVector::getDataNonConst
virtual Teuchos::ArrayRCP< Scalar > getDataNonConst(size_t j)
View of the local values in a particular vector of this vector.
Definition Xpetra_BlockedVector_def.hpp:127

Xpetra::BlockedVector::elementWiseMultiply
virtual void elementWiseMultiply(Scalar, const Xpetra::Vector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, Scalar)
Multiply a Vector A elementwise by a MultiVector B.
Definition Xpetra_BlockedVector_def.hpp:280

Xpetra::BlockedVector::getNumVectors
virtual size_t getNumVectors() const
Number of columns in the Vector.
Definition Xpetra_BlockedVector_def.hpp:331

Xpetra::BlockedVector::doImport
virtual void doImport(const DistObject< Scalar, LocalOrdinal, GlobalOrdinal, Node > &, const Import &, CombineMode)
Import.
Definition Xpetra_BlockedVector_def.hpp:383

Xpetra::BlockedVector::meanValue
virtual Scalar meanValue() const
Compute mean (average) value of this Vector.
Definition Xpetra_BlockedVector_def.hpp:252

Xpetra::BlockedVector::isSameSize
virtual bool isSameSize(const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &) const
Local number of rows on the calling process.
Definition Xpetra_BlockedVector_def.hpp:353

Xpetra::BlockedVector::update
virtual void update(const Scalar &alpha, const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &A, const Scalar &beta)
Update multi-vector values with scaled values of A, this = beta*this + alpha*A.
Definition Xpetra_BlockedVector_def.hpp:177

Xpetra::BlockedVector::getGlobalLength
virtual global_size_t getGlobalLength() const
Global number of rows in the Vector.
Definition Xpetra_BlockedVector_def.hpp:347

Xpetra::BlockedVector::assign
virtual void assign(const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &rhs)
Implementation of the assignment operator (operator=); does a deep copy.
Definition Xpetra_BlockedVector_def.hpp:493

Xpetra::BlockedVector::getMultiVector
Teuchos::RCP< Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > > getMultiVector(size_t r) const
return partial Vector associated with block row r
Definition Xpetra_BlockedVector_def.hpp:464

Xpetra::BlockedVector::~BlockedVector
virtual ~BlockedVector()
Destructor.
Definition Xpetra_BlockedVector_def.hpp:39

Xpetra::BlockedVector::normInf
virtual Teuchos::ScalarTraits< Scalar >::magnitudeType normInf() const
Compute Inf-norm in vector.
Definition Xpetra_BlockedVector_def.hpp:218

Xpetra::BlockedVector::abs
virtual void abs(const Xpetra::MultiVector< Scalar, LocalOrdinal, GlobalOrdinal, Node > &A)
Put element-wise absolute values of input vector in target: A = abs(this).
Definition Xpetra_BlockedVector_def.hpp:149

Xpetra::DistObject
Definition Xpetra_DistObject.hpp:29

Xpetra::DistObject::getMap
virtual Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > getMap() const =0
The Map describing the parallel distribution of this object.

Xpetra::Exceptions::RuntimeError
Exception throws to report errors in the internal logical of the program.
Definition Xpetra_Exceptions.hpp:65

Xpetra::Export
Definition Xpetra_Export.hpp:27

Xpetra::Import
Definition Xpetra_Import.hpp:27

Xpetra::MapExtractor
Definition Xpetra_MapExtractor_decl.hpp:47

Xpetra::MultiVector
Definition Xpetra_MultiVector_decl.hpp:45

Xpetra::MultiVector::Xpetra_randomize
virtual void Xpetra_randomize()
Set multi-vector values to random numbers. XPetra implementation.
Definition Xpetra_MultiVector_def.hpp:32

Xpetra::Vector
Definition Xpetra_Vector.hpp:25

TEUCHOS_TEST_FOR_EXCEPTION
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)

TEUCHOS_UNREACHABLE_RETURN
#define TEUCHOS_UNREACHABLE_RETURN(dummyReturnVal)

Teuchos::EVerbosityLevel
EVerbosityLevel

Teuchos::ETransp
ETransp

Xpetra
Xpetra namespace
Definition Xpetra_BlockedCrsMatrix_decl.hpp:52

Xpetra::global_size_t
size_t global_size_t
Global size_t object.
Definition Xpetra_ConfigDefs.hpp:138

Xpetra::CombineMode
CombineMode
Xpetra::Combine Mode enumerable type.
Definition Xpetra_ConfigDefs.hpp:176

Teuchos::ScalarTraits::magnitudeType
T magnitudeType