16 #ifndef dealii_la_parallel_vector_h
17 #define dealii_la_parallel_vector_h
53 class ReadWriteVector;
56 # ifdef DEAL_II_WITH_PETSC
66 # ifdef DEAL_II_WITH_TRILINOS
250 template <
typename Number,
typename MemorySpace = MemorySpace::Host>
267 std::is_same<MemorySpace, ::MemorySpace::Host>::value ||
268 std::is_same<MemorySpace, ::MemorySpace::CUDA>::value,
269 "MemorySpace should be Host or CUDA");
321 const MPI_Comm &communicator);
335 const std::shared_ptr<const Utilities::MPI::Partitioner> &
partitioner);
359 template <
typename Number2>
362 const bool omit_zeroing_entries =
false);
383 const MPI_Comm &communicator);
405 const std::shared_ptr<const Utilities::MPI::Partitioner> &
partitioner,
406 const MPI_Comm &
comm_sm = MPI_COMM_SELF);
430 const MPI_Comm &
comm,
431 const MPI_Comm &
comm_sm = MPI_COMM_SELF);
473 template <
typename Number2>
564 const unsigned int communication_channel = 0,
607 const unsigned int communication_channel = 0)
const;
672 template <
typename Number2>
686 template <
typename MemorySpace2>
704 const bool omit_zeroing_entries =
false)
override;
744 std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
745 communication_pattern = {})
override;
757 add(
const Number a)
override;
779 add(
const std::vector<size_type> &indices,
780 const std::vector<Number> &
values);
883 const unsigned int precision = 3,
884 const bool scientific =
true,
885 const bool across =
true)
const override;
911 template <
typename OtherNumber>
913 add(
const std::vector<size_type> & indices,
914 const ::Vector<OtherNumber> &
values);
920 template <
typename OtherNumber>
924 const OtherNumber *
values);
1099 template <
typename OtherNumber>
1102 std::vector<OtherNumber> &
values)
const;
1131 template <
typename ForwardIterator,
typename OutputIterator>
1134 const ForwardIterator indices_end,
1135 OutputIterator values_begin)
const;
1176 const std::shared_ptr<const Utilities::MPI::Partitioner> &
1219 const std::vector<ArrayView<const Number>> &
1245 <<
"Called compress(VectorOperation::insert), but"
1246 <<
" the element received from a remote processor, value "
1247 << std::setprecision(16) << arg1
1248 <<
", does not match with the value "
1249 << std::setprecision(16) << arg2
1250 <<
" on the owner processor " << arg3);
1261 <<
"You tried to access element " << arg1
1262 <<
" of a distributed vector, but this element is not "
1263 <<
"stored on the current processor. Note: The range of "
1264 <<
"locally owned elements is [" << arg2 <<
',' << arg3
1265 <<
"], and there are " << arg4 <<
" ghost elements "
1266 <<
"that this vector can access."
1268 <<
"A common source for this kind of problem is that you "
1269 <<
"are passing a 'fully distributed' vector into a function "
1270 <<
"that needs read access to vector elements that correspond "
1271 <<
"to degrees of freedom on ghost cells (or at least to "
1272 <<
"'locally active' degrees of freedom that are not also "
1273 <<
"'locally owned'). You need to pass a vector that has these "
1274 <<
"elements as ghost entries.");
1296 template <
typename Number2>
1355 mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace>
data;
1361 mutable std::shared_ptr<::parallel::internal::TBBPartitioner>
1368 mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace>
1380 #ifdef DEAL_II_WITH_MPI
1424 const MPI_Comm &
comm_sm = MPI_COMM_SELF);
1427 template <
typename Number2,
typename MemorySpace2>
1431 template <
typename Number2>
1441 template <
typename Number,
typename MemorySpace>
1445 return vector_is_ghosted;
1450 template <
typename Number,
typename MemorySpace>
1454 return partitioner->size();
1459 template <
typename Number,
typename MemorySpace>
1468 template <
typename Number,
typename MemorySpace>
1472 return partitioner->locally_owned_size();
1477 template <
typename Number,
typename MemorySpace>
1487 template <
typename Number,
typename MemorySpace>
1493 is.add_range(partitioner->local_range().first,
1494 partitioner->local_range().second);
1501 template <
typename Number,
typename MemorySpace>
1505 return data.values.data();
1510 template <
typename Number,
typename MemorySpace>
1514 return data.values.data();
1519 template <
typename Number,
typename MemorySpace>
1523 return data.values.data() + partitioner->locally_owned_size();
1528 template <
typename Number,
typename MemorySpace>
1532 return data.values.data() + partitioner->locally_owned_size();
1537 template <
typename Number,
typename MemorySpace>
1538 const std::vector<ArrayView<const Number>> &
1541 return data.values_sm;
1546 template <
typename Number,
typename MemorySpace>
1550 Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1552 "This function is only implemented for the Host memory space"));
1557 partitioner->local_range().first,
1558 partitioner->local_range().second == 0 ?
1560 (partitioner->local_range().second - 1),
1561 partitioner->ghost_indices().n_elements()));
1564 vector_is_ghosted ==
true,
1565 ExcMessage(
"You tried to read a ghost element of this vector, "
1566 "but it has not imported its ghost values."));
1567 return data.values[partitioner->global_to_local(
global_index)];
1572 template <
typename Number,
typename MemorySpace>
1576 Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1578 "This function is only implemented for the Host memory space"));
1583 partitioner->local_range().first,
1584 partitioner->local_range().second == 0 ?
1586 (partitioner->local_range().second - 1),
1587 partitioner->ghost_indices().n_elements()));
1594 return data.values[partitioner->global_to_local(
global_index)];
1599 template <
typename Number,
typename MemorySpace>
1608 template <
typename Number,
typename MemorySpace>
1617 template <
typename Number,
typename MemorySpace>
1622 Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1624 "This function is only implemented for the Host memory space"));
1626 partitioner->locally_owned_size() +
1627 partitioner->n_ghost_indices());
1630 ExcMessage(
"You tried to read a ghost element of this vector, "
1631 "but it has not imported its ghost values."));
1633 return data.values[local_index];
1638 template <
typename Number,
typename MemorySpace>
1642 Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1644 "This function is only implemented for the Host memory space"));
1647 partitioner->locally_owned_size() +
1648 partitioner->n_ghost_indices());
1650 return data.values[local_index];
1655 template <
typename Number,
typename MemorySpace>
1659 return data.values.data();
1664 template <
typename Number,
typename MemorySpace>
1665 template <
typename OtherNumber>
1668 const std::vector<size_type> &indices,
1669 std::vector<OtherNumber> &
values)
const
1671 for (
size_type i = 0; i < indices.size(); ++i)
1672 values[i] =
operator()(indices[i]);
1677 template <
typename Number,
typename MemorySpace>
1678 template <
typename ForwardIterator,
typename OutputIterator>
1681 ForwardIterator indices_begin,
1682 const ForwardIterator indices_end,
1683 OutputIterator values_begin)
const
1685 while (indices_begin != indices_end)
1695 template <
typename Number,
typename MemorySpace>
1696 template <
typename OtherNumber>
1699 const std::vector<size_type> & indices,
1700 const ::Vector<OtherNumber> &
values)
1703 for (
size_type i = 0; i < indices.size(); ++i)
1708 "The given value is not finite but either infinite or Not A Number (NaN)"));
1715 template <
typename Number,
typename MemorySpace>
1716 template <
typename OtherNumber>
1720 const OtherNumber *
values)
1727 "The given value is not finite but either infinite or Not A Number (NaN)"));
1734 template <
typename Number,
typename MemorySpace>
1735 inline const MPI_Comm &
1738 return partitioner->get_mpi_communicator();
1743 template <
typename Number,
typename MemorySpace>
1744 inline const std::shared_ptr<const Utilities::MPI::Partitioner> &
1752 template <
typename Number,
typename MemorySpace>
1756 vector_is_ghosted = ghosted;
1772 template <
typename Number,
typename MemorySpace>
1784 template <
typename Number,
typename MemorySpace>
1793 namespace LinearOperatorImplementation
1802 template <
typename Number>
1808 template <
typename T>
1810 decltype(std::declval<T>().get_mpi_communicator());
1812 template <
typename T>
1813 static constexpr
bool has_get_mpi_communicator =
1814 is_supported_operation<get_mpi_communicator_t, T>;
1818 template <
typename T>
1820 decltype(std::declval<T>().locally_owned_domain_indices());
1822 template <
typename T>
1823 static constexpr
bool has_locally_owned_domain_indices =
1824 is_supported_operation<locally_owned_domain_indices_t, T>;
1828 template <
typename T>
1830 decltype(std::declval<T>().locally_owned_range_indices());
1832 template <
typename T>
1833 static constexpr
bool has_locally_owned_range_indices =
1834 is_supported_operation<locally_owned_range_indices_t, T>;
1838 template <
typename T>
1840 decltype(std::declval<T>().initialize_dof_vector(
1843 template <
typename T>
1844 static constexpr
bool has_initialize_dof_vector =
1845 is_supported_operation<initialize_dof_vector_t, T>;
1848 template <
typename MatrixType,
1849 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1850 std::enable_if_t<has_get_mpi_communicator<MatrixType> &&
1851 has_locally_owned_domain_indices<MatrixType>,
1855 is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1859 MatrixType> * =
nullptr>
1865 vec.
reinit(mat.locally_owned_domain_indices(),
1866 mat.get_mpi_communicator());
1870 template <
typename MatrixType,
1871 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1872 std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1876 is_supported_operation<initialize_dof_vector_t, MatrixType>,
1878 MatrixType> * =
nullptr>
1882 bool omit_zeroing_entries)
1884 mat.initialize_dof_vector(vec);
1885 if (!omit_zeroing_entries)
1890 template <
typename MatrixType,
1891 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1892 std::enable_if_t<has_get_mpi_communicator<MatrixType> &&
1893 has_locally_owned_range_indices<MatrixType>,
1897 is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1901 MatrixType> * =
nullptr>
1907 vec.
reinit(mat.locally_owned_range_indices(),
1908 mat.get_mpi_communicator());
1912 template <
typename MatrixType,
1913 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1914 std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1918 is_supported_operation<initialize_dof_vector_t, MatrixType>,
1920 MatrixType> * =
nullptr>
1924 bool omit_zeroing_entries)
1926 mat.initialize_dof_vector(vec);
1927 if (!omit_zeroing_entries)
value_type operator()(const size_type i) const
std::size_t locally_owned_size() const
types::global_dof_index size_type
void zero_out_ghost_values() const
Number mean_value_local() const
virtual real_type l1_norm() const override
void resize_val(const size_type new_allocated_size, const MPI_Comm &comm_sm=MPI_COMM_SELF)
bool partitioners_are_compatible(const Utilities::MPI::Partitioner &part) const
virtual Vector< Number, MemorySpace > & operator-=(const VectorSpaceVector< Number > &V) override
virtual Vector< Number, MemorySpace > & operator/=(const Number factor) override
bool has_ghost_elements() const
void reinit(const std::shared_ptr< const Utilities::MPI::Partitioner > &partitioner, const MPI_Comm &comm_sm=MPI_COMM_SELF)
const value_type & const_reference
Number & operator[](const size_type global_index)
Number local_element(const size_type local_index) const
Number add_and_dot_local(const Number a, const Vector< Number, MemorySpace > &V, const Vector< Number, MemorySpace > &W)
real_type linfty_norm_local() const
virtual void add(const Number a, const VectorSpaceVector< Number > &V, const Number b, const VectorSpaceVector< Number > &W) override
void update_ghost_values() const
mutable ::MemorySpace::MemorySpaceData< Number, MemorySpace > import_data
void swap(Vector< Number, MemorySpace > &v)
real_type l1_norm_local() const
virtual real_type linfty_norm() const override
mutable ::MemorySpace::MemorySpaceData< Number, MemorySpace > data
types::global_dof_index size_type
Vector(const IndexSet &local_range, const IndexSet &ghost_indices, const MPI_Comm &communicator)
typename numbers::NumberTraits< Number >::real_type real_type
const_iterator end() const
Number & local_element(const size_type local_index)
Vector(const size_type size)
Vector(Vector< Number, MemorySpace > &&in_vector)
size_type locally_owned_size() const
virtual Vector< Number, MemorySpace > & operator+=(const VectorSpaceVector< Number > &V) override
std::shared_ptr< const Utilities::MPI::Partitioner > partitioner
void add(const size_type n_elements, const size_type *indices, const OtherNumber *values)
virtual void equ(const Number a, const VectorSpaceVector< Number > &V) override
void sadd(const Number s, const Vector< Number, MemorySpace > &V)
Vector(const IndexSet &local_range, const MPI_Comm &communicator)
real_type norm_sqr_local() const
virtual std::size_t memory_consumption() const override
const value_type * const_iterator
void clear_mpi_requests()
const std::shared_ptr< const Utilities::MPI::Partitioner > & get_partitioner() const
Number & operator()(const size_type global_index)
Number operator[](const size_type global_index) const
virtual bool all_zero() const override
Vector(const Vector< Number, MemorySpace > &in_vector)
virtual Number mean_value() const override
void set_ghost_state(const bool ghosted) const
void reinit(const IndexSet &local_range, const IndexSet &ghost_indices, const MPI_Comm &communicator)
void add(const std::vector< size_type > &indices, const ::Vector< OtherNumber > &values)
virtual void reinit(const VectorSpaceVector< Number > &V, const bool omit_zeroing_entries=false) override
virtual Number operator*(const VectorSpaceVector< Number > &V) const override
const value_type * const_pointer
virtual Vector< Number, MemorySpace > & operator=(const Number s) override
virtual void add(const std::vector< size_type > &indices, const std::vector< Number > &values)
virtual void compress(::VectorOperation::values operation) override
void reinit(const Vector< Number2, MemorySpace > &in_vector, const bool omit_zeroing_entries=false)
real_type lp_norm(const real_type p) const
Number * get_values() const
bool partitioners_are_globally_compatible(const Utilities::MPI::Partitioner &part) const
virtual size_type size() const override
const MPI_Comm & get_mpi_communicator() const
virtual ~Vector() override
void add_local(const Number a, const VectorSpaceVector< Number > &V)
std::shared_ptr<::parallel::internal::TBBPartitioner > thread_loop_partitioner
virtual void sadd(const Number s, const Number a, const VectorSpaceVector< Number > &V) override
void compress_start(const unsigned int communication_channel=0, ::VectorOperation::values operation=VectorOperation::add)
virtual void scale(const VectorSpaceVector< Number > &scaling_factors) override
virtual void print(std::ostream &out, const unsigned int precision=3, const bool scientific=true, const bool across=true) const override
void update_ghost_values_finish() const
void update_ghost_values_start(const unsigned int communication_channel=0) const
void copy_locally_owned_data_from(const Vector< Number2, MemorySpace > &src)
virtual void add(const Number a, const VectorSpaceVector< Number > &V) override
Vector< Number, MemorySpace > & operator=(const Vector< Number, MemorySpace > &in_vector)
size_type local_size() const
virtual void add(const Number a) override
void zero_out_ghosts() const
Number operator()(const size_type global_index) const
real_type lp_norm_local(const real_type p) const
void reinit(const types::global_dof_index local_size, const types::global_dof_index ghost_size, const MPI_Comm &comm, const MPI_Comm &comm_sm=MPI_COMM_SELF)
void sadd_local(const Number s, const Number a, const VectorSpaceVector< Number > &V)
void reinit(const IndexSet &local_range, const MPI_Comm &communicator)
void reinit(const size_type size, const bool omit_zeroing_entries=false)
const std::vector< ArrayView< const Number > > & shared_vector_data() const
Vector< Number, MemorySpace > & operator=(const Vector< Number2, MemorySpace > &in_vector)
void extract_subvector_to(const std::vector< size_type > &indices, std::vector< OtherNumber > &values) const
virtual Vector< Number, MemorySpace > & operator*=(const Number factor) override
void compress_finish(::VectorOperation::values operation)
std::vector< MPI_Request > update_ghost_values_requests
const_iterator begin() const
std::vector< MPI_Request > compress_requests
bool in_local_range(const size_type global_index) const
void extract_subvector_to(ForwardIterator indices_begin, const ForwardIterator indices_end, OutputIterator values_begin) const
Number inner_product_local(const Vector< Number2, MemorySpace > &V) const
real_type norm_sqr() const
virtual Number add_and_dot(const Number a, const VectorSpaceVector< Number > &V, const VectorSpaceVector< Number > &W) override
virtual real_type l2_norm() const override
Vector(const std::shared_ptr< const Utilities::MPI::Partitioner > &partitioner)
virtual ::IndexSet locally_owned_elements() const override
void swap(LinearAlgebra::distributed::Vector< Number, MemorySpace > &u, LinearAlgebra::distributed::Vector< Number, MemorySpace > &v)
const value_type * const_iterator
types::global_dof_index size_type
decltype(std::declval< T >().initialize_dof_vector(std::declval< LinearAlgebra::distributed::Vector< Number > & >())) initialize_dof_vector_t
decltype(std::declval< T >().get_mpi_communicator()) get_mpi_communicator_t
static void reinit_range_vector(MatrixType &mat, LinearAlgebra::distributed::Vector< Number > &vec, bool)
static void reinit_range_vector(MatrixType &mat, LinearAlgebra::distributed::Vector< Number > &vec, bool omit_zeroing_entries)
decltype(std::declval< T >().locally_owned_domain_indices()) locally_owned_domain_indices_t
decltype(std::declval< T >().locally_owned_range_indices()) locally_owned_range_indices_t
static void reinit_domain_vector(MatrixType &mat, LinearAlgebra::distributed::Vector< Number > &vec, bool omit_zeroing_entries)
static void reinit_domain_vector(MatrixType &mat, LinearAlgebra::distributed::Vector< Number > &vec, bool)
#define DEAL_II_DEPRECATED
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_CLOSE
#define DeclException0(Exception0)
#define DeclException4(Exception4, type1, type2, type3, type4, outsequence)
static ::ExceptionBase & ExcVectorTypeNotCompatible()
static ::ExceptionBase & ExcNonMatchingElements(Number arg1, Number arg2, unsigned int arg3)
static ::ExceptionBase & ExcAccessToNonLocalElement(size_type arg1, size_type arg2, size_type arg3, size_type arg4)
#define Assert(cond, exc)
static ::ExceptionBase & ExcNotAllowedForCuda()
#define AssertDimension(dim1, dim2)
#define AssertIndexRange(index, range)
#define DeclException3(Exception3, type1, type2, type3, outsequence)
static ::ExceptionBase & ExcMessage(std::string arg1)
types::global_dof_index size_type
SymmetricTensor< 2, dim, Number > b(const Tensor< 2, dim, Number > &F)
TrilinosWrappers::types::int_type global_index(const Epetra_BlockMap &map, const ::types::global_dof_index i)
constexpr bool is_supported_operation
bool is_finite(const double x)
unsigned int global_dof_index