Reference documentation for deal.II version GIT 5ac9d67d2d 2023-06-07 21:45:01+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\}}\)
la_parallel_vector.h
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2011 - 2022 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE.md at
12 // the top level directory of deal.II.
13 //
14 // ---------------------------------------------------------------------
15 
16 #ifndef dealii_la_parallel_vector_h
17 #define dealii_la_parallel_vector_h
18 
19 #include <deal.II/base/config.h>
20 
24 #include <deal.II/base/mpi_stub.h>
25 #include <deal.II/base/numbers.h>
26 #include <deal.II/base/parallel.h>
29 
33 
34 #include <iomanip>
35 #include <memory>
36 
38 
39 // Forward declarations
40 #ifndef DOXYGEN
41 namespace LinearAlgebra
42 {
46  namespace distributed
47  {
48  template <typename>
49  class BlockVector;
50  }
51 
52  template <typename>
53  class ReadWriteVector;
54 } // namespace LinearAlgebra
55 
56 # ifdef DEAL_II_WITH_PETSC
57 namespace PETScWrappers
58 {
59  namespace MPI
60  {
61  class Vector;
62  }
63 } // namespace PETScWrappers
64 # endif
65 
66 # ifdef DEAL_II_WITH_TRILINOS
67 namespace TrilinosWrappers
68 {
69  namespace MPI
70  {
71  class Vector;
72  }
73 } // namespace TrilinosWrappers
74 # endif
75 #endif
76 
77 namespace LinearAlgebra
78 {
79  namespace distributed
80  {
248  template <typename Number, typename MemorySpace = MemorySpace::Host>
250  public Subscriptor
251  {
252  public:
254  using value_type = Number;
255  using pointer = value_type *;
256  using const_pointer = const value_type *;
257  using iterator = value_type *;
258  using const_iterator = const value_type *;
260  using const_reference = const value_type &;
263 
264  static_assert(
265  std::is_same<MemorySpace, ::MemorySpace::Host>::value ||
266  std::is_same<MemorySpace, ::MemorySpace::Default>::value,
267  "MemorySpace should be Host or Default");
268 
277 
285 
293  Vector(Vector<Number, MemorySpace> &&in_vector); // NOLINT
294 
300 
317  Vector(const IndexSet &local_range,
318  const IndexSet &ghost_indices,
319  const MPI_Comm communicator);
320 
324  Vector(const IndexSet &local_range, const MPI_Comm communicator);
325 
333  const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
334 
338  virtual ~Vector() override;
339 
344  void
345  reinit(const size_type size, const bool omit_zeroing_entries = false);
346 
357  template <typename Number2>
358  void
360  const bool omit_zeroing_entries = false);
361 
378  void
379  reinit(const IndexSet &local_range,
380  const IndexSet &ghost_indices,
381  const MPI_Comm communicator);
382 
386  void
387  reinit(const IndexSet &local_range, const MPI_Comm communicator);
388 
401  void
403  const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner,
404  const MPI_Comm comm_sm = MPI_COMM_SELF);
405 
412  void
414  const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner,
415  const bool make_ghosted,
416  const MPI_Comm &comm_sm = MPI_COMM_SELF);
417 
437  void
439  const types::global_dof_index ghost_size,
440  const MPI_Comm comm,
441  const MPI_Comm comm_sm = MPI_COMM_SELF);
442 
455  void
457 
465  operator=(Vector<Number, MemorySpace> &&in_vector); // NOLINT
466 
480 
492  template <typename Number2>
495 
537  virtual void
538  compress(VectorOperation::values operation) override;
539 
561  void
563 
581  void
582  compress_start(const unsigned int communication_channel = 0,
584 
603  void
605 
623  void
625  const unsigned int communication_channel = 0) const;
626 
627 
635  void
637 
648  DEAL_II_DEPRECATED void
650 
659  void
661 
673  bool
675 
690  template <typename Number2>
691  void
693 
704  template <typename MemorySpace2>
705  void
707  VectorOperation::values operation);
708 
712  template <typename MemorySpace2>
713  DEAL_II_DEPRECATED_EARLY void
714  import(const Vector<Number, MemorySpace2> &src,
715  VectorOperation::values operation)
716  {
717  import_elements(src, operation);
718  }
719 
731  virtual void
733  const bool omit_zeroing_entries = false) override;
734 
739  operator*=(const Number factor) override;
740 
745  operator/=(const Number factor) override;
746 
752 
758 
770  virtual void
773  VectorOperation::values operation,
774  std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
775  communication_pattern = {}) override;
776 
780  DEAL_II_DEPRECATED_EARLY virtual void
782  VectorOperation::values operation,
783  std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
784  communication_pattern = {}) override
785  {
786  import_elements(V, operation, communication_pattern);
787  }
788 
792  virtual Number
793  operator*(const VectorSpaceVector<Number> &V) const override;
794 
798  virtual void
799  add(const Number a) override;
800 
804  virtual void
805  add(const Number a, const VectorSpaceVector<Number> &V) override;
806 
810  virtual void
811  add(const Number a,
813  const Number b,
814  const VectorSpaceVector<Number> &W) override;
815 
820  virtual void
821  add(const std::vector<size_type> &indices,
822  const std::vector<Number> & values);
823 
828  virtual void
829  sadd(const Number s,
830  const Number a,
831  const VectorSpaceVector<Number> &V) override;
832 
838  virtual void
839  scale(const VectorSpaceVector<Number> &scaling_factors) override;
840 
844  virtual void
845  equ(const Number a, const VectorSpaceVector<Number> &V) override;
846 
851  virtual real_type
852  l1_norm() const override;
853 
858  virtual real_type
859  l2_norm() const override;
860 
864  real_type
865  norm_sqr() const;
866 
871  virtual real_type
872  linfty_norm() const override;
873 
894  virtual Number
895  add_and_dot(const Number a,
897  const VectorSpaceVector<Number> &W) override;
898 
903  virtual size_type
904  size() const override;
905 
917  virtual ::IndexSet
918  locally_owned_elements() const override;
919 
923  virtual void
924  print(std::ostream & out,
925  const unsigned int precision = 3,
926  const bool scientific = true,
927  const bool across = true) const override;
928 
932  virtual std::size_t
933  memory_consumption() const override;
947  operator=(const Number s) override;
948 
953  template <typename OtherNumber>
954  void
955  add(const std::vector<size_type> & indices,
956  const ::Vector<OtherNumber> &values);
957 
962  template <typename OtherNumber>
963  void
964  add(const size_type n_elements,
965  const size_type * indices,
966  const OtherNumber *values);
967 
972  void
973  sadd(const Number s, const Vector<Number, MemorySpace> &V);
974 
990  size_type
991  local_size() const;
992 
997  size_type
999 
1004  bool
1006 
1017  iterator
1019 
1028  begin() const;
1029 
1037  iterator
1038  end();
1039 
1048  end() const;
1049 
1059  Number
1061 
1071  Number &
1073 
1081  Number
1090  Number &
1092 
1101  Number
1102  local_element(const size_type local_index) const;
1103 
1112  Number &
1113  local_element(const size_type local_index);
1114 
1121  Number *
1122  get_values() const;
1123 
1141  template <typename OtherNumber>
1142  void
1143  extract_subvector_to(const std::vector<size_type> &indices,
1144  std::vector<OtherNumber> & values) const;
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  virtual bool
1184  all_zero() const override;
1185 
1189  virtual Number
1190  mean_value() const override;
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 VectorSpaceVector<Number> &V);
1317 
1322  void
1323  sadd_local(const Number s,
1324  const Number a,
1325  const VectorSpaceVector<Number> &V);
1326 
1330  template <typename Number2>
1331  Number
1333 
1337  real_type
1339 
1343  Number
1345 
1349  real_type
1350  l1_norm_local() const;
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,
1372  const Vector<Number, MemorySpace> &W);
1373 
1379  std::shared_ptr<const Utilities::MPI::Partitioner> partitioner;
1380 
1385 
1389  mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace> data;
1390 
1395  mutable std::shared_ptr<::parallel::internal::TBBPartitioner>
1397 
1402  mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace>
1404 
1412  mutable bool vector_is_ghosted;
1413 
1414 #ifdef DEAL_II_WITH_MPI
1423  std::vector<MPI_Request> compress_requests;
1424 
1429  mutable std::vector<MPI_Request> update_ghost_values_requests;
1430 #endif
1431 
1437  mutable std::mutex mutex;
1438 
1444  MPI_Comm comm_sm;
1445 
1450  void
1452 
1456  void
1457  resize_val(const size_type new_allocated_size,
1458  const MPI_Comm comm_sm = MPI_COMM_SELF);
1459 
1460  // Make all other vector types friends.
1461  template <typename Number2, typename MemorySpace2>
1462  friend class Vector;
1463 
1464  // Make BlockVector type friends.
1465  template <typename Number2>
1466  friend class BlockVector;
1467  };
1471  /*-------------------- Inline functions ---------------------------------*/
1472 
1473 #ifndef DOXYGEN
1474 
1475  template <typename Number, typename MemorySpace>
1476  inline bool
1478  {
1479  return vector_is_ghosted;
1480  }
1481 
1482 
1483 
1484  template <typename Number, typename MemorySpace>
1487  {
1488  return partitioner->size();
1489  }
1490 
1491 
1492 
1493  template <typename Number, typename MemorySpace>
1496  {
1497  return locally_owned_size();
1498  }
1499 
1500 
1501 
1502  template <typename Number, typename MemorySpace>
1505  {
1506  return partitioner->locally_owned_size();
1507  }
1508 
1509 
1510 
1511  template <typename Number, typename MemorySpace>
1512  inline bool
1514  const size_type global_index) const
1515  {
1516  return partitioner->in_local_range(global_index);
1517  }
1518 
1519 
1520 
1521  template <typename Number, typename MemorySpace>
1522  inline IndexSet
1524  {
1525  IndexSet is(size());
1526 
1527  is.add_range(partitioner->local_range().first,
1528  partitioner->local_range().second);
1529 
1530  return is;
1531  }
1532 
1533 
1534 
1535  template <typename Number, typename MemorySpace>
1538  {
1539  return data.values.data();
1540  }
1541 
1542 
1543 
1544  template <typename Number, typename MemorySpace>
1547  {
1548  return data.values.data();
1549  }
1550 
1551 
1552 
1553  template <typename Number, typename MemorySpace>
1556  {
1557  return data.values.data() + partitioner->locally_owned_size();
1558  }
1559 
1560 
1561 
1562  template <typename Number, typename MemorySpace>
1565  {
1566  return data.values.data() + partitioner->locally_owned_size();
1567  }
1568 
1569 
1570 
1571  template <typename Number, typename MemorySpace>
1572  const std::vector<ArrayView<const Number>> &
1574  {
1575  return data.values_sm;
1576  }
1577 
1578 
1579 
1580  template <typename Number, typename MemorySpace>
1581  inline Number
1583  {
1584  Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1585  ExcMessage(
1586  "This function is only implemented for the Host memory space"));
1587  Assert(
1588  partitioner->in_local_range(global_index) ||
1589  partitioner->ghost_indices().is_element(global_index),
1590  ExcAccessToNonLocalElement(global_index,
1591  partitioner->local_range().first,
1592  partitioner->local_range().second == 0 ?
1593  0 :
1594  (partitioner->local_range().second - 1),
1595  partitioner->ghost_indices().n_elements()));
1596  // do not allow reading a vector which is not in ghost mode
1597  Assert(partitioner->in_local_range(global_index) ||
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)];
1602  }
1603 
1604 
1605 
1606  template <typename Number, typename MemorySpace>
1607  inline Number &
1609  {
1610  Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1611  ExcMessage(
1612  "This function is only implemented for the Host memory space"));
1613  Assert(
1614  partitioner->in_local_range(global_index) ||
1615  partitioner->ghost_indices().is_element(global_index),
1616  ExcAccessToNonLocalElement(global_index,
1617  partitioner->local_range().first,
1618  partitioner->local_range().second == 0 ?
1619  0 :
1620  (partitioner->local_range().second - 1),
1621  partitioner->ghost_indices().n_elements()));
1622  // we would like to prevent reading ghosts from a vector that does not
1623  // have them imported, but this is not possible because we might be in a
1624  // part of the code where the vector has enabled ghosts but is non-const
1625  // (then, the compiler picks this method according to the C++ rule book
1626  // even if a human would pick the const method when this subsequent use
1627  // is just a read)
1628  return data.values[partitioner->global_to_local(global_index)];
1629  }
1630 
1631 
1632 
1633  template <typename Number, typename MemorySpace>
1634  inline Number
1636  {
1637  return operator()(global_index);
1638  }
1639 
1640 
1641 
1642  template <typename Number, typename MemorySpace>
1643  inline Number &
1645  {
1646  return operator()(global_index);
1647  }
1648 
1649 
1650 
1651  template <typename Number, typename MemorySpace>
1652  inline Number
1654  const size_type local_index) const
1655  {
1656  Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1657  ExcMessage(
1658  "This function is only implemented for the Host memory space"));
1659  AssertIndexRange(local_index,
1660  partitioner->locally_owned_size() +
1661  partitioner->n_ghost_indices());
1662  // do not allow reading a vector which is not in ghost mode
1663  Assert(local_index < locally_owned_size() || vector_is_ghosted == true,
1664  ExcMessage("You tried to read a ghost element of this vector, "
1665  "but it has not imported its ghost values."));
1666 
1667  return data.values[local_index];
1668  }
1669 
1670 
1671 
1672  template <typename Number, typename MemorySpace>
1673  inline Number &
1675  {
1676  Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1677  ExcMessage(
1678  "This function is only implemented for the Host memory space"));
1679 
1680  AssertIndexRange(local_index,
1681  partitioner->locally_owned_size() +
1682  partitioner->n_ghost_indices());
1683 
1684  return data.values[local_index];
1685  }
1686 
1687 
1688 
1689  template <typename Number, typename MemorySpace>
1690  inline Number *
1692  {
1693  return data.values.data();
1694  }
1695 
1696 
1697 
1698  template <typename Number, typename MemorySpace>
1699  template <typename OtherNumber>
1700  inline void
1702  const std::vector<size_type> &indices,
1703  std::vector<OtherNumber> & values) const
1704  {
1705  for (size_type i = 0; i < indices.size(); ++i)
1706  values[i] = operator()(indices[i]);
1707  }
1708 
1709 
1710 
1711  template <typename Number, typename MemorySpace>
1712  template <typename ForwardIterator, typename OutputIterator>
1713  inline void
1715  ForwardIterator indices_begin,
1716  const ForwardIterator indices_end,
1717  OutputIterator values_begin) const
1718  {
1719  while (indices_begin != indices_end)
1720  {
1721  *values_begin = operator()(*indices_begin);
1722  indices_begin++;
1723  values_begin++;
1724  }
1725  }
1726 
1727 
1728 
1729  template <typename Number, typename MemorySpace>
1730  template <typename OtherNumber>
1731  inline void
1733  const std::vector<size_type> & indices,
1734  const ::Vector<OtherNumber> &values)
1735  {
1736  AssertDimension(indices.size(), values.size());
1737  for (size_type i = 0; i < indices.size(); ++i)
1738  {
1739  Assert(
1741  ExcMessage(
1742  "The given value is not finite but either infinite or Not A Number (NaN)"));
1743  this->operator()(indices[i]) += values(i);
1744  }
1745  }
1746 
1747 
1748 
1749  template <typename Number, typename MemorySpace>
1750  template <typename OtherNumber>
1751  inline void
1753  const size_type * indices,
1754  const OtherNumber *values)
1755  {
1756  for (size_type i = 0; i < n_elements; ++i, ++indices, ++values)
1757  {
1758  Assert(
1760  ExcMessage(
1761  "The given value is not finite but either infinite or Not A Number (NaN)"));
1762  this->operator()(*indices) += *values;
1763  }
1764  }
1765 
1766 
1767 
1768  template <typename Number, typename MemorySpace>
1769  inline MPI_Comm
1771  {
1772  return partitioner->get_mpi_communicator();
1773  }
1774 
1775 
1776 
1777  template <typename Number, typename MemorySpace>
1778  inline const std::shared_ptr<const Utilities::MPI::Partitioner> &
1780  {
1781  return partitioner;
1782  }
1783 
1784 
1785 
1786  template <typename Number, typename MemorySpace>
1787  inline void
1788  Vector<Number, MemorySpace>::set_ghost_state(const bool ghosted) const
1789  {
1790  vector_is_ghosted = ghosted;
1791  }
1792 
1793 #endif
1794 
1795  } // namespace distributed
1796 } // namespace LinearAlgebra
1797 
1798 
1806 template <typename Number, typename MemorySpace>
1807 inline void
1810 {
1811  u.swap(v);
1812 }
1813 
1814 
1818 template <typename Number, typename MemorySpace>
1820  : std::false_type
1821 {};
1822 
1823 
1824 
1825 namespace internal
1826 {
1827  namespace LinearOperatorImplementation
1828  {
1829  template <typename>
1830  class ReinitHelper;
1831 
1836  template <typename Number>
1838  {
1839  public:
1840  // A helper type-trait that leverage SFINAE to figure out if type T has
1841  // void T::get_mpi_communicator()
1842  template <typename T>
1844  decltype(std::declval<T>().get_mpi_communicator());
1845 
1846  template <typename T>
1847  static constexpr bool has_get_mpi_communicator =
1848  is_supported_operation<get_mpi_communicator_t, T>;
1849 
1850  // A helper type-trait that leverage SFINAE to figure out if type T has
1851  // void T::locally_owned_domain_indices()
1852  template <typename T>
1854  decltype(std::declval<T>().locally_owned_domain_indices());
1855 
1856  template <typename T>
1857  static constexpr bool has_locally_owned_domain_indices =
1858  is_supported_operation<locally_owned_domain_indices_t, T>;
1859 
1860  // A helper type-trait that leverage SFINAE to figure out if type T has
1861  // void T::locally_owned_range_indices()
1862  template <typename T>
1864  decltype(std::declval<T>().locally_owned_range_indices());
1865 
1866  template <typename T>
1867  static constexpr bool has_locally_owned_range_indices =
1868  is_supported_operation<locally_owned_range_indices_t, T>;
1869 
1870  // A helper type-trait that leverage SFINAE to figure out if type T has
1871  // void T::initialize_dof_vector(VectorType v)
1872  template <typename T>
1874  decltype(std::declval<T>().initialize_dof_vector(
1875  std::declval<LinearAlgebra::distributed::Vector<Number> &>()));
1876 
1877  template <typename T>
1878  static constexpr bool has_initialize_dof_vector =
1879  is_supported_operation<initialize_dof_vector_t, T>;
1880 
1881  // Used for (Trilinos/PETSc)Wrappers::SparseMatrix
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>,
1886 #else
1887  // workaround for Intel 18
1888  std::enable_if_t<
1889  is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1891  MatrixType>,
1892 #endif
1893  MatrixType> * = nullptr>
1894  static void
1895  reinit_domain_vector(MatrixType & mat,
1897  bool /*omit_zeroing_entries*/)
1898  {
1899  vec.reinit(mat.locally_owned_domain_indices(),
1900  mat.get_mpi_communicator());
1901  }
1902 
1903  // Used for MatrixFree and DiagonalMatrix
1904  template <typename MatrixType,
1905 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1906  std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1907 #else
1908  // workaround for Intel 18
1909  std::enable_if_t<
1910  is_supported_operation<initialize_dof_vector_t, MatrixType>,
1911 #endif
1912  MatrixType> * = nullptr>
1913  static void
1914  reinit_domain_vector(MatrixType & mat,
1916  bool omit_zeroing_entries)
1917  {
1918  mat.initialize_dof_vector(vec);
1919  if (!omit_zeroing_entries)
1920  vec = Number();
1921  }
1922 
1923  // Used for (Trilinos/PETSc)Wrappers::SparseMatrix
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>,
1928 #else
1929  // workaround for Intel 18
1930  std::enable_if_t<
1931  is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1932  is_supported_operation<locally_owned_range_indices_t,
1933  MatrixType>,
1934 #endif
1935  MatrixType> * = nullptr>
1936  static void
1937  reinit_range_vector(MatrixType & mat,
1939  bool /*omit_zeroing_entries*/)
1940  {
1941  vec.reinit(mat.locally_owned_range_indices(),
1942  mat.get_mpi_communicator());
1943  }
1944 
1945  // Used for MatrixFree and DiagonalMatrix
1946  template <typename MatrixType,
1947 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1948  std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1949 #else
1950  // workaround for Intel 18
1951  std::enable_if_t<
1952  is_supported_operation<initialize_dof_vector_t, MatrixType>,
1953 #endif
1954  MatrixType> * = nullptr>
1955  static void
1956  reinit_range_vector(MatrixType & mat,
1958  bool omit_zeroing_entries)
1959  {
1960  mat.initialize_dof_vector(vec);
1961  if (!omit_zeroing_entries)
1962  vec = Number();
1963  }
1964  };
1965 
1966  } // namespace LinearOperatorImplementation
1967 } /* namespace internal */
1968 
1969 
1971 
1972 #endif
value_type operator()(const size_type i) const
std::size_t locally_owned_size() const
types::global_dof_index size_type
Definition: la_vector.h:82
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
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)
void compress_finish(VectorOperation::values operation)
virtual void add(const Number a, const VectorSpaceVector< Number > &V, const Number b, const VectorSpaceVector< Number > &W) override
mutable ::MemorySpace::MemorySpaceData< Number, MemorySpace > import_data
void swap(Vector< Number, MemorySpace > &v)
virtual real_type linfty_norm() const override
mutable ::MemorySpace::MemorySpaceData< Number, MemorySpace > data
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)
void reinit(const IndexSet &local_range, const IndexSet &ghost_indices, const MPI_Comm communicator)
virtual std::size_t memory_consumption() const override
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
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
bool partitioners_are_globally_compatible(const Utilities::MPI::Partitioner &part) const
virtual size_type size() const 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_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)
virtual void add(const Number a) override
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
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)
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
Definition: vector.h:109
void swap(LinearAlgebra::distributed::Vector< Number, MemorySpace > &u, LinearAlgebra::distributed::Vector< Number, MemorySpace > &v)
const value_type * const_iterator
Definition: vector.h:132
types::global_dof_index size_type
Definition: vector.h:135
value_type * iterator
Definition: vector.h:131
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:174
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:474
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:475
#define DeclException0(Exception0)
Definition: exceptions.h:465
#define DeclException4(Exception4, type1, type2, type3, type4, outsequence)
Definition: exceptions.h:579
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)
Definition: exceptions.h:1614
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1787
#define AssertIndexRange(index, range)
Definition: exceptions.h:1855
#define DeclException3(Exception3, type1, type2, type3, outsequence)
Definition: exceptions.h:556
static ::ExceptionBase & ExcMessage(std::string arg1)
static const char V
types::global_dof_index size_type
Definition: cuda_kernels.h:45
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)
Definition: numbers.h:538
unsigned int global_dof_index
Definition: types.h:82
const MPI_Comm comm