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
249 template <
typename Number,
typename MemorySpace = MemorySpace::Host>
265 std::is_same_v<MemorySpace, ::MemorySpace::Host> ||
266 std::is_same_v<MemorySpace, ::MemorySpace::Default>,
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;
677 template <
typename Number2>
691 template <
typename MemorySpace2>
699 template <
typename MemorySpace2>
753 const std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
754 &communication_pattern = {});
762 std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
763 communication_pattern = {})
800 add(
const std::vector<size_type> &indices,
801 const std::vector<Number> &
values);
904 const unsigned int precision = 3,
905 const bool scientific =
true,
906 const bool across =
true)
const;
932 template <
typename OtherNumber>
934 add(
const std::vector<size_type> &indices,
935 const ::Vector<OtherNumber> &
values);
941 template <
typename OtherNumber>
945 const OtherNumber *
values);
1110 template <
typename OtherNumber>
1113 std::vector<OtherNumber> &
values)
const;
1150 template <
typename ForwardIterator,
typename OutputIterator>
1153 const ForwardIterator indices_end,
1154 OutputIterator values_begin)
const;
1194 const std::shared_ptr<const Utilities::MPI::Partitioner> &
1237 const std::vector<ArrayView<const Number>> &
1256 <<
"Called compress(VectorOperation::insert), but"
1257 <<
" the element received from a remote processor, value "
1258 << std::setprecision(16) << arg1
1259 <<
", does not match with the value "
1260 << std::setprecision(16) << arg2
1261 <<
" on the owner processor " << arg3);
1272 <<
"You tried to access element " << arg1
1273 <<
" of a distributed vector, but this element is not "
1274 <<
"stored on the current processor. Note: The range of "
1275 <<
"locally owned elements is [" << arg2 <<
',' << arg3
1276 <<
"], and there are " << arg4 <<
" ghost elements "
1277 <<
"that this vector can access."
1279 <<
"A common source for this kind of problem is that you "
1280 <<
"are passing a 'fully distributed' vector into a function "
1281 <<
"that needs read access to vector elements that correspond "
1282 <<
"to degrees of freedom on ghost cells (or at least to "
1283 <<
"'locally active' degrees of freedom that are not also "
1284 <<
"'locally owned'). You need to pass a vector that has these "
1285 <<
"elements as ghost entries.");
1307 template <
typename Number2>
1366 mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace>
data;
1372 mutable std::shared_ptr<::parallel::internal::TBBPartitioner>
1379 mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace>
1391 #ifdef DEAL_II_WITH_MPI
1435 const MPI_Comm
comm_sm = MPI_COMM_SELF);
1438 template <
typename Number2,
typename MemorySpace2>
1442 template <
typename Number2>
1452 template <
typename Number,
typename MemorySpace>
1456 return vector_is_ghosted;
1461 template <
typename Number,
typename MemorySpace>
1465 return partitioner->size();
1470 template <
typename Number,
typename MemorySpace>
1474 return partitioner->locally_owned_size();
1479 template <
typename Number,
typename MemorySpace>
1489 template <
typename Number,
typename MemorySpace>
1495 is.add_range(partitioner->local_range().first,
1496 partitioner->local_range().second);
1503 template <
typename Number,
typename MemorySpace>
1507 return data.values.data();
1512 template <
typename Number,
typename MemorySpace>
1516 return data.values.data();
1521 template <
typename Number,
typename MemorySpace>
1525 return data.values.data() + partitioner->locally_owned_size();
1530 template <
typename Number,
typename MemorySpace>
1534 return data.values.data() + partitioner->locally_owned_size();
1539 template <
typename Number,
typename MemorySpace>
1540 const std::vector<ArrayView<const Number>> &
1543 return data.values_sm;
1548 template <
typename Number,
typename MemorySpace>
1552 Assert((std::is_same_v<MemorySpace, ::MemorySpace::Host>),
1554 "This function is only implemented for the Host memory space"));
1559 partitioner->local_range().first,
1560 partitioner->local_range().second == 0 ?
1562 (partitioner->local_range().second - 1),
1563 partitioner->ghost_indices().n_elements()));
1566 vector_is_ghosted ==
true,
1567 ExcMessage(
"You tried to read a ghost element of this vector, "
1568 "but it has not imported its ghost values."));
1569 return data.values[partitioner->global_to_local(
global_index)];
1574 template <
typename Number,
typename MemorySpace>
1578 Assert((std::is_same_v<MemorySpace, ::MemorySpace::Host>),
1580 "This function is only implemented for the Host memory space"));
1585 partitioner->local_range().first,
1586 partitioner->local_range().second == 0 ?
1588 (partitioner->local_range().second - 1),
1589 partitioner->ghost_indices().n_elements()));
1596 return data.values[partitioner->global_to_local(
global_index)];
1601 template <
typename Number,
typename MemorySpace>
1610 template <
typename Number,
typename MemorySpace>
1619 template <
typename Number,
typename MemorySpace>
1624 Assert((std::is_same_v<MemorySpace, ::MemorySpace::Host>),
1626 "This function is only implemented for the Host memory space"));
1628 partitioner->locally_owned_size() +
1629 partitioner->n_ghost_indices());
1632 ExcMessage(
"You tried to read a ghost element of this vector, "
1633 "but it has not imported its ghost values."));
1635 return data.values[local_index];
1640 template <
typename Number,
typename MemorySpace>
1644 Assert((std::is_same_v<MemorySpace, ::MemorySpace::Host>),
1646 "This function is only implemented for the Host memory space"));
1649 partitioner->locally_owned_size() +
1650 partitioner->n_ghost_indices());
1652 return data.values[local_index];
1657 template <
typename Number,
typename MemorySpace>
1661 return data.values.data();
1666 template <
typename Number,
typename MemorySpace>
1667 template <
typename OtherNumber>
1670 const std::vector<size_type> &indices,
1671 std::vector<OtherNumber> &
values)
const
1673 for (
size_type i = 0; i < indices.size(); ++i)
1674 values[i] =
operator()(indices[i]);
1679 template <
typename Number,
typename MemorySpace>
1680 template <
typename ForwardIterator,
typename OutputIterator>
1683 ForwardIterator indices_begin,
1684 const ForwardIterator indices_end,
1685 OutputIterator values_begin)
const
1687 while (indices_begin != indices_end)
1697 template <
typename Number,
typename MemorySpace>
1698 template <
typename OtherNumber>
1701 const std::vector<size_type> &indices,
1702 const ::Vector<OtherNumber> &
values)
1705 for (
size_type i = 0; i < indices.size(); ++i)
1710 "The given value is not finite but either infinite or Not A Number (NaN)"));
1717 template <
typename Number,
typename MemorySpace>
1718 template <
typename OtherNumber>
1722 const OtherNumber *
values)
1729 "The given value is not finite but either infinite or Not A Number (NaN)"));
1736 template <
typename Number,
typename MemorySpace>
1740 return partitioner->get_mpi_communicator();
1745 template <
typename Number,
typename MemorySpace>
1746 inline const std::shared_ptr<const Utilities::MPI::Partitioner> &
1754 template <
typename Number,
typename MemorySpace>
1758 vector_is_ghosted = ghosted;
1774 template <
typename Number,
typename MemorySpace>
1786 template <
typename Number,
typename MemorySpace>
1795 namespace LinearOperatorImplementation
1804 template <
typename Number>
1810 template <
typename T>
1812 decltype(std::declval<T>().get_mpi_communicator());
1814 template <
typename T>
1815 static constexpr
bool has_get_mpi_communicator =
1816 is_supported_operation<get_mpi_communicator_t, T>;
1820 template <
typename T>
1822 decltype(std::declval<T>().locally_owned_domain_indices());
1824 template <
typename T>
1825 static constexpr
bool has_locally_owned_domain_indices =
1826 is_supported_operation<locally_owned_domain_indices_t, T>;
1830 template <
typename T>
1832 decltype(std::declval<T>().locally_owned_range_indices());
1834 template <
typename T>
1835 static constexpr
bool has_locally_owned_range_indices =
1836 is_supported_operation<locally_owned_range_indices_t, T>;
1840 template <
typename T>
1842 decltype(std::declval<T>().initialize_dof_vector(
1845 template <
typename T>
1846 static constexpr
bool has_initialize_dof_vector =
1847 is_supported_operation<initialize_dof_vector_t, T>;
1850 template <
typename MatrixType,
1851 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1852 std::enable_if_t<has_get_mpi_communicator<MatrixType> &&
1853 has_locally_owned_domain_indices<MatrixType>,
1857 is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1861 MatrixType> * =
nullptr>
1867 vec.
reinit(mat.locally_owned_domain_indices(),
1868 mat.get_mpi_communicator());
1872 template <
typename MatrixType,
1873 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1874 std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1878 is_supported_operation<initialize_dof_vector_t, MatrixType>,
1880 MatrixType> * =
nullptr>
1884 bool omit_zeroing_entries)
1886 mat.initialize_dof_vector(vec);
1887 if (!omit_zeroing_entries)
1892 template <
typename MatrixType,
1893 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1894 std::enable_if_t<has_get_mpi_communicator<MatrixType> &&
1895 has_locally_owned_range_indices<MatrixType>,
1899 is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1903 MatrixType> * =
nullptr>
1909 vec.
reinit(mat.locally_owned_range_indices(),
1910 mat.get_mpi_communicator());
1914 template <
typename MatrixType,
1915 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1916 std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1920 is_supported_operation<initialize_dof_vector_t, MatrixType>,
1922 MatrixType> * =
nullptr>
1926 bool omit_zeroing_entries)
1928 mat.initialize_dof_vector(vec);
1929 if (!omit_zeroing_entries)
virtual size_type size() const override
value_type operator()(const size_type i) const
std::size_t locally_owned_size() const
void zero_out_ghost_values() const
real_type linfty_norm() const
Number mean_value_local() const
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 & 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)
Number mean_value() const
real_type linfty_norm_local() const
void compress_finish(VectorOperation::values operation)
void update_ghost_values() const
mutable ::MemorySpace::MemorySpaceData< Number, MemorySpace > import_data
void swap(Vector< Number, MemorySpace > &v)
real_type l1_norm_local() const
mutable ::MemorySpace::MemorySpaceData< Number, MemorySpace > data
void equ(const Number a, const Vector< Number, MemorySpace > &V)
types::global_dof_index size_type
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
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)
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)
real_type norm_sqr_local() const
void reinit(const IndexSet &local_range, const IndexSet &ghost_indices, const MPI_Comm communicator)
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
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
virtual void extract_subvector_to(const ArrayView< const types::global_dof_index > &indices, ArrayView< Number > &elements) const override
real_type l2_norm() const
void compress(VectorOperation::values operation)
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)
Vector< Number, MemorySpace > & operator-=(const Vector< Number, MemorySpace > &V)
void add(const Number a, const Vector< Number, MemorySpace > &V, const Number b, const Vector< Number, MemorySpace > &W)
const value_type * const_pointer
Vector< Number, MemorySpace > & operator=(const Number s)
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
Vector< Number, MemorySpace > & operator/=(const Number factor)
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
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< Number, MemorySpace > &in_vector)
Number operator()(const size_type global_index) const
real_type lp_norm_local(const real_type p) const
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)
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)
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
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
Vector< Number, MemorySpace > & operator+=(const Vector< Number, MemorySpace > &V)
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< Number, MemorySpace > & operator*=(const Number factor)
Vector(const std::shared_ptr< const Utilities::MPI::Partitioner > &partitioner)
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