Loading [MathJax]/extensions/TeX/AMSsymbols.js
 deal.II version GIT relicensing-3041-g9c4075ddf4 2025-04-07 16:30:00+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages Concepts
la_parallel_vector.h
Go to the documentation of this file.
1// ------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: LGPL-2.1-or-later
4// Copyright (C) 2012 - 2024 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Part of the source code is dual licensed under Apache-2.0 WITH
9// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10// governing the source code and code contributions can be found in
11// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12//
13// ------------------------------------------------------------------------
14
15#ifndef dealii_la_parallel_vector_h
16#define dealii_la_parallel_vector_h
17
18#include <deal.II/base/config.h>
19
28
32
33#include <iomanip>
34#include <memory>
35
36#if defined(DEAL_II_WITH_MPI)
38# include <mpi.h>
40#endif
41
42
44
45// Forward declarations
46#ifndef DOXYGEN
47namespace LinearAlgebra
48{
52 namespace distributed
53 {
54 template <typename, typename>
55 class BlockVector;
56 }
57
58 template <typename>
59 class ReadWriteVector;
60} // namespace LinearAlgebra
61
62# ifdef DEAL_II_WITH_PETSC
63namespace PETScWrappers
64{
65 namespace MPI
66 {
67 class Vector;
68 }
69} // namespace PETScWrappers
70# endif
71
72# ifdef DEAL_II_WITH_TRILINOS
73namespace TrilinosWrappers
74{
75 namespace MPI
76 {
77 class Vector;
78 }
79} // namespace TrilinosWrappers
80# endif
81#endif
82
83namespace LinearAlgebra
84{
85 namespace distributed
86 {
255 template <typename Number, typename MemorySpace = MemorySpace::Host>
256 class Vector : public ::ReadVector<Number>
257 {
258 public:
260 using value_type = Number;
262 using const_pointer = const value_type *;
264 using const_iterator = const value_type *;
269
270 static_assert(
271 std::is_same_v<MemorySpace, ::MemorySpace::Host> ||
272 std::is_same_v<MemorySpace, ::MemorySpace::Default>,
273 "MemorySpace should be Host or Default");
274
283
291
299 Vector(Vector<Number, MemorySpace> &&in_vector); // NOLINT
300
306
324 const IndexSet &ghost_indices,
325 const MPI_Comm communicator);
326
330 Vector(const IndexSet &local_range, const MPI_Comm communicator);
331
339 const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
340
345
350 void
351 reinit(const size_type size, const bool omit_zeroing_entries = false);
352
363 template <typename Number2>
364 void
366 const bool omit_zeroing_entries = false);
367
384 void
386 const IndexSet &ghost_indices,
387 const MPI_Comm communicator);
388
392 void
393 reinit(const IndexSet &local_range, const MPI_Comm communicator);
394
407 void
409 const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner,
410 const MPI_Comm comm_sm = MPI_COMM_SELF);
411
418 void
420 const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner,
421 const bool make_ghosted,
422 const MPI_Comm &comm_sm = MPI_COMM_SELF);
423
443 void
445 const types::global_dof_index ghost_size,
446 const MPI_Comm comm,
447 const MPI_Comm comm_sm = MPI_COMM_SELF);
448
461 void
463
472
503
515 template <typename Number2>
518
560 void
562
584 void
586
604 void
605 compress_start(const unsigned int communication_channel = 0,
607
626 void
628
646 void
648 const unsigned int communication_channel = 0) const;
649
650
658 void
660
669 void
671
683 bool
685
700 template <typename Number2>
701 void
703
714 template <typename MemorySpace2>
715 void
717 VectorOperation::values operation);
718
722 template <typename MemorySpace2>
725 VectorOperation::values operation)
726 {
727 import_elements(src, operation);
728 }
729
741 operator*=(const Number factor);
742
747 operator/=(const Number factor);
748
754
760
772 void
775 const VectorOperation::values operation,
776 const std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
777 &communication_pattern = {});
778
784 VectorOperation::values operation,
785 std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
786 communication_pattern = {})
787 {
788 import_elements(V, operation, communication_pattern);
789 }
790
794 Number
796
800 void
801 add(const Number a);
802
806 void
807 add(const Number a, const Vector<Number, MemorySpace> &V);
808
812 void
813 add(const Number a,
815 const Number b,
817
822 void
823 add(const std::vector<size_type> &indices,
824 const std::vector<Number> &values);
825
830 void
831 sadd(const Number s,
832 const Number a,
834
840 void
841 scale(const Vector<Number, MemorySpace> &scaling_factors);
842
846 void
847 equ(const Number a, const Vector<Number, MemorySpace> &V);
848
854 l1_norm() const;
855
861 l2_norm() const;
862
867 norm_sqr() const;
868
874 linfty_norm() const;
875
896 Number
897 add_and_dot(const Number a,
900
905 virtual size_type
906 size() const override;
907
921
925 void
926 print(std::ostream &out,
927 const unsigned int precision = 3,
928 const bool scientific = true,
929 const bool across = true) const;
930
934 std::size_t
949 operator=(const Number s);
950
955 template <typename OtherNumber>
956 void
957 add(const std::vector<size_type> &indices,
958 const ::Vector<OtherNumber> &values);
959
964 template <typename OtherNumber>
965 void
966 add(const size_type n_elements,
967 const size_type *indices,
968 const OtherNumber *values);
969
974 void
975 sadd(const Number s, const Vector<Number, MemorySpace> &V);
976
991
996 bool
997 in_local_range(const size_type global_index) const;
998
1009 iterator
1011
1020 begin() const;
1021
1029 iterator
1031
1040 end() const;
1041
1051 Number
1052 operator()(const size_type global_index) const;
1053
1063 Number &
1064 operator()(const size_type global_index);
1065
1073 Number
1074 operator[](const size_type global_index) const;
1082 Number &
1083 operator[](const size_type global_index);
1084
1093 Number
1094 local_element(const size_type local_index) const;
1095
1104 Number &
1105 local_element(const size_type local_index);
1106
1113 Number *
1114 get_values() const;
1115
1133 template <typename OtherNumber>
1134 void
1135 extract_subvector_to(const std::vector<size_type> &indices,
1136 std::vector<OtherNumber> &values) const;
1137
1141 virtual void
1144 const ArrayView<Number> &elements) const override;
1145
1173 template <typename ForwardIterator, typename OutputIterator>
1174 void
1175 extract_subvector_to(ForwardIterator indices_begin,
1176 const ForwardIterator indices_end,
1177 OutputIterator values_begin) const;
1183 bool
1184 all_zero() const;
1185
1189 Number
1190 mean_value() const;
1191
1196 real_type
1197 lp_norm(const real_type p) const;
1208 MPI_Comm
1210
1217 const std::shared_ptr<const Utilities::MPI::Partitioner> &
1219
1229 bool
1231 const Utilities::MPI::Partitioner &part) const;
1232
1246 bool
1248 const Utilities::MPI::Partitioner &part) const;
1249
1253 void
1254 set_ghost_state(const bool ghosted) const;
1255
1260 const std::vector<ArrayView<const Number>> &
1262
1271
1276 Number,
1277 Number,
1278 unsigned int,
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);
1285
1291 size_type,
1292 size_type,
1293 size_type,
1294 size_type,
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."
1301 << "\n\n"
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.");
1309
1310 private:
1315 void
1316 add_local(const Number a, const Vector<Number, MemorySpace> &V);
1317
1322 void
1323 sadd_local(const Number s,
1324 const Number a,
1326
1330 template <typename Number2>
1331 Number
1333
1337 real_type
1339
1343 Number
1345
1349 real_type
1351
1355 real_type
1356 lp_norm_local(const real_type p) const;
1357
1361 real_type
1363
1369 Number
1370 add_and_dot_local(const Number a,
1373
1381 void
1383
1389 std::shared_ptr<const Utilities::MPI::Partitioner> partitioner;
1390
1395
1399 mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace> data;
1400
1405 mutable std::shared_ptr<::parallel::internal::TBBPartitioner>
1407
1412 mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace>
1414
1422 mutable bool vector_is_ghosted;
1423
1424#ifdef DEAL_II_WITH_MPI
1433 std::vector<MPI_Request> compress_requests;
1434
1439 mutable std::vector<MPI_Request> update_ghost_values_requests;
1440#endif
1441
1447 mutable std::mutex mutex;
1448
1455
1460 void
1462
1466 void
1467 resize_val(const size_type new_allocated_size,
1468 const MPI_Comm comm_sm = MPI_COMM_SELF);
1469
1470 // Make all other vector types friends.
1471 template <typename Number2, typename MemorySpace2>
1472 friend class Vector;
1473
1474 // Make BlockVector type friends.
1475 template <typename Number2, typename MemorySpace2>
1476 friend class BlockVector;
1477 };
1481 /*-------------------- Inline functions ---------------------------------*/
1482
1483#ifndef DOXYGEN
1484
1485 template <typename Number, typename MemorySpace>
1486 inline bool
1488 {
1489 return vector_is_ghosted;
1490 }
1491
1492
1493
1494 template <typename Number, typename MemorySpace>
1497 {
1498 return partitioner->size();
1499 }
1500
1501
1502
1503 template <typename Number, typename MemorySpace>
1506 {
1507 return partitioner->locally_owned_size();
1508 }
1509
1510
1511
1512 template <typename Number, typename MemorySpace>
1513 inline bool
1515 const size_type global_index) const
1516 {
1517 return partitioner->in_local_range(global_index);
1518 }
1519
1520
1521
1522 template <typename Number, typename MemorySpace>
1523 inline IndexSet
1525 {
1526 IndexSet is(size());
1527
1528 is.add_range(partitioner->local_range().first,
1529 partitioner->local_range().second);
1530
1531 return is;
1532 }
1533
1534
1535
1536 template <typename Number, typename MemorySpace>
1539 {
1540 return data.values.data();
1541 }
1542
1543
1544
1545 template <typename Number, typename MemorySpace>
1548 {
1549 return data.values.data();
1550 }
1551
1552
1553
1554 template <typename Number, typename MemorySpace>
1557 {
1558 return data.values.data() + partitioner->locally_owned_size();
1559 }
1560
1561
1562
1563 template <typename Number, typename MemorySpace>
1566 {
1567 return data.values.data() + partitioner->locally_owned_size();
1568 }
1569
1570
1571
1572 template <typename Number, typename MemorySpace>
1573 const std::vector<ArrayView<const Number>> &
1575 {
1576 return data.values_sm;
1577 }
1578
1579
1580
1581 template <typename Number, typename MemorySpace>
1582 inline Number
1583 Vector<Number, MemorySpace>::operator()(const size_type global_index) const
1584 {
1585 Assert((std::is_same_v<MemorySpace, ::MemorySpace::Host>),
1586 ExcMessage(
1587 "This function is only implemented for the Host memory space"));
1588 Assert(
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 ?
1594 0 :
1595 (partitioner->local_range().second - 1),
1596 partitioner->ghost_indices().n_elements()));
1597 // do not allow reading a vector which is not in ghost mode
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)];
1603 }
1604
1605
1606
1607 template <typename Number, typename MemorySpace>
1608 inline Number &
1609 Vector<Number, MemorySpace>::operator()(const size_type global_index)
1610 {
1611 Assert((std::is_same_v<MemorySpace, ::MemorySpace::Host>),
1612 ExcMessage(
1613 "This function is only implemented for the Host memory space"));
1614 Assert(
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 ?
1620 0 :
1621 (partitioner->local_range().second - 1),
1622 partitioner->ghost_indices().n_elements()));
1623 // we would like to prevent reading ghosts from a vector that does not
1624 // have them imported, but this is not possible because we might be in a
1625 // part of the code where the vector has enabled ghosts but is non-const
1626 // (then, the compiler picks this method according to the C++ rule book
1627 // even if a human would pick the const method when this subsequent use
1628 // is just a read)
1629 return data.values[partitioner->global_to_local(global_index)];
1630 }
1631
1632
1633
1634 template <typename Number, typename MemorySpace>
1635 inline Number
1636 Vector<Number, MemorySpace>::operator[](const size_type global_index) const
1637 {
1638 return operator()(global_index);
1639 }
1640
1641
1642
1643 template <typename Number, typename MemorySpace>
1644 inline Number &
1645 Vector<Number, MemorySpace>::operator[](const size_type global_index)
1646 {
1647 return operator()(global_index);
1648 }
1649
1650
1651
1652 template <typename Number, typename MemorySpace>
1653 inline Number
1655 const size_type local_index) const
1656 {
1657 Assert((std::is_same_v<MemorySpace, ::MemorySpace::Host>),
1658 ExcMessage(
1659 "This function is only implemented for the Host memory space"));
1660 AssertIndexRange(local_index,
1661 partitioner->locally_owned_size() +
1662 partitioner->n_ghost_indices());
1663 // do not allow reading a vector which is not in ghost mode
1664 Assert(local_index < locally_owned_size() || vector_is_ghosted == true,
1665 ExcMessage("You tried to read a ghost element of this vector, "
1666 "but it has not imported its ghost values."));
1667
1668 return data.values[local_index];
1669 }
1670
1671
1672
1673 template <typename Number, typename MemorySpace>
1674 inline Number &
1675 Vector<Number, MemorySpace>::local_element(const size_type local_index)
1676 {
1677 Assert((std::is_same_v<MemorySpace, ::MemorySpace::Host>),
1678 ExcMessage(
1679 "This function is only implemented for the Host memory space"));
1680
1681 AssertIndexRange(local_index,
1682 partitioner->locally_owned_size() +
1683 partitioner->n_ghost_indices());
1684
1685 return data.values[local_index];
1686 }
1687
1688
1689
1690 template <typename Number, typename MemorySpace>
1691 inline Number *
1693 {
1694 return data.values.data();
1695 }
1696
1697
1698
1699 template <typename Number, typename MemorySpace>
1700 template <typename OtherNumber>
1701 inline void
1703 const std::vector<size_type> &indices,
1704 std::vector<OtherNumber> &values) const
1705 {
1706 for (size_type i = 0; i < indices.size(); ++i)
1707 values[i] = operator()(indices[i]);
1708 }
1709
1710
1711
1712 template <typename Number, typename MemorySpace>
1713 template <typename ForwardIterator, typename OutputIterator>
1714 inline void
1716 ForwardIterator indices_begin,
1717 const ForwardIterator indices_end,
1718 OutputIterator values_begin) const
1719 {
1720 while (indices_begin != indices_end)
1721 {
1722 *values_begin = operator()(*indices_begin);
1723 ++indices_begin;
1724 ++values_begin;
1725 }
1726 }
1727
1728
1729
1730 template <typename Number, typename MemorySpace>
1731 template <typename OtherNumber>
1732 inline void
1734 const std::vector<size_type> &indices,
1735 const ::Vector<OtherNumber> &values)
1736 {
1737 AssertDimension(indices.size(), values.size());
1738 for (size_type i = 0; i < indices.size(); ++i)
1739 {
1740 Assert(
1741 numbers::is_finite(values[i]),
1742 ExcMessage(
1743 "The given value is not finite but either infinite or Not A Number (NaN)"));
1744 this->operator()(indices[i]) += values(i);
1745 }
1746 }
1747
1748
1749
1750 template <typename Number, typename MemorySpace>
1751 template <typename OtherNumber>
1752 inline void
1753 Vector<Number, MemorySpace>::add(const size_type n_elements,
1754 const size_type *indices,
1755 const OtherNumber *values)
1756 {
1757 for (size_type i = 0; i < n_elements; ++i, ++indices, ++values)
1758 {
1759 Assert(
1760 numbers::is_finite(*values),
1761 ExcMessage(
1762 "The given value is not finite but either infinite or Not A Number (NaN)"));
1763 this->operator()(*indices) += *values;
1764 }
1765 }
1766
1767
1768
1769 template <typename Number, typename MemorySpace>
1770 inline MPI_Comm
1772 {
1773 return partitioner->get_mpi_communicator();
1774 }
1775
1776
1777
1778 template <typename Number, typename MemorySpace>
1779 inline const std::shared_ptr<const Utilities::MPI::Partitioner> &
1781 {
1782 return partitioner;
1783 }
1784
1785
1786
1787 template <typename Number, typename MemorySpace>
1788 inline void
1789 Vector<Number, MemorySpace>::set_ghost_state(const bool ghosted) const
1790 {
1791 vector_is_ghosted = ghosted;
1792 }
1793
1794#endif
1795
1796 } // namespace distributed
1797} // namespace LinearAlgebra
1798
1799
1807template <typename Number, typename MemorySpace>
1808inline void
1814
1815
1819template <typename Number, typename MemorySpace>
1820struct is_serial_vector<LinearAlgebra::distributed::Vector<Number, MemorySpace>>
1821 : std::false_type
1822{};
1823
1824
1825
1826namespace internal
1827{
1828 namespace LinearOperatorImplementation
1829 {
1830 template <typename>
1831 class ReinitHelper;
1832
1837 template <typename Number>
1838 class ReinitHelper<LinearAlgebra::distributed::Vector<Number>>
1839 {
1840 public:
1841 // A helper type-trait that leverage SFINAE to figure out if type T has
1842 // void T::get_mpi_communicator()
1843 template <typename T>
1845 decltype(std::declval<T>().get_mpi_communicator());
1846
1847 template <typename T>
1848 static constexpr bool has_get_mpi_communicator =
1849 is_supported_operation<get_mpi_communicator_t, T>;
1850
1851 // A helper type-trait that leverage SFINAE to figure out if type T has
1852 // void T::locally_owned_domain_indices()
1853 template <typename T>
1855 decltype(std::declval<T>().locally_owned_domain_indices());
1856
1857 template <typename T>
1858 static constexpr bool has_locally_owned_domain_indices =
1859 is_supported_operation<locally_owned_domain_indices_t, T>;
1860
1861 // A helper type-trait that leverage SFINAE to figure out if type T has
1862 // void T::locally_owned_range_indices()
1863 template <typename T>
1865 decltype(std::declval<T>().locally_owned_range_indices());
1866
1867 template <typename T>
1868 static constexpr bool has_locally_owned_range_indices =
1869 is_supported_operation<locally_owned_range_indices_t, T>;
1870
1871 // A helper type-trait that leverage SFINAE to figure out if type T has
1872 // void T::initialize_dof_vector(VectorType v)
1873 template <typename T>
1875 decltype(std::declval<T>().initialize_dof_vector(
1877
1878 template <typename T>
1879 static constexpr bool has_initialize_dof_vector =
1880 is_supported_operation<initialize_dof_vector_t, T>;
1881
1882 // Used for (Trilinos/PETSc)Wrappers::SparseMatrix
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>,
1887#else
1888 // workaround for Intel 18
1889 std::enable_if_t<
1890 is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1892 MatrixType>,
1893#endif
1894 MatrixType> * = nullptr>
1895 static void
1896 reinit_domain_vector(MatrixType &mat,
1898 bool /*omit_zeroing_entries*/)
1899 {
1900 vec.reinit(mat.locally_owned_domain_indices(),
1901 mat.get_mpi_communicator());
1902 }
1903
1904 // Used for MatrixFree and DiagonalMatrix
1905 template <typename MatrixType,
1906#if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1907 std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1908#else
1909 // workaround for Intel 18
1910 std::enable_if_t<
1911 is_supported_operation<initialize_dof_vector_t, MatrixType>,
1912#endif
1913 MatrixType> * = nullptr>
1914 static void
1915 reinit_domain_vector(MatrixType &mat,
1917 bool omit_zeroing_entries)
1918 {
1919 mat.initialize_dof_vector(vec);
1920 if (!omit_zeroing_entries)
1921 vec = Number();
1922 }
1923
1924 // Used for (Trilinos/PETSc)Wrappers::SparseMatrix
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>,
1929#else
1930 // workaround for Intel 18
1931 std::enable_if_t<
1932 is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1933 is_supported_operation<locally_owned_range_indices_t,
1934 MatrixType>,
1935#endif
1936 MatrixType> * = nullptr>
1937 static void
1938 reinit_range_vector(MatrixType &mat,
1940 bool /*omit_zeroing_entries*/)
1941 {
1942 vec.reinit(mat.locally_owned_range_indices(),
1943 mat.get_mpi_communicator());
1944 }
1945
1946 // Used for MatrixFree and DiagonalMatrix
1947 template <typename MatrixType,
1948#if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1949 std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1950#else
1951 // workaround for Intel 18
1952 std::enable_if_t<
1953 is_supported_operation<initialize_dof_vector_t, MatrixType>,
1954#endif
1955 MatrixType> * = nullptr>
1956 static void
1957 reinit_range_vector(MatrixType &mat,
1959 bool omit_zeroing_entries)
1960 {
1961 mat.initialize_dof_vector(vec);
1962 if (!omit_zeroing_entries)
1963 vec = Number();
1964 }
1965 };
1966
1967 } // namespace LinearOperatorImplementation
1968} /* namespace internal */
1969
1970
1972
1973#endif
Number & operator()(const size_type global_index)
void assert_no_residual_content_in_ghost_region() 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)
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)
void compress_finish(VectorOperation::values operation)
mutable ::MemorySpace::MemorySpaceData< Number, MemorySpace > import_data
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)
void reinit(const IndexSet &local_range, const IndexSet &ghost_indices, const MPI_Comm communicator)
void swap(Vector< Number, MemorySpace > &v) noexcept
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
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)
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
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)
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)
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
Definition vector.h:141
void swap(LinearAlgebra::distributed::Vector< Number, MemorySpace > &u, LinearAlgebra::distributed::Vector< Number, MemorySpace > &v) noexcept
value_type * iterator
Definition vector.h:140
decltype(std::declval< T >().initialize_dof_vector(std::declval< LinearAlgebra::distributed::Vector< Number > & >())) initialize_dof_vector_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)
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
Definition config.h:280
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:35
#define DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
Definition config.h:595
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:36
#define DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
Definition config.h:638
Point< 2 > second
Definition grid_out.cc:4633
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
Definition mpi.cc:746
std::pair< types::global_dof_index, types::global_dof_index > local_range
Definition mpi.cc:826
std::size_t size
Definition mpi.cc:745
const MPI_Comm comm
Definition mpi.cc:924
types::global_dof_index locally_owned_size
Definition mpi.cc:833
constexpr bool is_supported_operation
bool is_finite(const double x)
Definition numbers.h:519
unsigned int global_dof_index
Definition types.h:90