Reference documentation for deal.II version GIT eebce32b03 2022-06-26 16:25:02+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.h>
25 #include <deal.II/base/numbers.h>
26 #include <deal.II/base/parallel.h>
30 
34 
35 #include <iomanip>
36 #include <memory>
37 
39 
40 // Forward declarations
41 #ifndef DOXYGEN
42 namespace LinearAlgebra
43 {
47  namespace distributed
48  {
49  template <typename>
50  class BlockVector;
51  }
52 
53  template <typename>
54  class ReadWriteVector;
55 } // namespace LinearAlgebra
56 
57 # ifdef DEAL_II_WITH_PETSC
58 namespace PETScWrappers
59 {
60  namespace MPI
61  {
62  class Vector;
63  }
64 } // namespace PETScWrappers
65 # endif
66 
67 # ifdef DEAL_II_WITH_TRILINOS
68 namespace TrilinosWrappers
69 {
70  namespace MPI
71  {
72  class Vector;
73  }
74 } // namespace TrilinosWrappers
75 # endif
76 #endif
77 
78 namespace LinearAlgebra
79 {
80  namespace distributed
81  {
249  template <typename Number, typename MemorySpace = MemorySpace::Host>
251  public Subscriptor
252  {
253  public:
255  using value_type = Number;
256  using pointer = value_type *;
257  using const_pointer = const value_type *;
258  using iterator = value_type *;
259  using const_iterator = const value_type *;
261  using const_reference = const value_type &;
264 
265  static_assert(
266  std::is_same<MemorySpace, ::MemorySpace::Host>::value ||
267  std::is_same<MemorySpace, ::MemorySpace::CUDA>::value,
268  "MemorySpace should be Host or CUDA");
269 
278 
286 
294  Vector(Vector<Number, MemorySpace> &&in_vector); // NOLINT
295 
301 
318  Vector(const IndexSet &local_range,
319  const IndexSet &ghost_indices,
320  const MPI_Comm &communicator);
321 
325  Vector(const IndexSet &local_range, const MPI_Comm &communicator);
326 
334  const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner);
335 
339  virtual ~Vector() override;
340 
345  void
346  reinit(const size_type size, const bool omit_zeroing_entries = false);
347 
358  template <typename Number2>
359  void
361  const bool omit_zeroing_entries = false);
362 
379  void
380  reinit(const IndexSet &local_range,
381  const IndexSet &ghost_indices,
382  const MPI_Comm &communicator);
383 
387  void
388  reinit(const IndexSet &local_range, const MPI_Comm &communicator);
389 
402  void
404  const std::shared_ptr<const Utilities::MPI::Partitioner> &partitioner,
405  const MPI_Comm &comm_sm = MPI_COMM_SELF);
406 
426  void
428  const types::global_dof_index ghost_size,
429  const MPI_Comm & comm,
430  const MPI_Comm & comm_sm = MPI_COMM_SELF);
431 
444  void
446 
460 
472  template <typename Number2>
475 
477 
517  virtual void
518  compress(::VectorOperation::values operation) override;
519 
541  void
543 
561  void
563  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 
691 
696 
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;
892 
897 
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 
933 
934 
939 
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;
1156 
1161 
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 
1222 
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  namespace internal
1441  {
1442  template <typename Number, typename MemorySpace>
1443  struct Policy
1444  {
1445  static inline typename Vector<Number, MemorySpace>::iterator
1447  {
1448  return nullptr;
1449  }
1450 
1451  static inline typename Vector<Number, MemorySpace>::const_iterator
1452  begin(
1453  const ::MemorySpace::MemorySpaceData<Number, MemorySpace> &)
1454  {
1455  return nullptr;
1456  }
1457 
1458  static inline Number *
1459  get_values(
1461  {
1462  return nullptr;
1463  }
1464  };
1465 
1466 
1467 
1468  template <typename Number>
1469  struct Policy<Number, ::MemorySpace::Host>
1470  {
1471  static inline
1473  begin(::MemorySpace::
1474  MemorySpaceData<Number, ::MemorySpace::Host> &data)
1475  {
1476  return data.values.get();
1477  }
1478 
1479  static inline
1481  begin(const ::MemorySpace::
1482  MemorySpaceData<Number, ::MemorySpace::Host> &data)
1483  {
1484  return data.values.get();
1485  }
1486 
1487  static inline Number *
1488  get_values(::MemorySpace::
1489  MemorySpaceData<Number, ::MemorySpace::Host> &data)
1490  {
1491  return data.values.get();
1492  }
1493  };
1494 
1495 
1496 
1497  template <typename Number>
1498  struct Policy<Number, ::MemorySpace::CUDA>
1499  {
1500  static inline
1502  begin(::MemorySpace::
1503  MemorySpaceData<Number, ::MemorySpace::CUDA> &data)
1504  {
1505  return data.values_dev.get();
1506  }
1507 
1508  static inline
1510  begin(const ::MemorySpace::
1511  MemorySpaceData<Number, ::MemorySpace::CUDA> &data)
1512  {
1513  return data.values_dev.get();
1514  }
1515 
1516  static inline Number *
1517  get_values(::MemorySpace::
1518  MemorySpaceData<Number, ::MemorySpace::CUDA> &data)
1519  {
1520  return data.values_dev.get();
1521  }
1522  };
1523  } // namespace internal
1524 
1525 
1526  template <typename Number, typename MemorySpace>
1527  inline bool
1529  {
1530  return vector_is_ghosted;
1531  }
1532 
1533 
1534 
1535  template <typename Number, typename MemorySpace>
1538  {
1539  return partitioner->size();
1540  }
1541 
1542 
1543 
1544  template <typename Number, typename MemorySpace>
1547  {
1548  return locally_owned_size();
1549  }
1550 
1551 
1552 
1553  template <typename Number, typename MemorySpace>
1556  {
1557  return partitioner->locally_owned_size();
1558  }
1559 
1560 
1561 
1562  template <typename Number, typename MemorySpace>
1563  inline bool
1565  const size_type global_index) const
1566  {
1567  return partitioner->in_local_range(global_index);
1568  }
1569 
1570 
1571 
1572  template <typename Number, typename MemorySpace>
1573  inline IndexSet
1575  {
1576  IndexSet is(size());
1577 
1578  is.add_range(partitioner->local_range().first,
1579  partitioner->local_range().second);
1580 
1581  return is;
1582  }
1583 
1584 
1585 
1586  template <typename Number, typename MemorySpace>
1589  {
1591  }
1592 
1593 
1594 
1595  template <typename Number, typename MemorySpace>
1598  {
1600  }
1601 
1602 
1603 
1604  template <typename Number, typename MemorySpace>
1607  {
1609  partitioner->locally_owned_size();
1610  }
1611 
1612 
1613 
1614  template <typename Number, typename MemorySpace>
1617  {
1619  partitioner->locally_owned_size();
1620  }
1621 
1622 
1623 
1624  template <typename Number, typename MemorySpace>
1625  const std::vector<ArrayView<const Number>> &
1627  {
1628  return data.values_sm;
1629  }
1630 
1631 
1632 
1633  template <typename Number, typename MemorySpace>
1634  inline Number
1636  {
1637  Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1638  ExcMessage(
1639  "This function is only implemented for the Host memory space"));
1640  Assert(
1641  partitioner->in_local_range(global_index) ||
1642  partitioner->ghost_indices().is_element(global_index),
1643  ExcAccessToNonLocalElement(global_index,
1644  partitioner->local_range().first,
1645  partitioner->local_range().second == 0 ?
1646  0 :
1647  (partitioner->local_range().second - 1),
1648  partitioner->ghost_indices().n_elements()));
1649  // do not allow reading a vector which is not in ghost mode
1650  Assert(partitioner->in_local_range(global_index) ||
1651  vector_is_ghosted == true,
1652  ExcMessage("You tried to read a ghost element of this vector, "
1653  "but it has not imported its ghost values."));
1654  return data.values[partitioner->global_to_local(global_index)];
1655  }
1656 
1657 
1658 
1659  template <typename Number, typename MemorySpace>
1660  inline Number &
1662  {
1663  Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1664  ExcMessage(
1665  "This function is only implemented for the Host memory space"));
1666  Assert(
1667  partitioner->in_local_range(global_index) ||
1668  partitioner->ghost_indices().is_element(global_index),
1669  ExcAccessToNonLocalElement(global_index,
1670  partitioner->local_range().first,
1671  partitioner->local_range().second == 0 ?
1672  0 :
1673  (partitioner->local_range().second - 1),
1674  partitioner->ghost_indices().n_elements()));
1675  // we would like to prevent reading ghosts from a vector that does not
1676  // have them imported, but this is not possible because we might be in a
1677  // part of the code where the vector has enabled ghosts but is non-const
1678  // (then, the compiler picks this method according to the C++ rule book
1679  // even if a human would pick the const method when this subsequent use
1680  // is just a read)
1681  return data.values[partitioner->global_to_local(global_index)];
1682  }
1683 
1684 
1685 
1686  template <typename Number, typename MemorySpace>
1687  inline Number
1689  {
1690  return operator()(global_index);
1691  }
1692 
1693 
1694 
1695  template <typename Number, typename MemorySpace>
1696  inline Number &
1698  {
1699  return operator()(global_index);
1700  }
1701 
1702 
1703 
1704  template <typename Number, typename MemorySpace>
1705  inline Number
1707  const size_type local_index) const
1708  {
1709  Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1710  ExcMessage(
1711  "This function is only implemented for the Host memory space"));
1712  AssertIndexRange(local_index,
1713  partitioner->locally_owned_size() +
1714  partitioner->n_ghost_indices());
1715  // do not allow reading a vector which is not in ghost mode
1716  Assert(local_index < locally_owned_size() || vector_is_ghosted == true,
1717  ExcMessage("You tried to read a ghost element of this vector, "
1718  "but it has not imported its ghost values."));
1719 
1720  return data.values[local_index];
1721  }
1722 
1723 
1724 
1725  template <typename Number, typename MemorySpace>
1726  inline Number &
1728  {
1729  Assert((std::is_same<MemorySpace, ::MemorySpace::Host>::value),
1730  ExcMessage(
1731  "This function is only implemented for the Host memory space"));
1732 
1733  AssertIndexRange(local_index,
1734  partitioner->locally_owned_size() +
1735  partitioner->n_ghost_indices());
1736 
1737  return data.values[local_index];
1738  }
1739 
1740 
1741 
1742  template <typename Number, typename MemorySpace>
1743  inline Number *
1745  {
1746  return internal::Policy<Number, MemorySpace>::get_values(data);
1747  }
1748 
1749 
1750 
1751  template <typename Number, typename MemorySpace>
1752  template <typename OtherNumber>
1753  inline void
1755  const std::vector<size_type> &indices,
1756  std::vector<OtherNumber> & values) const
1757  {
1758  for (size_type i = 0; i < indices.size(); ++i)
1759  values[i] = operator()(indices[i]);
1760  }
1761 
1762 
1763 
1764  template <typename Number, typename MemorySpace>
1765  template <typename ForwardIterator, typename OutputIterator>
1766  inline void
1768  ForwardIterator indices_begin,
1769  const ForwardIterator indices_end,
1770  OutputIterator values_begin) const
1771  {
1772  while (indices_begin != indices_end)
1773  {
1774  *values_begin = operator()(*indices_begin);
1775  indices_begin++;
1776  values_begin++;
1777  }
1778  }
1779 
1780 
1781 
1782  template <typename Number, typename MemorySpace>
1783  template <typename OtherNumber>
1784  inline void
1786  const std::vector<size_type> & indices,
1787  const ::Vector<OtherNumber> &values)
1788  {
1789  AssertDimension(indices.size(), values.size());
1790  for (size_type i = 0; i < indices.size(); ++i)
1791  {
1792  Assert(
1794  ExcMessage(
1795  "The given value is not finite but either infinite or Not A Number (NaN)"));
1796  this->operator()(indices[i]) += values(i);
1797  }
1798  }
1799 
1800 
1801 
1802  template <typename Number, typename MemorySpace>
1803  template <typename OtherNumber>
1804  inline void
1806  const size_type * indices,
1807  const OtherNumber *values)
1808  {
1809  for (size_type i = 0; i < n_elements; ++i, ++indices, ++values)
1810  {
1811  Assert(
1813  ExcMessage(
1814  "The given value is not finite but either infinite or Not A Number (NaN)"));
1815  this->operator()(*indices) += *values;
1816  }
1817  }
1818 
1819 
1820 
1821  template <typename Number, typename MemorySpace>
1822  inline const MPI_Comm &
1824  {
1825  return partitioner->get_mpi_communicator();
1826  }
1827 
1828 
1829 
1830  template <typename Number, typename MemorySpace>
1831  inline const std::shared_ptr<const Utilities::MPI::Partitioner> &
1833  {
1834  return partitioner;
1835  }
1836 
1837 
1838 
1839  template <typename Number, typename MemorySpace>
1840  inline void
1841  Vector<Number, MemorySpace>::set_ghost_state(const bool ghosted) const
1842  {
1843  vector_is_ghosted = ghosted;
1844  }
1845 
1846 #endif
1847 
1848  } // namespace distributed
1849 } // namespace LinearAlgebra
1850 
1851 
1859 template <typename Number, typename MemorySpace>
1860 inline void
1863 {
1864  u.swap(v);
1865 }
1866 
1867 
1871 template <typename Number, typename MemorySpace>
1873  : std::false_type
1874 {};
1875 
1876 
1877 
1878 namespace internal
1879 {
1880  namespace LinearOperatorImplementation
1881  {
1882  template <typename>
1883  class ReinitHelper;
1884 
1889  template <typename Number>
1891  {
1892  public:
1893  // A helper type-trait that leverage SFINAE to figure out if type T has
1894  // void T::get_mpi_communicator()
1895  template <typename T>
1897  decltype(std::declval<T>().get_mpi_communicator());
1898 
1899  template <typename T>
1900  static constexpr bool has_get_mpi_communicator =
1901  is_supported_operation<get_mpi_communicator_t, T>;
1902 
1903  // A helper type-trait that leverage SFINAE to figure out if type T has
1904  // void T::locally_owned_domain_indices()
1905  template <typename T>
1907  decltype(std::declval<T>().locally_owned_domain_indices());
1908 
1909  template <typename T>
1910  static constexpr bool has_locally_owned_domain_indices =
1911  is_supported_operation<locally_owned_domain_indices_t, T>;
1912 
1913  // A helper type-trait that leverage SFINAE to figure out if type T has
1914  // void T::locally_owned_range_indices()
1915  template <typename T>
1917  decltype(std::declval<T>().locally_owned_range_indices());
1918 
1919  template <typename T>
1920  static constexpr bool has_locally_owned_range_indices =
1921  is_supported_operation<locally_owned_range_indices_t, T>;
1922 
1923  // A helper type-trait that leverage SFINAE to figure out if type T has
1924  // void T::initialize_dof_vector(VectorType v)
1925  template <typename T>
1927  decltype(std::declval<T>().initialize_dof_vector(
1928  std::declval<LinearAlgebra::distributed::Vector<Number> &>()));
1929 
1930  template <typename T>
1931  static constexpr bool has_initialize_dof_vector =
1932  is_supported_operation<initialize_dof_vector_t, T>;
1933 
1934  // Used for (Trilinos/PETSc)Wrappers::SparseMatrix
1935  template <
1936  typename MatrixType,
1937 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1938  typename std::enable_if<has_get_mpi_communicator<MatrixType> &&
1939  has_locally_owned_domain_indices<MatrixType>,
1940 #else
1941  // workaround for Intel 18
1942  typename std::enable_if<
1943  is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1944  is_supported_operation<locally_owned_domain_indices_t, MatrixType>,
1945 #endif
1946  MatrixType>::type * = nullptr>
1947  static void
1948  reinit_domain_vector(MatrixType & mat,
1950  bool /*omit_zeroing_entries*/)
1951  {
1952  vec.reinit(mat.locally_owned_domain_indices(),
1953  mat.get_mpi_communicator());
1954  }
1955 
1956  // Used for MatrixFree and DiagonalMatrix
1957  template <typename MatrixType,
1958 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1959  typename std::enable_if<has_initialize_dof_vector<MatrixType>,
1960 #else
1961  // workaround for Intel 18
1962  typename std::enable_if<
1963  is_supported_operation<initialize_dof_vector_t, MatrixType>,
1964 #endif
1965  MatrixType>::type * = nullptr>
1966  static void
1967  reinit_domain_vector(MatrixType & mat,
1969  bool omit_zeroing_entries)
1970  {
1971  mat.initialize_dof_vector(vec);
1972  if (!omit_zeroing_entries)
1973  vec = Number();
1974  }
1975 
1976  // Used for (Trilinos/PETSc)Wrappers::SparseMatrix
1977  template <
1978  typename MatrixType,
1979 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
1980  typename std::enable_if<has_get_mpi_communicator<MatrixType> &&
1981  has_locally_owned_range_indices<MatrixType>,
1982 #else
1983  // workaround for Intel 18
1984  typename std::enable_if<
1985  is_supported_operation<get_mpi_communicator_t, MatrixType> &&
1986  is_supported_operation<locally_owned_range_indices_t, MatrixType>,
1987 #endif
1988  MatrixType>::type * = nullptr>
1989  static void
1990  reinit_range_vector(MatrixType & mat,
1992  bool /*omit_zeroing_entries*/)
1993  {
1994  vec.reinit(mat.locally_owned_range_indices(),
1995  mat.get_mpi_communicator());
1996  }
1997 
1998  // Used for MatrixFree and DiagonalMatrix
1999  template <typename MatrixType,
2000 #if !defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1900
2001  typename std::enable_if<has_initialize_dof_vector<MatrixType>,
2002 #else
2003  // workaround for Intel 18
2004  typename std::enable_if<
2005  is_supported_operation<initialize_dof_vector_t, MatrixType>,
2006 #endif
2007  MatrixType>::type * = nullptr>
2008  static void
2009  reinit_range_vector(MatrixType & mat,
2011  bool omit_zeroing_entries)
2012  {
2013  mat.initialize_dof_vector(vec);
2014  if (!omit_zeroing_entries)
2015  vec = Number();
2016  }
2017  };
2018 
2019  } // namespace LinearOperatorImplementation
2020 } /* namespace internal */
2021 
2022 
2024 
2025 #endif
Definition: vector.h:109
void swap(LinearAlgebra::distributed::Vector< Number, MemorySpace > &u, LinearAlgebra::distributed::Vector< Number, MemorySpace > &v)
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)
#define DEAL_II_DEPRECATED
Definition: config.h:164
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:442
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:443
#define DeclException0(Exception0)
Definition: exceptions.h:464
#define DeclException4(Exception4, type1, type2, type3, type4, outsequence)
Definition: exceptions.h:578
#define Assert(cond, exc)
Definition: exceptions.h:1473
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1667
#define AssertIndexRange(index, range)
Definition: exceptions.h:1732
#define DeclException3(Exception3, type1, type2, type3, outsequence)
Definition: exceptions.h:555
static ::ExceptionBase & ExcMessage(std::string arg1)
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
decltype(std::declval< T >().initialize_dof_vector(std::declval< LinearAlgebra::distributed::Vector< Number > & >())) initialize_dof_vector_t
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)
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)
const value_type * const_iterator
Definition: vector.h:125
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
static void reinit_range_vector(MatrixType &mat, LinearAlgebra::distributed::Vector< Number > &vec, bool)
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)
static ::ExceptionBase & ExcVectorTypeNotCompatible()
virtual std::size_t memory_consumption() const override
static ::ExceptionBase & ExcNonMatchingElements(Number arg1, Number arg2, unsigned int arg3)
const std::shared_ptr< const Utilities::MPI::Partitioner > & get_partitioner() const
Number & operator()(const size_type global_index)
types::global_dof_index size_type
Definition: vector.h:128
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
static ::ExceptionBase & ExcAccessToNonLocalElement(size_type arg1, size_type arg2, size_type arg3, size_type arg4)
static ::ExceptionBase & ExcNotAllowedForCuda()
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)
virtual void compress(::VectorOperation::values operation) override
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
void compress_start(const unsigned int communication_channel=0, ::VectorOperation::values operation=VectorOperation::add)
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
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)
value_type * iterator
Definition: vector.h:124
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)
static void reinit_domain_vector(MatrixType &mat, LinearAlgebra::distributed::Vector< Number > &vec, bool)
void extract_subvector_to(const std::vector< size_type > &indices, std::vector< OtherNumber > &values) const
virtual Vector< Number, MemorySpace > & operator*=(const Number factor) override
void compress_finish(::VectorOperation::values operation)
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
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)
VectorType::value_type * begin(VectorType &V)
TrilinosWrappers::types::int_type global_index(const Epetra_BlockMap &map, const ::types::global_dof_index i)
bool is_finite(const double x)
Definition: numbers.h:539
unsigned int global_dof_index
Definition: types.h:76
const MPI_Comm & comm