Reference documentation for deal.II version GIT 9c182271f7 2023-03-28 14:30: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  {
250  template <typename Number, typename MemorySpace = MemorySpace::Host>
252  public Subscriptor
253  {
254  public:
256  using value_type = Number;
257  using pointer = value_type *;
258  using const_pointer = const value_type *;
259  using iterator = value_type *;
260  using const_iterator = const value_type *;
262  using const_reference = const value_type &;
265 
266  static_assert(
267  std::is_same<MemorySpace, ::MemorySpace::Host>::value ||
268  std::is_same<MemorySpace, ::MemorySpace::CUDA>::value,
269  "MemorySpace should be Host or CUDA");
270 
279 
287 
295  Vector(Vector<Number, MemorySpace> &&in_vector); // NOLINT
296 
302 
319  Vector(const IndexSet &local_range,
320  const IndexSet &ghost_indices,
321  const MPI_Comm &communicator);
322 
326  Vector(const IndexSet &local_range, const MPI_Comm &communicator);
327 
335  const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
336 
340  virtual ~Vector() override;
341 
346  void
347  reinit(const size_type size, const bool omit_zeroing_entries = false);
348 
359  template <typename Number2>
360  void
362  const bool omit_zeroing_entries = false);
363 
380  void
381  reinit(const IndexSet &local_range,
382  const IndexSet &ghost_indices,
383  const MPI_Comm &communicator);
384 
388  void
389  reinit(const IndexSet &local_range, const MPI_Comm &communicator);
390 
403  void
405  const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner,
406  const MPI_Comm &comm_sm = MPI_COMM_SELF);
407 
427  void
429  const types::global_dof_index ghost_size,
430  const MPI_Comm & comm,
431  const MPI_Comm & comm_sm = MPI_COMM_SELF);
432 
445  void
447 
461 
473  template <typename Number2>
476 
518  virtual void
519  compress(VectorOperation::values operation) override;
520 
542  void
544 
562  void
563  compress_start(const unsigned int communication_channel = 0,
565 
584  void
586 
604  void
606  const unsigned int communication_channel = 0) const;
607 
608 
616  void
618 
629  DEAL_II_DEPRECATED void
631 
640  void
642 
654  bool
656 
671  template <typename Number2>
672  void
674 
685  template <typename MemorySpace2>
686  void
687  import(const Vector<Number, MemorySpace2> &src,
688  VectorOperation::values operation);
689 
701  virtual void
703  const bool omit_zeroing_entries = false) override;
704 
709  operator*=(const Number factor) override;
710 
715  operator/=(const Number factor) override;
716 
722 
728 
740  virtual void
742  VectorOperation::values operation,
743  std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
744  communication_pattern = {}) override;
745 
749  virtual Number
750  operator*(const VectorSpaceVector<Number> &V) const override;
751 
755  virtual void
756  add(const Number a) override;
757 
761  virtual void
762  add(const Number a, const VectorSpaceVector<Number> &V) override;
763 
767  virtual void
768  add(const Number a,
770  const Number b,
771  const VectorSpaceVector<Number> &W) override;
772 
777  virtual void
778  add(const std::vector<size_type> &indices,
779  const std::vector<Number> & values);
780 
785  virtual void
786  sadd(const Number s,
787  const Number a,
788  const VectorSpaceVector<Number> &V) override;
789 
795  virtual void
796  scale(const VectorSpaceVector<Number> &scaling_factors) override;
797 
801  virtual void
802  equ(const Number a, const VectorSpaceVector<Number> &V) override;
803 
808  virtual real_type
809  l1_norm() const override;
810 
815  virtual real_type
816  l2_norm() const override;
817 
821  real_type
822  norm_sqr() const;
823 
828  virtual real_type
829  linfty_norm() const override;
830 
851  virtual Number
852  add_and_dot(const Number a,
854  const VectorSpaceVector<Number> &W) override;
855 
860  virtual size_type
861  size() const override;
862 
874  virtual ::IndexSet
875  locally_owned_elements() const override;
876 
880  virtual void
881  print(std::ostream & out,
882  const unsigned int precision = 3,
883  const bool scientific = true,
884  const bool across = true) const override;
885 
889  virtual std::size_t
890  memory_consumption() const override;
904  operator=(const Number s) override;
905 
910  template <typename OtherNumber>
911  void
912  add(const std::vector<size_type> & indices,
913  const ::Vector<OtherNumber> &values);
914 
919  template <typename OtherNumber>
920  void
921  add(const size_type n_elements,
922  const size_type * indices,
923  const OtherNumber *values);
924 
929  void
930  sadd(const Number s, const Vector<Number, MemorySpace> &V);
931 
947  size_type
948  local_size() const;
949 
954  size_type
956 
961  bool
963 
974  iterator
975  begin();
976 
985  begin() const;
986 
994  iterator
995  end();
996 
1005  end() const;
1006 
1016  Number
1018 
1028  Number &
1030 
1038  Number
1047  Number &
1049 
1058  Number
1059  local_element(const size_type local_index) const;
1060 
1069  Number &
1070  local_element(const size_type local_index);
1071 
1078  Number *
1079  get_values() const;
1080 
1098  template <typename OtherNumber>
1099  void
1100  extract_subvector_to(const std::vector<size_type> &indices,
1101  std::vector<OtherNumber> & values) const;
1102 
1130  template <typename ForwardIterator, typename OutputIterator>
1131  void
1132  extract_subvector_to(ForwardIterator indices_begin,
1133  const ForwardIterator indices_end,
1134  OutputIterator values_begin) const;
1140  virtual bool
1141  all_zero() const override;
1142 
1146  virtual Number
1147  mean_value() const override;
1148 
1153  real_type
1154  lp_norm(const real_type p) const;
1166  const MPI_Comm &
1168 
1175  const std::shared_ptr<const Utilities::MPI::Partitioner> &
1177 
1187  bool
1189  const Utilities::MPI::Partitioner &part) const;
1190 
1204  bool
1206  const Utilities::MPI::Partitioner &part) const;
1207 
1211  void
1212  set_ghost_state(const bool ghosted) const;
1213 
1218  const std::vector<ArrayView<const Number>> &
1220 
1229 
1236 
1241  Number,
1242  Number,
1243  unsigned int,
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);
1250 
1256  size_type,
1257  size_type,
1258  size_type,
1259  size_type,
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."
1266  << "\n\n"
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.");
1274 
1275  private:
1280  void
1281  add_local(const Number a, const VectorSpaceVector<Number> &V);
1282 
1287  void
1288  sadd_local(const Number s,
1289  const Number a,
1290  const VectorSpaceVector<Number> &V);
1291 
1295  template <typename Number2>
1296  Number
1298 
1302  real_type
1304 
1308  Number
1310 
1314  real_type
1315  l1_norm_local() const;
1316 
1320  real_type
1321  lp_norm_local(const real_type p) const;
1322 
1326  real_type
1328 
1334  Number
1335  add_and_dot_local(const Number a,
1337  const Vector<Number, MemorySpace> &W);
1338 
1344  std::shared_ptr<const Utilities::MPI::Partitioner> partitioner;
1345 
1350 
1354  mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace> data;
1355 
1360  mutable std::shared_ptr<::parallel::internal::TBBPartitioner>
1362 
1367  mutable ::MemorySpace::MemorySpaceData<Number, MemorySpace>
1369 
1377  mutable bool vector_is_ghosted;
1378 
1379 #ifdef DEAL_II_WITH_MPI
1388  std::vector<MPI_Request> compress_requests;
1389 
1394  mutable std::vector<MPI_Request> update_ghost_values_requests;
1395 #endif
1396 
1402  mutable std::mutex mutex;
1403 
1409  MPI_Comm comm_sm;
1410 
1415  void
1417 
1421  void
1422  resize_val(const size_type new_allocated_size,
1423  const MPI_Comm &comm_sm = MPI_COMM_SELF);
1424 
1425  // Make all other vector types friends.
1426  template <typename Number2, typename MemorySpace2>
1427  friend class Vector;
1428 
1429  // Make BlockVector type friends.
1430  template <typename Number2>
1431  friend class BlockVector;
1432  };
1436  /*-------------------- Inline functions ---------------------------------*/
1437 
1438 #ifndef DOXYGEN
1439 
1440  template <typename Number, typename MemorySpace>
1441  inline bool
1443  {
1444  return vector_is_ghosted;
1445  }
1446 
1447 
1448 
1449  template <typename Number, typename MemorySpace>
1452  {
1453  return partitioner->size();
1454  }
1455 
1456 
1457 
1458  template <typename Number, typename MemorySpace>
1461  {
1462  return locally_owned_size();
1463  }
1464 
1465 
1466 
1467  template <typename Number, typename MemorySpace>
1470  {
1471  return partitioner->locally_owned_size();
1472  }
1473 
1474 
1475 
1476  template <typename Number, typename MemorySpace>
1477  inline bool
1479  const size_type global_index) const
1480  {
1481  return partitioner->in_local_range(global_index);
1482  }
1483 
1484 
1485 
1486  template <typename Number, typename MemorySpace>
1487  inline IndexSet
1489  {
1490  IndexSet is(size());
1491 
1492  is.add_range(partitioner->local_range().first,
1493  partitioner->local_range().second);
1494 
1495  return is;
1496  }
1497 
1498 
1499 
1500  template <typename Number, typename MemorySpace>
1503  {
1504  return data.values.data();
1505  }
1506 
1507 
1508 
1509  template <typename Number, typename MemorySpace>
1512  {
1513  return data.values.data();
1514  }
1515 
1516 
1517 
1518  template <typename Number, typename MemorySpace>
1521  {
1522  return data.values.data() + partitioner->locally_owned_size();
1523  }
1524 
1525 
1526 
1527  template <typename Number, typename MemorySpace>
1530  {
1531  return data.values.data() + partitioner->locally_owned_size();
1532  }
1533 
1534 
1535 
1536  template <typename Number, typename MemorySpace>
1537  const std::vector<ArrayView<const Number>> &
1539  {
1540  return data.values_sm;
1541  }
1542 
1543 
1544 
1545  template <typename Number, typename MemorySpace>
1546  inline Number
1548  {
1549  Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1550  ExcMessage(
1551  "This function is only implemented for the Host memory space"));
1552  Assert(
1553  partitioner->in_local_range(global_index) ||
1554  partitioner->ghost_indices().is_element(global_index),
1555  ExcAccessToNonLocalElement(global_index,
1556  partitioner->local_range().first,
1557  partitioner->local_range().second == 0 ?
1558  0 :
1559  (partitioner->local_range().second - 1),
1560  partitioner->ghost_indices().n_elements()));
1561  // do not allow reading a vector which is not in ghost mode
1562  Assert(partitioner->in_local_range(global_index) ||
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)];
1567  }
1568 
1569 
1570 
1571  template <typename Number, typename MemorySpace>
1572  inline Number &
1574  {
1575  Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1576  ExcMessage(
1577  "This function is only implemented for the Host memory space"));
1578  Assert(
1579  partitioner->in_local_range(global_index) ||
1580  partitioner->ghost_indices().is_element(global_index),
1581  ExcAccessToNonLocalElement(global_index,
1582  partitioner->local_range().first,
1583  partitioner->local_range().second == 0 ?
1584  0 :
1585  (partitioner->local_range().second - 1),
1586  partitioner->ghost_indices().n_elements()));
1587  // we would like to prevent reading ghosts from a vector that does not
1588  // have them imported, but this is not possible because we might be in a
1589  // part of the code where the vector has enabled ghosts but is non-const
1590  // (then, the compiler picks this method according to the C++ rule book
1591  // even if a human would pick the const method when this subsequent use
1592  // is just a read)
1593  return data.values[partitioner->global_to_local(global_index)];
1594  }
1595 
1596 
1597 
1598  template <typename Number, typename MemorySpace>
1599  inline Number
1601  {
1602  return operator()(global_index);
1603  }
1604 
1605 
1606 
1607  template <typename Number, typename MemorySpace>
1608  inline Number &
1610  {
1611  return operator()(global_index);
1612  }
1613 
1614 
1615 
1616  template <typename Number, typename MemorySpace>
1617  inline Number
1619  const size_type local_index) const
1620  {
1621  Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1622  ExcMessage(
1623  "This function is only implemented for the Host memory space"));
1624  AssertIndexRange(local_index,
1625  partitioner->locally_owned_size() +
1626  partitioner->n_ghost_indices());
1627  // do not allow reading a vector which is not in ghost mode
1628  Assert(local_index < locally_owned_size() || vector_is_ghosted == true,
1629  ExcMessage("You tried to read a ghost element of this vector, "
1630  "but it has not imported its ghost values."));
1631 
1632  return data.values[local_index];
1633  }
1634 
1635 
1636 
1637  template <typename Number, typename MemorySpace>
1638  inline Number &
1640  {
1641  Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1642  ExcMessage(
1643  "This function is only implemented for the Host memory space"));
1644 
1645  AssertIndexRange(local_index,
1646  partitioner->locally_owned_size() +
1647  partitioner->n_ghost_indices());
1648 
1649  return data.values[local_index];
1650  }
1651 
1652 
1653 
1654  template <typename Number, typename MemorySpace>
1655  inline Number *
1657  {
1658  return data.values.data();
1659  }
1660 
1661 
1662 
1663  template <typename Number, typename MemorySpace>
1664  template <typename OtherNumber>
1665  inline void
1667  const std::vector<size_type> &indices,
1668  std::vector<OtherNumber> & values) const
1669  {
1670  for (size_type i = 0; i < indices.size(); ++i)
1671  values[i] = operator()(indices[i]);
1672  }
1673 
1674 
1675 
1676  template <typename Number, typename MemorySpace>
1677  template <typename ForwardIterator, typename OutputIterator>
1678  inline void
1680  ForwardIterator indices_begin,
1681  const ForwardIterator indices_end,
1682  OutputIterator values_begin) const
1683  {
1684  while (indices_begin != indices_end)
1685  {
1686  *values_begin = operator()(*indices_begin);
1687  indices_begin++;
1688  values_begin++;
1689  }
1690  }
1691 
1692 
1693 
1694  template <typename Number, typename MemorySpace>
1695  template <typename OtherNumber>
1696  inline void
1698  const std::vector<size_type> & indices,
1699  const ::Vector<OtherNumber> &values)
1700  {
1701  AssertDimension(indices.size(), values.size());
1702  for (size_type i = 0; i < indices.size(); ++i)
1703  {
1704  Assert(
1706  ExcMessage(
1707  "The given value is not finite but either infinite or Not A Number (NaN)"));
1708  this->operator()(indices[i]) += values(i);
1709  }
1710  }
1711 
1712 
1713 
1714  template <typename Number, typename MemorySpace>
1715  template <typename OtherNumber>
1716  inline void
1718  const size_type * indices,
1719  const OtherNumber *values)
1720  {
1721  for (size_type i = 0; i < n_elements; ++i, ++indices, ++values)
1722  {
1723  Assert(
1725  ExcMessage(
1726  "The given value is not finite but either infinite or Not A Number (NaN)"));
1727  this->operator()(*indices) += *values;
1728  }
1729  }
1730 
1731 
1732 
1733  template <typename Number, typename MemorySpace>
1734  inline const MPI_Comm &
1736  {
1737  return partitioner->get_mpi_communicator();
1738  }
1739 
1740 
1741 
1742  template <typename Number, typename MemorySpace>
1743  inline const std::shared_ptr<const Utilities::MPI::Partitioner> &
1745  {
1746  return partitioner;
1747  }
1748 
1749 
1750 
1751  template <typename Number, typename MemorySpace>
1752  inline void
1753  Vector<Number, MemorySpace>::set_ghost_state(const bool ghosted) const
1754  {
1755  vector_is_ghosted = ghosted;
1756  }
1757 
1758 #endif
1759 
1760  } // namespace distributed
1761 } // namespace LinearAlgebra
1762 
1763 
1771 template <typename Number, typename MemorySpace>
1772 inline void
1775 {
1776  u.swap(v);
1777 }
1778 
1779 
1783 template <typename Number, typename MemorySpace>
1785  : std::false_type
1786 {};
1787 
1788 
1789 
1790 namespace internal
1791 {
1792  namespace LinearOperatorImplementation
1793  {
1794  template <typename>
1795  class ReinitHelper;
1796 
1801  template <typename Number>
1803  {
1804  public:
1805  // A helper type-trait that leverage SFINAE to figure out if type T has
1806  // void T::get_mpi_communicator()
1807  template <typename T>
1809  decltype(std::declval<T>().get_mpi_communicator());
1810 
1811  template <typename T>
1812  static constexpr bool has_get_mpi_communicator =
1813  is_supported_operation<get_mpi_communicator_t, T>;
1814 
1815  // A helper type-trait that leverage SFINAE to figure out if type T has
1816  // void T::locally_owned_domain_indices()
1817  template <typename T>
1819  decltype(std::declval<T>().locally_owned_domain_indices());
1820 
1821  template <typename T>
1822  static constexpr bool has_locally_owned_domain_indices =
1823  is_supported_operation<locally_owned_domain_indices_t, T>;
1824 
1825  // A helper type-trait that leverage SFINAE to figure out if type T has
1826  // void T::locally_owned_range_indices()
1827  template <typename T>
1829  decltype(std::declval<T>().locally_owned_range_indices());
1830 
1831  template <typename T>
1832  static constexpr bool has_locally_owned_range_indices =
1833  is_supported_operation<locally_owned_range_indices_t, T>;
1834 
1835  // A helper type-trait that leverage SFINAE to figure out if type T has
1836  // void T::initialize_dof_vector(VectorType v)
1837  template <typename T>
1839  decltype(std::declval<T>().initialize_dof_vector(
1840  std::declval<LinearAlgebra::distributed::Vector<Number> &>()));
1841 
1842  template <typename T>
1843  static constexpr bool has_initialize_dof_vector =
1844  is_supported_operation<initialize_dof_vector_t, T>;
1845 
1846  // Used for (Trilinos/PETSc)Wrappers::SparseMatrix
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>,
1851 #else
1852  // workaround for Intel 18
1853  std::enable_if_t<
1854  is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1856  MatrixType>,
1857 #endif
1858  MatrixType> * = nullptr>
1859  static void
1860  reinit_domain_vector(MatrixType & mat,
1862  bool /*omit_zeroing_entries*/)
1863  {
1864  vec.reinit(mat.locally_owned_domain_indices(),
1865  mat.get_mpi_communicator());
1866  }
1867 
1868  // Used for MatrixFree and DiagonalMatrix
1869  template <typename MatrixType,
1870 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1871  std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1872 #else
1873  // workaround for Intel 18
1874  std::enable_if_t<
1875  is_supported_operation<initialize_dof_vector_t, MatrixType>,
1876 #endif
1877  MatrixType> * = nullptr>
1878  static void
1879  reinit_domain_vector(MatrixType & mat,
1881  bool omit_zeroing_entries)
1882  {
1883  mat.initialize_dof_vector(vec);
1884  if (!omit_zeroing_entries)
1885  vec = Number();
1886  }
1887 
1888  // Used for (Trilinos/PETSc)Wrappers::SparseMatrix
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>,
1893 #else
1894  // workaround for Intel 18
1895  std::enable_if_t<
1896  is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1897  is_supported_operation<locally_owned_range_indices_t,
1898  MatrixType>,
1899 #endif
1900  MatrixType> * = nullptr>
1901  static void
1902  reinit_range_vector(MatrixType & mat,
1904  bool /*omit_zeroing_entries*/)
1905  {
1906  vec.reinit(mat.locally_owned_range_indices(),
1907  mat.get_mpi_communicator());
1908  }
1909 
1910  // Used for MatrixFree and DiagonalMatrix
1911  template <typename MatrixType,
1912 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1913  std::enable_if_t<has_initialize_dof_vector<MatrixType>,
1914 #else
1915  // workaround for Intel 18
1916  std::enable_if_t<
1917  is_supported_operation<initialize_dof_vector_t, MatrixType>,
1918 #endif
1919  MatrixType> * = nullptr>
1920  static void
1921  reinit_range_vector(MatrixType & mat,
1923  bool omit_zeroing_entries)
1924  {
1925  mat.initialize_dof_vector(vec);
1926  if (!omit_zeroing_entries)
1927  vec = Number();
1928  }
1929  };
1930 
1931  } // namespace LinearOperatorImplementation
1932 } /* namespace internal */
1933 
1934 
1936 
1937 #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
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
void reinit(const std::shared_ptr< const Utilities::MPI::Partitioner > &partitioner, const MPI_Comm &comm_sm=MPI_COMM_SELF)
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)
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
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)
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
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
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
const MPI_Comm & get_mpi_communicator() const
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 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
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
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:1586
static ::ExceptionBase & ExcNotAllowedForCuda()
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1759
#define AssertIndexRange(index, range)
Definition: exceptions.h:1827
#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