17#ifdef DEAL_II_WITH_TRILINOS
27# include <boost/io/ios_state.hpp>
29# include <Epetra_Export.h>
30# include <Epetra_Import.h>
31# include <Epetra_Vector.h>
53 vector.vector->Map().LID(
58 vector.vector->Map().NumMyElements(),
59 vector.vector->Map().MinMyGID(),
60 vector.vector->Map().MaxMyGID()));
63 return (*(vector.vector))[0][local_index];
75 , vector(new Epetra_FEVector(
76 Epetra_Map(0, 0, 0,
Utilities::Trilinos::comm_self())))
85 reinit(parallel_partitioning, communicator);
122 vector = std::make_unique<Epetra_FEVector>(
134 reinit(local, ghost, communicator,
false);
144 Epetra_Map map(0, 0, Epetra_MpiComm(MPI_COMM_SELF));
147 vector = std::make_unique<Epetra_FEVector>(map);
166 vector = std::make_unique<Epetra_FEVector>(map);
196 const bool omit_zeroing_entries,
197 const bool allow_different_maps)
204 if (allow_different_maps ==
false)
210 const Epetra_MpiComm *my_comm =
211 dynamic_cast<const Epetra_MpiComm *
>(&
vector->Comm());
212 const Epetra_MpiComm *v_comm =
213 dynamic_cast<const Epetra_MpiComm *
>(&v.
vector->Comm());
214 const bool same_communicators =
215 my_comm !=
nullptr && v_comm !=
nullptr &&
216 my_comm->DataPtr() == v_comm->DataPtr();
217 if (!same_communicators ||
220 vector = std::make_unique<Epetra_FEVector>(v.
vector->Map());
225 else if (omit_zeroing_entries ==
false)
234 ierr =
vector->PutScalar(0.0);
247 Assert(omit_zeroing_entries ==
false,
249 "It is not possible to exchange data with the "
250 "option 'omit_zeroing_entries' set, which would not write "
256 Epetra_Import data_exchange(
vector->Map(), v.
vector->Map());
258 const int ierr =
vector->Import(*v.
vector, data_exchange, Insert);
264 const Epetra_MpiComm *comm_ptr =
265 dynamic_cast<const Epetra_MpiComm *
>(&(v.
vector->Comm()));
290 size_type n_elements = 0, added_elements = 0, block_offset = 0;
292 n_elements += v.
block(block).vector->Map().NumMyElements();
293 std::vector<TrilinosWrappers::types::int_type> global_ids(n_elements, -1);
298 v.
block(block).trilinos_partitioner());
299 size_type vector_size = v.
block(block).vector->Map().NumMyElements();
300 for (
size_type i = 0; i < vector_size; ++i)
301 global_ids[added_elements++] = glob_elements[i] + block_offset;
304 block_offset += v.
block(block).size();
308 Epetra_Map new_map(v.
size(),
312 v.
block(0).trilinos_partitioner().Comm());
314 auto actual_vec = std::make_unique<Epetra_FEVector>(new_map);
319 v.
block(block).trilinos_vector().ExtractCopy(entries, 0);
320 entries += v.
block(block).vector->Map().NumMyElements();
323 if (import_data ==
true)
326 *actual_vec)) == v.
size(),
331 Epetra_Import data_exchange(
vector->Map(), actual_vec->Map());
333 const int ierr =
vector->Import(*actual_vec, data_exchange, Insert);
339 vector = std::move(actual_vec);
341 const Epetra_MpiComm *comm_ptr =
342 dynamic_cast<const Epetra_MpiComm *
>(&(
vector->Comm()));
357 const bool vector_writable)
361 if (vector_writable ==
false)
363 IndexSet parallel_partitioner = locally_owned_entries;
367 vector = std::make_unique<Epetra_FEVector>(map);
374 ExcMessage(
"A writable vector must not have ghost entries in "
375 "its parallel partitioning"));
377 if (
vector->Map().SameAs(map) ==
false)
378 vector = std::make_unique<Epetra_FEVector>(map);
381 const int ierr =
vector->PutScalar(0.);
386 IndexSet nonlocal_entries(ghost_entries);
390 Epetra_Map nonlocal_map =
393 std::make_unique<Epetra_MultiVector>(nonlocal_map, 1);
413 const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner,
414 const bool make_ghosted,
415 const bool vector_writable)
419 Assert(partitioner->ghost_indices_initialized(),
420 ExcMessage(
"You asked to create a ghosted vector, but the "
421 "partitioner does not provide ghost indices."));
423 this->
reinit(partitioner->locally_owned_range(),
424 partitioner->ghost_indices(),
425 partitioner->get_mpi_communicator(),
430 this->
reinit(partitioner->locally_owned_range(),
431 partitioner->get_mpi_communicator());
441 ExcMessage(
"Vector is not constructed properly."));
445 const Epetra_MpiComm *my_comm =
446 dynamic_cast<const Epetra_MpiComm *
>(&
vector->Comm());
447 const Epetra_MpiComm *v_comm =
448 dynamic_cast<const Epetra_MpiComm *
>(&v.
vector->Comm());
449 const bool same_communicators = my_comm !=
nullptr && v_comm !=
nullptr &&
450 my_comm->DataPtr() == v_comm->DataPtr();
477 if (same_communicators && v.
vector->Map().SameAs(
vector->Map()))
490 (v.
vector->Map().UniqueGIDs() ||
vector->Map().UniqueGIDs()))
523 template <
typename number>
549 "Cannot find exchange information!"));
551 ExcMessage(
"The input vector has overlapping data, "
552 "which is not allowed."));
558 Epetra_Import data_exchange(
vector->Map(), v.
vector->Map());
559 const int ierr =
vector->Import(*v.
vector, data_exchange, Insert);
574 "Both vectors need to have the same size for import_elements() to work!"));
584 (*
this)[idx] = rwv[idx];
589 (*
this)[idx] += rwv[idx];
603 "Calling compress() is only useful if a vector "
604 "has been written into, but this is a vector with ghost "
605 "elements and consequently is read-only. It does "
606 "not make sense to call compress() for such "
625 "compress() can only be called with VectorOperation add, insert, or unknown"));
635 "The last operation on the Vector and the given last action in the compress() call do not agree!"));
643 const double double_mode = mode;
644 const Epetra_MpiComm *comm_ptr =
652 "Not all processors agree whether the last operation on "
653 "this vector was an addition or a set operation. This will "
654 "prevent the compress() operation from succeeding."));
661 const auto ierr =
vector->GlobalAssemble(mode);
691 if (trilinos_i == -1)
695 vector->Map().NumMyElements(),
697 vector->Map().MaxMyGID()));
700 value = (*vector)[0][trilinos_i];
710 if (allow_different_maps ==
false)
718# if DEAL_II_TRILINOS_VERSION_GTE(11, 11, 0)
719 Epetra_Import data_exchange(
vector->Map(), v.
vector->Map());
721 vector->Import(*v.
vector, data_exchange, Epetra_AddLocalAlso);
728 Epetra_MultiVector dummy(
vector->Map(), 1,
false);
729 Epetra_Import data_exchange(dummy.Map(), v.
vector->Map());
731 int ierr = dummy.Import(*v.
vector, data_exchange, Insert);
734 ierr =
vector->Update(1.0, dummy, 1.0);
746 if (
vector->Map().NumMyElements() != v.
vector->Map().NumMyElements())
750 for (
size_type i = 0; i < vector_size; ++i)
764 return (!(*
this == v));
776 *eptr = start_ptr +
vector->Map().NumMyElements();
777 unsigned int flag = 0;
790 const Epetra_MpiComm *mpi_comm =
791 dynamic_cast<const Epetra_MpiComm *
>(&
vector->Map().Comm());
794 return num_nonzero == 0;
806 *eptr = start_ptr +
vector->Map().NumMyElements();
807 unsigned int flag = 0;
820 const auto max_n_negative =
822 return max_n_negative == 0;
829 const unsigned int precision,
830 const bool scientific,
831 const bool across)
const
834 boost::io::ios_flags_saver restore_flags(out);
837 out.precision(precision);
839 out.setf(std::ios::scientific, std::ios::floatfield);
841 out.setf(std::ios::fixed, std::ios::floatfield);
844 if (
size() != vector_size)
846 auto global_id = [&](
const size_type index) {
849 out <<
"size:" <<
size()
850 <<
" locally_owned_size:" <<
vector->Map().NumMyElements() <<
" :"
852 for (
size_type i = 0; i < vector_size; ++i)
853 out <<
"[" << global_id(i) <<
"]: " << (*(
vector))[0][i]
859 int leading_dimension;
860 int ierr =
vector->ExtractView(&val, &leading_dimension);
865 out <<
static_cast<double>(val[i]) <<
' ';
868 out <<
static_cast<double>(val[i]) << std::endl;
898 return sizeof(*this) +
899 this->
vector->Map().NumMyElements() *
905# include "trilinos_vector.inst"
virtual size_type size() const override
unsigned int n_blocks() const
BlockType & block(const unsigned int i)
bool is_ascending_and_one_to_one(const MPI_Comm communicator) const
size_type n_elements() const
void set_size(const size_type size)
Epetra_Map make_trilinos_map(const MPI_Comm communicator=MPI_COMM_WORLD, const bool overlapping=false) const
void subtract_set(const IndexSet &other)
void add_indices(const ForwardIterator &begin, const ForwardIterator &end)
size_type size() const override
const IndexSet & get_stored_elements() const
void compress(VectorOperation::values operation)
void add(const std::vector< size_type > &indices, const std::vector< TrilinosScalar > &values)
std::unique_ptr< Epetra_MultiVector > nonlocal_vector
void import_elements(const LinearAlgebra::ReadWriteVector< double > &rwv, const VectorOperation::values operation)
MPI_Comm get_mpi_communicator() const
const Epetra_BlockMap & trilinos_partitioner() const
reference operator()(const size_type index)
void import_nonlocal_data_for_fe(const ::TrilinosWrappers::SparseMatrix &matrix, const Vector &vector)
std::unique_ptr< Epetra_FEVector > vector
size_type size() const override
void print(std::ostream &out, const unsigned int precision=3, const bool scientific=true, const bool across=true) const
IndexSet locally_owned_elements() const
void reinit(const Vector &v, const bool omit_zeroing_entries=false, const bool allow_different_maps=false)
bool has_ghost_elements() const
std::pair< size_type, size_type > local_range() const
bool operator!=(const Vector &v) const
bool operator==(const Vector &v) const
Epetra_CombineMode last_action
Vector & operator=(const TrilinosScalar s)
bool is_non_negative() const
std::size_t memory_consumption() const
const Epetra_CrsMatrix & trilinos_matrix() const
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_CLOSE
static ::ExceptionBase & ExcIO()
static ::ExceptionBase & ExcGhostsPresent()
static ::ExceptionBase & ExcNotImplemented()
static ::ExceptionBase & ExcAccessToNonLocalElement(size_type arg1, size_type arg2, size_type arg3, size_type arg4)
#define Assert(cond, exc)
#define AssertIndexRange(index, range)
static ::ExceptionBase & ExcTrilinosError(int arg1)
static ::ExceptionBase & ExcInternalError()
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
static ::ExceptionBase & ExcMessage(std::string arg1)
#define AssertThrow(cond, exc)
void swap(BlockVector &u, BlockVector &v)
TrilinosWrappers::types::int_type global_length(const Epetra_MultiVector &vector)
int gid(const Epetra_BlockMap &map, int i)
TrilinosWrappers::types::int_type * my_global_elements(const Epetra_BlockMap &map)
TrilinosWrappers::types::int64_type n_global_elements(const Epetra_BlockMap &map)
T sum(const T &t, const MPI_Comm mpi_communicator)
unsigned int n_mpi_processes(const MPI_Comm mpi_communicator)
T max(const T &t, const MPI_Comm mpi_communicator)
MinMaxAvg min_max_avg(const double my_value, const MPI_Comm mpi_communicator)