//-----------------------------------------------------------------------------
void TpetraVector::get_local(std::vector<double>& values) const
{
dolfin_assert(!_x.is_null());
values.resize(local_size());
Teuchos::ArrayRCP<const double> arr = _x->getData(0);
std::copy(arr.get(), arr.get() + values.size(), values.begin());
}
//-----------------------------------------------------------------------------
double TpetraVector::max() const
{
dolfin_assert(!_x.is_null());
Teuchos::ArrayRCP<const double> arr = _x->getData(0);
double max_local = *std::max_element(arr.get(), arr.get() + arr.size());
return MPI::max(mpi_comm(), max_local);
}
//-----------------------------------------------------------------------------
void TpetraVector::gather_on_zero(std::vector<double>& v) const
{
dolfin_assert(!_x.is_null());
if (_x->getMap()->getComm()->getRank() == 0)
v.resize(size());
else
v.resize(0);
// Create map with elements only on process zero
Teuchos::RCP<map_type> ymap(new map_type(size(), v.size(), 0,
_x->getMap()->getComm()));
Teuchos::RCP<vector_type> y(new vector_type(ymap, 1));
// Export from vector x to vector y
Tpetra::Export<vector_type::local_ordinal_type,
vector_type::global_ordinal_type,
vector_type::node_type> exporter(_x->getMap(), ymap);
y->doExport(*_x, exporter, Tpetra::INSERT);
Teuchos::ArrayRCP<const double> yarr = y->getData(0);
std::copy(yarr.get(), yarr.get() + v.size(), v.begin());
}
void DiscreteBoundaryOperator<ValueType>::applyImpl(
const Thyra::EOpTransp M_trans,
const Thyra::MultiVectorBase<ValueType> &X_in,
const Teuchos::Ptr<Thyra::MultiVectorBase<ValueType>> &Y_inout,
const ValueType alpha, const ValueType beta) const {
typedef Thyra::Ordinal Ordinal;
// Note: the name is VERY misleading: these asserts don't disappear in
// release runs, and in case of failure throw exceptions rather than
// abort.
TEUCHOS_ASSERT(this->opSupported(M_trans));
TEUCHOS_ASSERT(X_in.range()->isCompatible(*this->domain()));
TEUCHOS_ASSERT(Y_inout->range()->isCompatible(*this->range()));
TEUCHOS_ASSERT(Y_inout->domain()->isCompatible(*X_in.domain()));
const Ordinal colCount = X_in.domain()->dim();
// Loop over the input columns
for (Ordinal col = 0; col < colCount; ++col) {
// Get access the the elements of X_in's and Y_inout's column #col
Thyra::ConstDetachedSpmdVectorView<ValueType> xVec(X_in.col(col));
Thyra::DetachedSpmdVectorView<ValueType> yVec(Y_inout->col(col));
const Teuchos::ArrayRCP<const ValueType> xArray(xVec.sv().values());
const Teuchos::ArrayRCP<ValueType> yArray(yVec.sv().values());
// Wrap the Trilinos array in an Armadillo vector. const_cast is used
// because it's more natural to have a const arma::Col<ValueType> array
// than an arma::Col<const ValueType> one.
const arma::Col<ValueType> xCol(const_cast<ValueType *>(xArray.get()),
xArray.size(), false /* copy_aux_mem */);
arma::Col<ValueType> yCol(yArray.get(), yArray.size(), false);
applyBuiltInImpl(static_cast<TranspositionMode>(M_trans), xCol, yCol, alpha,
beta);
}
}
//-----------------------------------------------------------------------------
void TpetraVector::set_local(const std::vector<double>& values)
{
dolfin_assert(!_x.is_null());
const std::size_t num_values = local_size();
if (values.size() != num_values)
{
dolfin_error("TpetraVector.cpp",
"set local values of Tpetra vector",
"Size of values array is not equal to local vector size");
}
if (num_values == 0)
return;
Teuchos::ArrayRCP<double> arr = _x->getDataNonConst(0);
std::copy(values.begin(), values.end(), arr.get());
}