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>
606 const unsigned int communication_channel = 0)
const;
671 template <
typename Number2>
685 template <
typename MemorySpace2>
703 const bool omit_zeroing_entries =
false)
override;
743 std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
744 communication_pattern = {})
override;
756 add(
const Number a)
override;
778 add(
const std::vector<size_type> &indices,
779 const std::vector<Number> &
values);
882 const unsigned int precision = 3,
883 const bool scientific =
true,
884 const bool across =
true)
const override;
910 template <
typename OtherNumber>
912 add(
const std::vector<size_type> & indices,
913 const ::Vector<OtherNumber> &
values);
919 template <
typename OtherNumber>
923 const OtherNumber *
values);
1098 template <
typename OtherNumber>
1101 std::vector<OtherNumber> &
values)
const;
1130 template <
typename ForwardIterator,
typename OutputIterator>
1133 const ForwardIterator indices_end,
1134 OutputIterator values_begin)
const;
1175 const std::shared_ptr<const Utilities::MPI::Partitioner> &
1218 const std::vector<ArrayView<const Number>> &
1244 <<
"Called compress(VectorOperation::insert), but"
1245 <<
" the element received from a remote processor, value "
1246 << std::setprecision(16) << arg1
1247 <<
", does not match with the value "
1248 << std::setprecision(16) << arg2
1249 <<
" on the owner processor " << arg3);
1260 <<
"You tried to access element " << arg1
1261 <<
" of a distributed vector, but this element is not "
1262 <<
"stored on the current processor. Note: The range of "
1263 <<
"locally owned elements is [" << arg2 <<
',' << arg3
1264 <<
"], and there are " << arg4 <<
" ghost elements "
1265 <<
"that this vector can access."
1267 <<
"A common source for this kind of problem is that you "
1268 <<
"are passing a 'fully distributed' vector into a function "
1269 <<
"that needs read access to vector elements that correspond "
1270 <<
"to degrees of freedom on ghost cells (or at least to "
1271 <<
"'locally active' degrees of freedom that are not also "
1272 <<
"'locally owned'). You need to pass a vector that has these "
1273 <<
"elements as ghost entries.");
1295 template <
typename Number2>
1354 mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace>
data;
1360 mutable std::shared_ptr<::parallel::internal::TBBPartitioner>
1367 mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace>
1379 #ifdef DEAL_II_WITH_MPI
1423 const MPI_Comm &
comm_sm = MPI_COMM_SELF);
1426 template <
typename Number2,
typename MemorySpace2>
1430 template <
typename Number2>
1440 template <
typename Number,
typename MemorySpace>
1444 return vector_is_ghosted;
1449 template <
typename Number,
typename MemorySpace>
1453 return partitioner->size();
1458 template <
typename Number,
typename MemorySpace>
1467 template <
typename Number,
typename MemorySpace>
1471 return partitioner->locally_owned_size();
1476 template <
typename Number,
typename MemorySpace>
1486 template <
typename Number,
typename MemorySpace>
1492 is.add_range(partitioner->local_range().first,
1493 partitioner->local_range().second);
1500 template <
typename Number,
typename MemorySpace>
1504 return data.values.data();
1509 template <
typename Number,
typename MemorySpace>
1513 return data.values.data();
1518 template <
typename Number,
typename MemorySpace>
1522 return data.values.data() + partitioner->locally_owned_size();
1527 template <
typename Number,
typename MemorySpace>
1531 return data.values.data() + partitioner->locally_owned_size();
1536 template <
typename Number,
typename MemorySpace>
1537 const std::vector<ArrayView<const Number>> &
1540 return data.values_sm;
1545 template <
typename Number,
typename MemorySpace>
1549 Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1551 "This function is only implemented for the Host memory space"));
1556 partitioner->local_range().first,
1557 partitioner->local_range().second == 0 ?
1559 (partitioner->local_range().second - 1),
1560 partitioner->ghost_indices().n_elements()));
1563 vector_is_ghosted ==
true,
1564 ExcMessage(
"You tried to read a ghost element of this vector, "
1565 "but it has not imported its ghost values."));
1566 return data.values[partitioner->global_to_local(
global_index)];
1571 template <
typename Number,
typename MemorySpace>
1575 Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1577 "This function is only implemented for the Host memory space"));
1582 partitioner->local_range().first,
1583 partitioner->local_range().second == 0 ?
1585 (partitioner->local_range().second - 1),
1586 partitioner->ghost_indices().n_elements()));
1593 return data.values[partitioner->global_to_local(
global_index)];
1598 template <
typename Number,
typename MemorySpace>
1607 template <
typename Number,
typename MemorySpace>
1616 template <
typename Number,
typename MemorySpace>
1621 Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1623 "This function is only implemented for the Host memory space"));
1625 partitioner->locally_owned_size() +
1626 partitioner->n_ghost_indices());
1629 ExcMessage(
"You tried to read a ghost element of this vector, "
1630 "but it has not imported its ghost values."));
1632 return data.values[local_index];
1637 template <
typename Number,
typename MemorySpace>
1641 Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1643 "This function is only implemented for the Host memory space"));
1646 partitioner->locally_owned_size() +
1647 partitioner->n_ghost_indices());
1649 return data.values[local_index];
1654 template <
typename Number,
typename MemorySpace>
1658 return data.values.data();
1663 template <
typename Number,
typename MemorySpace>
1664 template <
typename OtherNumber>
1667 const std::vector<size_type> &indices,
1668 std::vector<OtherNumber> &
values)
const
1670 for (
size_type i = 0; i < indices.size(); ++i)
1671 values[i] =
operator()(indices[i]);
1676 template <
typename Number,
typename MemorySpace>
1677 template <
typename ForwardIterator,
typename OutputIterator>
1680 ForwardIterator indices_begin,
1681 const ForwardIterator indices_end,
1682 OutputIterator values_begin)
const
1684 while (indices_begin != indices_end)
1694 template <
typename Number,
typename MemorySpace>
1695 template <
typename OtherNumber>
1698 const std::vector<size_type> & indices,
1699 const ::Vector<OtherNumber> &
values)
1702 for (
size_type i = 0; i < indices.size(); ++i)
1707 "The given value is not finite but either infinite or Not A Number (NaN)"));
1714 template <
typename Number,
typename MemorySpace>
1715 template <
typename OtherNumber>
1719 const OtherNumber *
values)
1726 "The given value is not finite but either infinite or Not A Number (NaN)"));
1733 template <
typename Number,
typename MemorySpace>
1734 inline const MPI_Comm &
1737 return partitioner->get_mpi_communicator();
1742 template <
typename Number,
typename MemorySpace>
1743 inline const std::shared_ptr<const Utilities::MPI::Partitioner> &
1751 template <
typename Number,
typename MemorySpace>
1755 vector_is_ghosted = ghosted;
1771 template <
typename Number,
typename MemorySpace>
1783 template <
typename Number,
typename MemorySpace>
1792 namespace LinearOperatorImplementation
1801 template <
typename Number>
1807 template <
typename T>
1809 decltype(std::declval<T>().get_mpi_communicator());
1811 template <
typename T>
1812 static constexpr
bool has_get_mpi_communicator =
1813 is_supported_operation<get_mpi_communicator_t, T>;
1817 template <
typename T>
1819 decltype(std::declval<T>().locally_owned_domain_indices());
1821 template <
typename T>
1822 static constexpr
bool has_locally_owned_domain_indices =
1823 is_supported_operation<locally_owned_domain_indices_t, T>;
1827 template <
typename T>
1829 decltype(std::declval<T>().locally_owned_range_indices());
1831 template <
typename T>
1832 static constexpr
bool has_locally_owned_range_indices =
1833 is_supported_operation<locally_owned_range_indices_t, T>;
1837 template <
typename T>
1839 decltype(std::declval<T>().initialize_dof_vector(
1842 template <
typename T>
1843 static constexpr
bool has_initialize_dof_vector =
1844 is_supported_operation<initialize_dof_vector_t, T>;
1847 template <
typename MatrixType,
1848 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1849 std::enable_if_t<has_get_mpi_communicator<MatrixType> &&
1850 has_locally_owned_domain_indices<MatrixType>,
1854 is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1858 MatrixType> * =
nullptr>
1864 vec.
reinit(mat.locally_owned_domain_indices(),
1865 mat.get_mpi_communicator());
1869 template <
typename MatrixType,
1870 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1871 std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1875 is_supported_operation<initialize_dof_vector_t, MatrixType>,
1877 MatrixType> * =
nullptr>
1881 bool omit_zeroing_entries)
1883 mat.initialize_dof_vector(vec);
1884 if (!omit_zeroing_entries)
1889 template <
typename MatrixType,
1890 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1891 std::enable_if_t<has_get_mpi_communicator<MatrixType> &&
1892 has_locally_owned_range_indices<MatrixType>,
1896 is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1900 MatrixType> * =
nullptr>
1906 vec.
reinit(mat.locally_owned_range_indices(),
1907 mat.get_mpi_communicator());
1911 template <
typename MatrixType,
1912 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1913 std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1917 is_supported_operation<initialize_dof_vector_t, MatrixType>,
1919 MatrixType> * =
nullptr>
1923 bool omit_zeroing_entries)
1925 mat.initialize_dof_vector(vec);
1926 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
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
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)
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
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 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
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
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