15#ifndef dealii_la_parallel_vector_h
16#define dealii_la_parallel_vector_h
36#if defined(DEAL_II_WITH_MPI)
54 template <
typename,
typename>
59 class ReadWriteVector;
62# ifdef DEAL_II_WITH_PETSC
72# ifdef DEAL_II_WITH_TRILINOS
255 template <
typename Number,
typename MemorySpace = MemorySpace::Host>
271 std::is_same_v<MemorySpace, ::MemorySpace::Host> ||
272 std::is_same_v<MemorySpace, ::MemorySpace::Default>,
273 "MemorySpace should be Host or Default");
339 const std::shared_ptr<const Utilities::MPI::Partitioner> &
partitioner);
363 template <
typename Number2>
366 const bool omit_zeroing_entries =
false);
409 const std::shared_ptr<const Utilities::MPI::Partitioner> &
partitioner,
420 const std::shared_ptr<const Utilities::MPI::Partitioner> &
partitioner,
421 const bool make_ghosted,
515 template <
typename Number2>
648 const unsigned int communication_channel = 0)
const;
700 template <
typename Number2>
714 template <
typename MemorySpace2>
722 template <
typename MemorySpace2>
776 const std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
777 &communication_pattern = {});
785 std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
786 communication_pattern = {})
823 add(
const std::vector<size_type> &indices,
824 const std::vector<Number> &values);
927 const unsigned int precision = 3,
928 const bool scientific =
true,
929 const bool across =
true)
const;
955 template <
typename OtherNumber>
957 add(
const std::vector<size_type> &indices,
958 const ::Vector<OtherNumber> &values);
964 template <
typename OtherNumber>
968 const OtherNumber *values);
1133 template <
typename OtherNumber>
1136 std::vector<OtherNumber> &values)
const;
1173 template <
typename ForwardIterator,
typename OutputIterator>
1176 const ForwardIterator indices_end,
1177 OutputIterator values_begin)
const;
1217 const std::shared_ptr<const Utilities::MPI::Partitioner> &
1260 const std::vector<ArrayView<const Number>> &
1279 <<
"Called compress(VectorOperation::insert), but"
1280 <<
" the element received from a remote processor, value "
1281 << std::setprecision(16) << arg1
1282 <<
", does not match with the value "
1283 << std::setprecision(16) << arg2
1284 <<
" on the owner processor " << arg3);
1295 <<
"You tried to access element " << arg1
1296 <<
" of a distributed vector, but this element is not "
1297 <<
"stored on the current processor. Note: The range of "
1298 <<
"locally owned elements is [" << arg2 <<
',' << arg3
1299 <<
"], and there are " << arg4 <<
" ghost elements "
1300 <<
"that this vector can access."
1302 <<
"A common source for this kind of problem is that you "
1303 <<
"are passing a 'fully distributed' vector into a function "
1304 <<
"that needs read access to vector elements that correspond "
1305 <<
"to degrees of freedom on ghost cells (or at least to "
1306 <<
"'locally active' degrees of freedom that are not also "
1307 <<
"'locally owned'). You need to pass a vector that has these "
1308 <<
"elements as ghost entries.");
1330 template <
typename Number2>
1399 mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace>
data;
1405 mutable std::shared_ptr<::parallel::internal::TBBPartitioner>
1412 mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace>
1424#ifdef DEAL_II_WITH_MPI
1471 template <
typename Number2,
typename MemorySpace2>
1475 template <
typename Number2,
typename MemorySpace2>
1485 template <
typename Number,
typename MemorySpace>
1489 return vector_is_ghosted;
1494 template <
typename Number,
typename MemorySpace>
1498 return partitioner->size();
1503 template <
typename Number,
typename MemorySpace>
1507 return partitioner->locally_owned_size();
1512 template <
typename Number,
typename MemorySpace>
1515 const size_type global_index)
const
1517 return partitioner->in_local_range(global_index);
1522 template <
typename Number,
typename MemorySpace>
1528 is.add_range(partitioner->local_range().first,
1529 partitioner->local_range().second);
1536 template <
typename Number,
typename MemorySpace>
1540 return data.values.data();
1545 template <
typename Number,
typename MemorySpace>
1549 return data.values.data();
1554 template <
typename Number,
typename MemorySpace>
1558 return data.values.data() + partitioner->locally_owned_size();
1563 template <
typename Number,
typename MemorySpace>
1567 return data.values.data() + partitioner->locally_owned_size();
1572 template <
typename Number,
typename MemorySpace>
1573 const std::vector<ArrayView<const Number>> &
1576 return data.values_sm;
1581 template <
typename Number,
typename MemorySpace>
1585 Assert((std::is_same_v<MemorySpace, ::MemorySpace::Host>),
1587 "This function is only implemented for the Host memory space"));
1589 partitioner->in_local_range(global_index) ||
1590 partitioner->ghost_indices().is_element(global_index),
1591 ExcAccessToNonLocalElement(global_index,
1592 partitioner->local_range().first,
1593 partitioner->local_range().second == 0 ?
1596 partitioner->ghost_indices().n_elements()));
1598 Assert(partitioner->in_local_range(global_index) ||
1599 vector_is_ghosted ==
true,
1600 ExcMessage(
"You tried to read a ghost element of this vector, "
1601 "but it has not imported its ghost values."));
1602 return data.values[partitioner->global_to_local(global_index)];
1607 template <
typename Number,
typename MemorySpace>
1611 Assert((std::is_same_v<MemorySpace, ::MemorySpace::Host>),
1613 "This function is only implemented for the Host memory space"));
1615 partitioner->in_local_range(global_index) ||
1616 partitioner->ghost_indices().is_element(global_index),
1617 ExcAccessToNonLocalElement(global_index,
1618 partitioner->local_range().first,
1619 partitioner->local_range().second == 0 ?
1622 partitioner->ghost_indices().n_elements()));
1629 return data.values[partitioner->global_to_local(global_index)];
1634 template <
typename Number,
typename MemorySpace>
1638 return operator()(global_index);
1643 template <
typename Number,
typename MemorySpace>
1647 return operator()(global_index);
1652 template <
typename Number,
typename MemorySpace>
1655 const size_type local_index)
const
1657 Assert((std::is_same_v<MemorySpace, ::MemorySpace::Host>),
1659 "This function is only implemented for the Host memory space"));
1661 partitioner->locally_owned_size() +
1662 partitioner->n_ghost_indices());
1665 ExcMessage(
"You tried to read a ghost element of this vector, "
1666 "but it has not imported its ghost values."));
1668 return data.values[local_index];
1673 template <
typename Number,
typename MemorySpace>
1677 Assert((std::is_same_v<MemorySpace, ::MemorySpace::Host>),
1679 "This function is only implemented for the Host memory space"));
1682 partitioner->locally_owned_size() +
1683 partitioner->n_ghost_indices());
1685 return data.values[local_index];
1690 template <
typename Number,
typename MemorySpace>
1694 return data.values.data();
1699 template <
typename Number,
typename MemorySpace>
1700 template <
typename OtherNumber>
1703 const std::vector<size_type> &indices,
1704 std::vector<OtherNumber> &values)
const
1706 for (size_type i = 0; i < indices.size(); ++i)
1707 values[i] =
operator()(indices[i]);
1712 template <
typename Number,
typename MemorySpace>
1713 template <
typename ForwardIterator,
typename OutputIterator>
1716 ForwardIterator indices_begin,
1717 const ForwardIterator indices_end,
1718 OutputIterator values_begin)
const
1720 while (indices_begin != indices_end)
1722 *values_begin = operator()(*indices_begin);
1730 template <
typename Number,
typename MemorySpace>
1731 template <
typename OtherNumber>
1734 const std::vector<size_type> &indices,
1735 const ::Vector<OtherNumber> &values)
1738 for (size_type i = 0; i < indices.size(); ++i)
1743 "The given value is not finite but either infinite or Not A Number (NaN)"));
1744 this->operator()(indices[i]) +=
values(i);
1750 template <
typename Number,
typename MemorySpace>
1751 template <
typename OtherNumber>
1754 const size_type *indices,
1755 const OtherNumber *values)
1757 for (size_type i = 0; i < n_elements; ++i, ++indices, ++
values)
1762 "The given value is not finite but either infinite or Not A Number (NaN)"));
1763 this->operator()(*indices) += *
values;
1769 template <
typename Number,
typename MemorySpace>
1773 return partitioner->get_mpi_communicator();
1778 template <
typename Number,
typename MemorySpace>
1779 inline const std::shared_ptr<const Utilities::MPI::Partitioner> &
1787 template <
typename Number,
typename MemorySpace>
1791 vector_is_ghosted = ghosted;
1807template <
typename Number,
typename MemorySpace>
1819template <
typename Number,
typename MemorySpace>
1828 namespace LinearOperatorImplementation
1837 template <
typename Number>
1843 template <
typename T>
1845 decltype(std::declval<T>().get_mpi_communicator());
1847 template <
typename T>
1848 static constexpr bool has_get_mpi_communicator =
1849 is_supported_operation<get_mpi_communicator_t, T>;
1853 template <
typename T>
1855 decltype(std::declval<T>().locally_owned_domain_indices());
1857 template <
typename T>
1858 static constexpr bool has_locally_owned_domain_indices =
1859 is_supported_operation<locally_owned_domain_indices_t, T>;
1863 template <
typename T>
1865 decltype(std::declval<T>().locally_owned_range_indices());
1867 template <
typename T>
1868 static constexpr bool has_locally_owned_range_indices =
1869 is_supported_operation<locally_owned_range_indices_t, T>;
1873 template <
typename T>
1875 decltype(std::declval<T>().initialize_dof_vector(
1878 template <
typename T>
1879 static constexpr bool has_initialize_dof_vector =
1880 is_supported_operation<initialize_dof_vector_t, T>;
1883 template <
typename MatrixType,
1884#if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1885 std::enable_if_t<has_get_mpi_communicator<MatrixType> &&
1886 has_locally_owned_domain_indices<MatrixType>,
1890 is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1894 MatrixType> * =
nullptr>
1900 vec.
reinit(mat.locally_owned_domain_indices(),
1901 mat.get_mpi_communicator());
1905 template <
typename MatrixType,
1906#if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1907 std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1911 is_supported_operation<initialize_dof_vector_t, MatrixType>,
1913 MatrixType> * =
nullptr>
1917 bool omit_zeroing_entries)
1919 mat.initialize_dof_vector(vec);
1920 if (!omit_zeroing_entries)
1925 template <
typename MatrixType,
1926#if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1927 std::enable_if_t<has_get_mpi_communicator<MatrixType> &&
1928 has_locally_owned_range_indices<MatrixType>,
1932 is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1936 MatrixType> * =
nullptr>
1942 vec.
reinit(mat.locally_owned_range_indices(),
1943 mat.get_mpi_communicator());
1947 template <
typename MatrixType,
1948#if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1949 std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1953 is_supported_operation<initialize_dof_vector_t, MatrixType>,
1955 MatrixType> * =
nullptr>
1959 bool omit_zeroing_entries)
1961 mat.initialize_dof_vector(vec);
1962 if (!omit_zeroing_entries)
Number & operator()(const size_type global_index)
void zero_out_ghost_values() const
void assert_no_residual_content_in_ghost_region() const
real_type linfty_norm() const
Number mean_value_local() const
virtual void extract_subvector_to(const ArrayView< const types::global_dof_index > &indices, const ArrayView< Number > &elements) const override
bool partitioners_are_compatible(const Utilities::MPI::Partitioner &part) const
void sadd(const Number s, const Number a, const Vector< Number, MemorySpace > &V)
bool has_ghost_elements() const
const value_type & const_reference
Number local_element(const size_type local_index) const
void reinit(const IndexSet &local_range, const MPI_Comm communicator)
Number add_and_dot_local(const Number a, const Vector< Number, MemorySpace > &V, const Vector< Number, MemorySpace > &W)
Number mean_value() const
real_type linfty_norm_local() const
void compress_finish(VectorOperation::values operation)
Number * get_values() const
void update_ghost_values() const
mutable ::MemorySpace::MemorySpaceData< Number, MemorySpace > import_data
real_type l1_norm_local() const
mutable ::MemorySpace::MemorySpaceData< Number, MemorySpace > data
void equ(const Number a, const Vector< Number, MemorySpace > &V)
Vector< Number, MemorySpace > & operator=(Vector< Number, MemorySpace > &&in_vector)
void sadd_local(const Number s, const Number a, const Vector< Number, MemorySpace > &V)
typename numbers::NumberTraits< Number >::real_type real_type
const_iterator end() const
Vector(const IndexSet &local_range, const MPI_Comm communicator)
Vector(const size_type size)
Vector(Vector< Number, MemorySpace > &&in_vector)
size_type locally_owned_size() const
void reinit(const std::shared_ptr< const Utilities::MPI::Partitioner > &partitioner, const MPI_Comm comm_sm=MPI_COMM_SELF)
std::shared_ptr< const Utilities::MPI::Partitioner > partitioner
void add(const size_type n_elements, const size_type *indices, const OtherNumber *values)
void sadd(const Number s, const Vector< Number, MemorySpace > &V)
Vector< Number, MemorySpace > & operator=(const Vector< Number, MemorySpace > &in_vector)
real_type norm_sqr_local() const
void reinit(const IndexSet &local_range, const IndexSet &ghost_indices, const MPI_Comm communicator)
void swap(Vector< Number, MemorySpace > &v) noexcept
const value_type * const_iterator
void clear_mpi_requests()
Number operator[](const size_type global_index) const
Vector(const Vector< Number, MemorySpace > &in_vector)
void add(const Number a, const Vector< Number, MemorySpace > &V)
void set_ghost_state(const bool ghosted) const
void add(const std::vector< size_type > &indices, const std::vector< Number > &values)
::IndexSet locally_owned_elements() const
real_type l2_norm() const
void compress(VectorOperation::values operation)
Vector(const IndexSet &local_range, const IndexSet &ghost_indices, const MPI_Comm communicator)
Vector< Number, MemorySpace > & operator*=(const Number factor)
Vector< Number, MemorySpace > & operator+=(const Vector< Number, MemorySpace > &V)
void add(const std::vector< size_type > &indices, const ::Vector< OtherNumber > &values)
void import_elements(const Vector< Number, MemorySpace2 > &src, VectorOperation::values operation)
Number & operator[](const size_type global_index)
void add(const Number a, const Vector< Number, MemorySpace > &V, const Number b, const Vector< Number, MemorySpace > &W)
const value_type * const_pointer
void reinit(const Vector< Number2, MemorySpace > &in_vector, const bool omit_zeroing_entries=false)
real_type lp_norm(const real_type p) const
bool partitioners_are_globally_compatible(const Utilities::MPI::Partitioner &part) const
const std::shared_ptr< const Utilities::MPI::Partitioner > & get_partitioner() const
virtual size_type size() const override
std::shared_ptr<::parallel::internal::TBBPartitioner > thread_loop_partitioner
Number add_and_dot(const Number a, const Vector< Number, MemorySpace > &V, const Vector< Number, MemorySpace > &W)
std::size_t memory_consumption() const
void update_ghost_values_finish() const
const std::vector< ArrayView< const Number > > & shared_vector_data() const
void update_ghost_values_start(const unsigned int communication_channel=0) const
void import_elements(const LinearAlgebra::ReadWriteVector< Number > &V, const VectorOperation::values operation, const std::shared_ptr< const Utilities::MPI::CommunicationPatternBase > &communication_pattern={})
void copy_locally_owned_data_from(const Vector< Number2, MemorySpace > &src)
Vector< Number, MemorySpace > & operator=(const Vector< Number2, MemorySpace > &in_vector)
Vector< Number, MemorySpace > & operator=(const Number s)
Number operator()(const size_type global_index) const
real_type lp_norm_local(const real_type p) const
Vector< Number, MemorySpace > & operator-=(const Vector< Number, MemorySpace > &V)
void print(std::ostream &out, const unsigned int precision=3, const bool scientific=true, const bool across=true) const
void reinit(const size_type size, const bool omit_zeroing_entries=false)
MPI_Comm get_mpi_communicator() const
void extract_subvector_to(const std::vector< size_type > &indices, std::vector< OtherNumber > &values) const
void compress_start(const unsigned int communication_channel=0, VectorOperation::values operation=VectorOperation::add)
std::vector< MPI_Request > update_ghost_values_requests
void scale(const Vector< Number, MemorySpace > &scaling_factors)
const_iterator begin() const
std::vector< MPI_Request > compress_requests
void add_local(const Number a, const Vector< Number, MemorySpace > &V)
Number operator*(const Vector< Number, MemorySpace > &V) const
bool in_local_range(const size_type global_index) const
Vector< Number, MemorySpace > & operator/=(const Number factor)
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
Number & local_element(const size_type local_index)
void reinit(const std::shared_ptr< const Utilities::MPI::Partitioner > &partitioner, const bool make_ghosted, const MPI_Comm &comm_sm=MPI_COMM_SELF)
real_type norm_sqr() const
real_type l1_norm() const
void resize_val(const size_type new_allocated_size, const MPI_Comm comm_sm=MPI_COMM_SELF)
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)
Vector(const std::shared_ptr< const Utilities::MPI::Partitioner > &partitioner)
const value_type * const_iterator
void swap(LinearAlgebra::distributed::Vector< Number, MemorySpace > &u, LinearAlgebra::distributed::Vector< Number, MemorySpace > &v) noexcept
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_DISABLE_EXTRA_DIAGNOSTICS
#define DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
static ::ExceptionBase & ExcAccessToNonLocalElement(size_type arg1, size_type arg2, size_type arg3, size_type arg4)
#define DeclException0(Exception0)
#define DeclException4(Exception4, type1, type2, type3, type4, outsequence)
static ::ExceptionBase & ExcVectorTypeNotCompatible()
static ::ExceptionBase & ExcNonMatchingElements(Number arg1, Number arg2, unsigned int arg3)
#define Assert(cond, exc)
#define AssertDimension(dim1, dim2)
#define AssertIndexRange(index, range)
#define DeclException3(Exception3, type1, type2, type3, outsequence)
static ::ExceptionBase & ExcMessage(std::string arg1)
std::vector< index_type > data
std::pair< types::global_dof_index, types::global_dof_index > local_range
types::global_dof_index locally_owned_size
constexpr bool is_supported_operation
bool is_finite(const double x)
unsigned int global_dof_index