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
248 template <
typename Number,
typename MemorySpace = MemorySpace::Host>
265 std::is_same<MemorySpace, ::MemorySpace::Host>::value ||
266 std::is_same<MemorySpace, ::MemorySpace::Default>::value,
267 "MemorySpace should be Host or Default");
319 const MPI_Comm communicator);
333 const std::shared_ptr<const Utilities::MPI::Partitioner> &
partitioner);
357 template <
typename Number2>
360 const bool omit_zeroing_entries =
false);
381 const MPI_Comm communicator);
403 const std::shared_ptr<const Utilities::MPI::Partitioner> &
partitioner,
404 const MPI_Comm
comm_sm = MPI_COMM_SELF);
414 const std::shared_ptr<const Utilities::MPI::Partitioner> &
partitioner,
415 const bool make_ghosted,
416 const MPI_Comm &
comm_sm = MPI_COMM_SELF);
441 const MPI_Comm
comm_sm = MPI_COMM_SELF);
492 template <
typename Number2>
625 const unsigned int communication_channel = 0)
const;
690 template <
typename Number2>
704 template <
typename MemorySpace2>
712 template <
typename MemorySpace2>
713 DEAL_II_DEPRECATED_EARLY
void
733 const bool omit_zeroing_entries =
false)
override;
774 std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
775 communication_pattern = {})
override;
780 DEAL_II_DEPRECATED_EARLY
virtual void
783 std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
784 communication_pattern = {})
override
799 add(
const Number a)
override;
821 add(
const std::vector<size_type> &indices,
822 const std::vector<Number> &
values);
925 const unsigned int precision = 3,
926 const bool scientific =
true,
927 const bool across =
true)
const override;
953 template <
typename OtherNumber>
955 add(
const std::vector<size_type> & indices,
956 const ::Vector<OtherNumber> &
values);
962 template <
typename OtherNumber>
966 const OtherNumber *
values);
1141 template <
typename OtherNumber>
1144 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>
1389 mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace>
data;
1395 mutable std::shared_ptr<::parallel::internal::TBBPartitioner>
1402 mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace>
1414 #ifdef DEAL_II_WITH_MPI
1458 const MPI_Comm
comm_sm = MPI_COMM_SELF);
1461 template <
typename Number2,
typename MemorySpace2>
1465 template <
typename Number2>
1475 template <
typename Number,
typename MemorySpace>
1479 return vector_is_ghosted;
1484 template <
typename Number,
typename MemorySpace>
1488 return partitioner->size();
1493 template <
typename Number,
typename MemorySpace>
1502 template <
typename Number,
typename MemorySpace>
1506 return partitioner->locally_owned_size();
1511 template <
typename Number,
typename MemorySpace>
1521 template <
typename Number,
typename MemorySpace>
1527 is.add_range(partitioner->local_range().first,
1528 partitioner->local_range().second);
1535 template <
typename Number,
typename MemorySpace>
1539 return data.values.data();
1544 template <
typename Number,
typename MemorySpace>
1548 return data.values.data();
1553 template <
typename Number,
typename MemorySpace>
1557 return data.values.data() + partitioner->locally_owned_size();
1562 template <
typename Number,
typename MemorySpace>
1566 return data.values.data() + partitioner->locally_owned_size();
1571 template <
typename Number,
typename MemorySpace>
1572 const std::vector<ArrayView<const Number>> &
1575 return data.values_sm;
1580 template <
typename Number,
typename MemorySpace>
1584 Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1586 "This function is only implemented for the Host memory space"));
1591 partitioner->local_range().first,
1592 partitioner->local_range().second == 0 ?
1594 (partitioner->local_range().second - 1),
1595 partitioner->ghost_indices().n_elements()));
1598 vector_is_ghosted ==
true,
1599 ExcMessage(
"You tried to read a ghost element of this vector, "
1600 "but it has not imported its ghost values."));
1601 return data.values[partitioner->global_to_local(
global_index)];
1606 template <
typename Number,
typename MemorySpace>
1610 Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1612 "This function is only implemented for the Host memory space"));
1617 partitioner->local_range().first,
1618 partitioner->local_range().second == 0 ?
1620 (partitioner->local_range().second - 1),
1621 partitioner->ghost_indices().n_elements()));
1628 return data.values[partitioner->global_to_local(
global_index)];
1633 template <
typename Number,
typename MemorySpace>
1642 template <
typename Number,
typename MemorySpace>
1651 template <
typename Number,
typename MemorySpace>
1656 Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1658 "This function is only implemented for the Host memory space"));
1660 partitioner->locally_owned_size() +
1661 partitioner->n_ghost_indices());
1664 ExcMessage(
"You tried to read a ghost element of this vector, "
1665 "but it has not imported its ghost values."));
1667 return data.values[local_index];
1672 template <
typename Number,
typename MemorySpace>
1676 Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1678 "This function is only implemented for the Host memory space"));
1681 partitioner->locally_owned_size() +
1682 partitioner->n_ghost_indices());
1684 return data.values[local_index];
1689 template <
typename Number,
typename MemorySpace>
1693 return data.values.data();
1698 template <
typename Number,
typename MemorySpace>
1699 template <
typename OtherNumber>
1702 const std::vector<size_type> &indices,
1703 std::vector<OtherNumber> &
values)
const
1705 for (
size_type i = 0; i < indices.size(); ++i)
1706 values[i] =
operator()(indices[i]);
1711 template <
typename Number,
typename MemorySpace>
1712 template <
typename ForwardIterator,
typename OutputIterator>
1715 ForwardIterator indices_begin,
1716 const ForwardIterator indices_end,
1717 OutputIterator values_begin)
const
1719 while (indices_begin != indices_end)
1729 template <
typename Number,
typename MemorySpace>
1730 template <
typename OtherNumber>
1733 const std::vector<size_type> & indices,
1734 const ::Vector<OtherNumber> &
values)
1737 for (
size_type i = 0; i < indices.size(); ++i)
1742 "The given value is not finite but either infinite or Not A Number (NaN)"));
1749 template <
typename Number,
typename MemorySpace>
1750 template <
typename OtherNumber>
1754 const OtherNumber *
values)
1761 "The given value is not finite but either infinite or Not A Number (NaN)"));
1768 template <
typename Number,
typename MemorySpace>
1772 return partitioner->get_mpi_communicator();
1777 template <
typename Number,
typename MemorySpace>
1778 inline const std::shared_ptr<const Utilities::MPI::Partitioner> &
1786 template <
typename Number,
typename MemorySpace>
1790 vector_is_ghosted = ghosted;
1806 template <
typename Number,
typename MemorySpace>
1818 template <
typename Number,
typename MemorySpace>
1827 namespace LinearOperatorImplementation
1836 template <
typename Number>
1842 template <
typename T>
1844 decltype(std::declval<T>().get_mpi_communicator());
1846 template <
typename T>
1847 static constexpr
bool has_get_mpi_communicator =
1848 is_supported_operation<get_mpi_communicator_t, T>;
1852 template <
typename T>
1854 decltype(std::declval<T>().locally_owned_domain_indices());
1856 template <
typename T>
1857 static constexpr
bool has_locally_owned_domain_indices =
1858 is_supported_operation<locally_owned_domain_indices_t, T>;
1862 template <
typename T>
1864 decltype(std::declval<T>().locally_owned_range_indices());
1866 template <
typename T>
1867 static constexpr
bool has_locally_owned_range_indices =
1868 is_supported_operation<locally_owned_range_indices_t, T>;
1872 template <
typename T>
1874 decltype(std::declval<T>().initialize_dof_vector(
1877 template <
typename T>
1878 static constexpr
bool has_initialize_dof_vector =
1879 is_supported_operation<initialize_dof_vector_t, T>;
1882 template <
typename MatrixType,
1883 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1884 std::enable_if_t<has_get_mpi_communicator<MatrixType> &&
1885 has_locally_owned_domain_indices<MatrixType>,
1889 is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1893 MatrixType> * =
nullptr>
1899 vec.
reinit(mat.locally_owned_domain_indices(),
1900 mat.get_mpi_communicator());
1904 template <
typename MatrixType,
1905 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1906 std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1910 is_supported_operation<initialize_dof_vector_t, MatrixType>,
1912 MatrixType> * =
nullptr>
1916 bool omit_zeroing_entries)
1918 mat.initialize_dof_vector(vec);
1919 if (!omit_zeroing_entries)
1924 template <
typename MatrixType,
1925 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1926 std::enable_if_t<has_get_mpi_communicator<MatrixType> &&
1927 has_locally_owned_range_indices<MatrixType>,
1931 is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1935 MatrixType> * =
nullptr>
1941 vec.
reinit(mat.locally_owned_range_indices(),
1942 mat.get_mpi_communicator());
1946 template <
typename MatrixType,
1947 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1948 std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1952 is_supported_operation<initialize_dof_vector_t, MatrixType>,
1954 MatrixType> * =
nullptr>
1958 bool omit_zeroing_entries)
1960 mat.initialize_dof_vector(vec);
1961 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
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
const value_type & const_reference
Number & operator[](const size_type global_index)
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)
real_type linfty_norm_local() const
void compress_finish(VectorOperation::values operation)
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
typename numbers::NumberTraits< Number >::real_type real_type
const_iterator end() const
Number & local_element(const size_type local_index)
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)
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)
real_type norm_sqr_local() const
void reinit(const IndexSet &local_range, const IndexSet &ghost_indices, const MPI_Comm communicator)
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
Vector(const IndexSet &local_range, const IndexSet &ghost_indices, const MPI_Comm communicator)
void add(const std::vector< size_type > &indices, const ::Vector< OtherNumber > &values)
void import_elements(const Vector< Number, MemorySpace2 > &src, VectorOperation::values operation)
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)
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
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
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
virtual void compress(VectorOperation::values operation) 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 sadd_local(const Number s, const Number a, const VectorSpaceVector< Number > &V)
void reinit(const size_type size, const bool omit_zeroing_entries=false)
const std::vector< ArrayView< const Number > > & shared_vector_data() const
MPI_Comm get_mpi_communicator() 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
void compress_start(const unsigned int communication_channel=0, VectorOperation::values operation=VectorOperation::add)
virtual Vector< Number, MemorySpace > & operator*=(const Number factor) override
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
Vector< Number, MemorySpace > & operator=(Vector< Number, MemorySpace > &&in_vector)
Number inner_product_local(const Vector< Number2, MemorySpace > &V) const
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
virtual Number add_and_dot(const Number a, const VectorSpaceVector< Number > &V, const VectorSpaceVector< Number > &W) override
void resize_val(const size_type new_allocated_size, const MPI_Comm comm_sm=MPI_COMM_SELF)
virtual real_type l2_norm() const override
virtual void import_elements(const LinearAlgebra::ReadWriteVector< Number > &V, VectorOperation::values operation, std::shared_ptr< const Utilities::MPI::CommunicationPatternBase > communication_pattern={}) override
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)
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)
#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