Reference documentation for deal.II version Git 292c2606a1 2021-03-03 00:48:14 +0100
\(\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\}}\)
dof_handler.h
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 1998 - 2020 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_dof_handler_h
17 #define dealii_dof_handler_h
18 
19 
20 
21 #include <deal.II/base/config.h>
22 
24 #include <deal.II/base/function.h>
25 #include <deal.II/base/index_set.h>
28 
30 
33 #include <deal.II/dofs/dof_faces.h>
37 
39 
40 #include <boost/serialization/split_member.hpp>
41 
42 #include <map>
43 #include <memory>
44 #include <set>
45 #include <vector>
46 
48 
49 // Forward declarations
50 #ifndef DOXYGEN
51 template <int dim, int spacedim>
52 class FiniteElement;
53 template <int dim, int spacedim>
54 class Triangulation;
55 
56 namespace internal
57 {
58  namespace DoFHandlerImplementation
59  {
60  struct Implementation;
61 
62  namespace Policy
63  {
64  template <int dim, int spacedim>
65  class PolicyBase;
66  struct Implementation;
67  } // namespace Policy
68  } // namespace DoFHandlerImplementation
69 
70  namespace DoFAccessorImplementation
71  {
72  struct Implementation;
73  }
74 
75  namespace DoFCellAccessorImplementation
76  {
77  struct Implementation;
78  }
79 
80  namespace hp
81  {
82  namespace DoFHandlerImplementation
83  {
84  struct Implementation;
85  }
86  } // namespace hp
87 } // namespace internal
88 
89 namespace parallel
90 {
91  namespace distributed
92  {
93  template <int dim, int spacedim, typename VectorType>
94  class CellDataTransfer;
95  }
96 } // namespace parallel
97 #endif
98 
313 template <int dim, int spacedim = dim>
314 class DoFHandler : public Subscriptor
315 {
316  using ActiveSelector =
318  using LevelSelector =
320 
321 public:
334  using cell_accessor = typename ActiveSelector::CellAccessor;
335 
348  using face_accessor = typename ActiveSelector::FaceAccessor;
349 
357  using line_iterator = typename ActiveSelector::line_iterator;
358 
372  using active_line_iterator = typename ActiveSelector::active_line_iterator;
373 
381  using quad_iterator = typename ActiveSelector::quad_iterator;
382 
396  using active_quad_iterator = typename ActiveSelector::active_quad_iterator;
397 
405  using hex_iterator = typename ActiveSelector::hex_iterator;
406 
416  using active_hex_iterator = typename ActiveSelector::active_hex_iterator;
417 
438  using active_cell_iterator = typename ActiveSelector::active_cell_iterator;
439 
466  using cell_iterator = typename ActiveSelector::cell_iterator;
467 
484  using face_iterator = typename ActiveSelector::face_iterator;
485 
497  using active_face_iterator = typename ActiveSelector::active_face_iterator;
498 
499  using level_cell_accessor = typename LevelSelector::CellAccessor;
500  using level_face_accessor = typename LevelSelector::FaceAccessor;
501 
502  using level_cell_iterator = typename LevelSelector::cell_iterator;
503  using level_face_iterator = typename LevelSelector::face_iterator;
504 
505 
509  static const unsigned int dimension = dim;
510 
514  static const unsigned int space_dimension = spacedim;
515 
519  static const unsigned int default_fe_index = 0;
520 
524  static const unsigned int invalid_fe_index = numbers::invalid_unsigned_int;
525 
529  using active_fe_index_type = unsigned short int;
530 
534  using offset_type = unsigned int;
535 
540  static const active_fe_index_type invalid_active_fe_index =
541  static_cast<active_fe_index_type>(-1);
542 
547  DoFHandler();
548 
553 
560  DoFHandler(const DoFHandler &) = delete;
561 
565  virtual ~DoFHandler() override;
566 
573  DoFHandler &
574  operator=(const DoFHandler &) = delete;
575 
583  void
584  initialize(const Triangulation<dim, spacedim> &tria,
585  const FiniteElement<dim, spacedim> &fe);
586 
593  void
594  initialize(const Triangulation<dim, spacedim> & tria,
596 
621  void
622  set_fe(const FiniteElement<dim, spacedim> &fe);
623 
630  void
631  set_fe(const hp::FECollection<dim, spacedim> &fe);
632 
637  void
638  set_active_fe_indices(const std::vector<unsigned int> &active_fe_indices);
639 
645  void
646  get_active_fe_indices(std::vector<unsigned int> &active_fe_indices) const;
647 
655  void
657 
687  void
688  distribute_dofs(const FiniteElement<dim, spacedim> &fe);
689 
693  void
694  distribute_dofs(const hp::FECollection<dim, spacedim> &fe);
695 
701  void
702  distribute_mg_dofs();
703 
707  bool
708  has_hp_capabilities() const;
709 
715  bool
716  has_level_dofs() const;
717 
732  bool
733  has_active_dofs() const;
734 
741  void
742  initialize_local_block_info();
743 
747  void
748  clear();
749 
802  void
803  renumber_dofs(const std::vector<types::global_dof_index> &new_numbers);
804 
809  void
810  renumber_dofs(const unsigned int level,
811  const std::vector<types::global_dof_index> &new_numbers);
812 
841  unsigned int
842  max_couplings_between_dofs() const;
843 
856  unsigned int
857  max_couplings_between_boundary_dofs() const;
858 
859  /*--------------------------------------*/
860 
865  /*
866  * @{
867  */
868 
873  begin(const unsigned int level = 0) const;
874 
892  begin_active(const unsigned int level = 0) const;
893 
899  end() const;
900 
906  end(const unsigned int level) const;
907 
914  end_active(const unsigned int level) const;
915 
921  begin_mg(const unsigned int level = 0) const;
922 
928  end_mg(const unsigned int level) const;
929 
935  end_mg() const;
936 
952  cell_iterators() const;
953 
995  active_cell_iterators() const;
996 
1009  mg_cell_iterators() const;
1010 
1027  cell_iterators_on_level(const unsigned int level) const;
1028 
1045  active_cell_iterators_on_level(const unsigned int level) const;
1046 
1063  mg_cell_iterators_on_level(const unsigned int level) const;
1064 
1065  /*
1066  * @}
1067  */
1068 
1069 
1070  /*---------------------------------------*/
1071 
1072 
1097  n_dofs() const;
1098 
1107  n_dofs(const unsigned int level) const;
1108 
1114  n_boundary_dofs() const;
1115 
1127  template <typename number>
1129  n_boundary_dofs(
1130  const std::map<types::boundary_id, const Function<spacedim, number> *>
1131  &boundary_ids) const;
1132 
1138  n_boundary_dofs(const std::set<types::boundary_id> &boundary_ids) const;
1139 
1155  const BlockInfo &
1156  block_info() const;
1157 
1178  n_locally_owned_dofs() const;
1179 
1185  const IndexSet &
1186  locally_owned_dofs() const;
1187 
1192  const IndexSet &
1193  locally_owned_mg_dofs(const unsigned int level) const;
1194 
1208  DEAL_II_DEPRECATED const std::vector<IndexSet> &
1209  locally_owned_dofs_per_processor() const;
1210 
1227  DEAL_II_DEPRECATED const std::vector<types::global_dof_index> &
1228  n_locally_owned_dofs_per_processor() const;
1229 
1244  DEAL_II_DEPRECATED const std::vector<IndexSet> &
1245  locally_owned_mg_dofs_per_processor(const unsigned int level) const;
1246 
1253  get_fe(const unsigned int index = 0) const;
1254 
1262  get_fe_collection() const;
1263 
1268  get_triangulation() const;
1269 
1273  MPI_Comm
1274  get_communicator() const;
1275 
1292  void
1293  prepare_for_serialization_of_active_fe_indices();
1294 
1310  void
1311  deserialize_active_fe_indices();
1312 
1321  virtual std::size_t
1322  memory_consumption() const;
1323 
1329  template <class Archive>
1330  void
1331  save(Archive &ar, const unsigned int version) const;
1332 
1338  template <class Archive>
1339  void
1340  load(Archive &ar, const unsigned int version);
1341 
1342 #ifdef DOXYGEN
1343 
1348  template <class Archive>
1349  void
1350  serialize(Archive &archive, const unsigned int version);
1351 #else
1352  // This macro defines the serialize() method that is compatible with
1353  // the templated save() and load() method that have been implemented.
1354  BOOST_SERIALIZATION_SPLIT_MEMBER()
1355 #endif
1356 
1370  DeclException1(ExcInvalidLevel,
1371  int,
1372  << "The given level " << arg1
1373  << " is not in the valid range!");
1378  DeclException1(ExcNewNumbersNotConsecutive,
1380  << "The given list of new dof indices is not consecutive: "
1381  << "the index " << arg1 << " does not exist.");
1385  DeclException2(ExcInvalidFEIndex,
1386  int,
1387  int,
1388  << "The mesh contains a cell with an active FE index of "
1389  << arg1 << ", but the finite element collection only has "
1390  << arg2 << " elements");
1391 
1396  DeclExceptionMsg(ExcOnlyAvailableWithHP,
1397  "The current function doesn't make sense when used with a "
1398  "DoFHandler without hp-capabilities.");
1399 
1404  DeclExceptionMsg(ExcNotImplementedWithHP,
1405  "The current function has not yet been implemented for a "
1406  "DoFHandler with hp-capabilities.");
1407 
1408 private:
1416  {
1417  public:
1421  MGVertexDoFs();
1422 
1428  void
1429  init(const unsigned int coarsest_level,
1430  const unsigned int finest_level,
1431  const unsigned int dofs_per_vertex);
1432 
1436  unsigned int
1437  get_coarsest_level() const;
1438 
1442  unsigned int
1443  get_finest_level() const;
1444 
1450  get_index(const unsigned int level,
1451  const unsigned int dof_number,
1452  const unsigned int dofs_per_vertex) const;
1453 
1458  void
1459  set_index(const unsigned int level,
1460  const unsigned int dof_number,
1461  const unsigned int dofs_per_vertex,
1462  const types::global_dof_index index);
1463 
1464  private:
1468  unsigned int coarsest_level;
1469 
1473  unsigned int finest_level;
1474 
1484  std::unique_ptr<types::global_dof_index[]> indices;
1485  };
1486 
1494  {
1499  std::map<const cell_iterator, const unsigned int> persisting_cells_fe_index;
1500 
1505  std::map<const cell_iterator, const unsigned int> refined_cells_fe_index;
1506 
1511  std::map<const cell_iterator, const unsigned int> coarsened_cells_fe_index;
1512 
1518  std::vector<unsigned int> active_fe_indices;
1519 
1525  std::unique_ptr<
1526  parallel::distributed::
1527  CellDataTransfer<dim, spacedim, std::vector<unsigned int>>>
1529  };
1530 
1535 
1541 
1547 
1554 
1559  std::unique_ptr<::internal::DoFHandlerImplementation::Policy::
1560  PolicyBase<dim, spacedim>>
1562 
1571 
1575  std::vector<::internal::DoFHandlerImplementation::NumberCache>
1577 
1583  mutable std::vector<std::vector<types::global_dof_index>>
1585 
1590  mutable std::vector<std::vector<offset_type>> cell_dof_cache_ptr;
1591 
1597  mutable std::vector<std::array<std::vector<types::global_dof_index>, dim + 1>>
1599 
1608  mutable std::vector<std::array<std::vector<offset_type>, dim + 1>>
1610 
1616  mutable std::array<std::vector<active_fe_index_type>, dim + 1>
1618 
1622  mutable std::array<std::vector<offset_type>, dim + 1> hp_object_fe_ptr;
1623 
1628  mutable std::vector<std::vector<active_fe_index_type>>
1630 
1635  mutable std::vector<std::vector<active_fe_index_type>>
1637 
1642  std::vector<MGVertexDoFs> mg_vertex_dofs;
1643 
1647  std::vector<
1648  std::unique_ptr<::internal::DoFHandlerImplementation::DoFLevel<dim>>>
1650 
1654  std::unique_ptr<::internal::DoFHandlerImplementation::DoFFaces<dim>>
1656 
1661  std::unique_ptr<ActiveFEIndexTransfer> active_fe_index_transfer;
1662 
1667  std::vector<boost::signals2::connection> tria_listeners;
1668 
1674  std::vector<boost::signals2::connection> tria_listeners_for_transfer;
1675 
1679  void
1680  clear_space();
1681 
1685  void
1686  clear_mg_space();
1687 
1691  template <int structdim>
1693  get_dof_index(const unsigned int obj_level,
1694  const unsigned int obj_index,
1695  const unsigned int fe_index,
1696  const unsigned int local_index) const;
1697 
1701  template <int structdim>
1702  void
1703  set_dof_index(const unsigned int obj_level,
1704  const unsigned int obj_index,
1705  const unsigned int fe_index,
1706  const unsigned int local_index,
1708 
1712  void
1713  setup_policy();
1714 
1718  void
1719  connect_to_triangulation_signals();
1720 
1732  void
1733  create_active_fe_table();
1734 
1747  void
1748  update_active_fe_table();
1749 
1759  void
1760  pre_transfer_action();
1761 
1770  void
1771  post_transfer_action();
1772 
1781  void
1782  pre_distributed_transfer_action();
1783 
1792  void
1793  post_distributed_transfer_action();
1794 
1795 
1796  // Make accessor objects friends.
1797  template <int, int, int, bool>
1798  friend class ::DoFAccessor;
1799  template <int, int, bool>
1800  friend class ::DoFCellAccessor;
1801  friend struct ::internal::DoFAccessorImplementation::Implementation;
1802  friend struct ::internal::DoFCellAccessorImplementation::Implementation;
1803 
1804  // Likewise for DoFLevel objects since they need to access the vertex dofs
1805  // in the functions that set and retrieve vertex dof indices.
1806  friend struct ::internal::DoFHandlerImplementation::Implementation;
1807  friend struct ::internal::hp::DoFHandlerImplementation::Implementation;
1808  friend struct ::internal::DoFHandlerImplementation::Policy::
1809  Implementation;
1810 
1811  // explicitly check for sensible template arguments, but not on windows
1812  // because MSVC creates bogus warnings during normal compilation
1813 #ifndef DEAL_II_MSVC
1814  static_assert(dim <= spacedim,
1815  "The dimension <dim> of a DoFHandler must be less than or "
1816  "equal to the space dimension <spacedim> in which it lives.");
1817 #endif
1818 };
1819 
1820 #ifndef DOXYGEN
1821 
1822 /* ----------------------- Inline functions ----------------------------------
1823  */
1824 
1825 
1826 template <int dim, int spacedim>
1827 inline bool
1829 {
1830  return hp_capability_enabled;
1831 }
1832 
1833 
1834 
1835 template <int dim, int spacedim>
1836 inline bool
1838 {
1839  return mg_number_cache.size() > 0;
1840 }
1841 
1842 
1843 
1844 template <int dim, int spacedim>
1845 inline bool
1847 {
1848  return number_cache.n_global_dofs > 0;
1849 }
1850 
1851 
1852 
1853 template <int dim, int spacedim>
1856 {
1857  return number_cache.n_global_dofs;
1858 }
1859 
1860 
1861 
1862 template <int dim, int spacedim>
1864 DoFHandler<dim, spacedim>::n_dofs(const unsigned int level) const
1865 {
1866  Assert(has_level_dofs(),
1867  ExcMessage(
1868  "n_dofs(level) can only be called after distribute_mg_dofs()"));
1869  Assert(level < mg_number_cache.size(), ExcInvalidLevel(level));
1870  return mg_number_cache[level].n_global_dofs;
1871 }
1872 
1873 
1874 
1875 template <int dim, int spacedim>
1878 {
1879  return number_cache.n_locally_owned_dofs;
1880 }
1881 
1882 
1883 
1884 template <int dim, int spacedim>
1885 const IndexSet &
1887 {
1888  return number_cache.locally_owned_dofs;
1889 }
1890 
1891 
1892 
1893 template <int dim, int spacedim>
1894 const IndexSet &
1895 DoFHandler<dim, spacedim>::locally_owned_mg_dofs(const unsigned int level) const
1896 {
1897  Assert(level < this->get_triangulation().n_global_levels(),
1898  ExcMessage("The given level index exceeds the number of levels "
1899  "present in the triangulation"));
1900  Assert(
1901  mg_number_cache.size() == this->get_triangulation().n_global_levels(),
1902  ExcMessage(
1903  "The level dofs are not set up properly! Did you call distribute_mg_dofs()?"));
1904  return mg_number_cache[level].locally_owned_dofs;
1905 }
1906 
1907 
1908 
1909 template <int dim, int spacedim>
1910 const std::vector<types::global_dof_index> &
1912 {
1913  if (number_cache.n_locally_owned_dofs_per_processor.empty() &&
1914  number_cache.n_global_dofs > 0)
1915  {
1916  MPI_Comm comm;
1917 
1919  (dynamic_cast<const parallel::TriangulationBase<dim, spacedim> *>(
1920  &this->get_triangulation()));
1921  if (tr != nullptr)
1922  comm = tr->get_communicator();
1923  else
1924  comm = MPI_COMM_SELF;
1925 
1927  number_cache)
1928  .n_locally_owned_dofs_per_processor =
1929  number_cache.get_n_locally_owned_dofs_per_processor(comm);
1930  }
1931  return number_cache.n_locally_owned_dofs_per_processor;
1932 }
1933 
1934 
1935 
1936 template <int dim, int spacedim>
1937 const std::vector<IndexSet> &
1939 {
1940  if (number_cache.locally_owned_dofs_per_processor.empty() &&
1941  number_cache.n_global_dofs > 0)
1942  {
1943  MPI_Comm comm;
1944 
1946  (dynamic_cast<const parallel::TriangulationBase<dim, spacedim> *>(
1947  &this->get_triangulation()));
1948  if (tr != nullptr)
1949  comm = tr->get_communicator();
1950  else
1951  comm = MPI_COMM_SELF;
1952 
1954  number_cache)
1955  .locally_owned_dofs_per_processor =
1956  number_cache.get_locally_owned_dofs_per_processor(comm);
1957  }
1958  return number_cache.locally_owned_dofs_per_processor;
1959 }
1960 
1961 
1962 
1963 template <int dim, int spacedim>
1964 const std::vector<IndexSet> &
1966  const unsigned int level) const
1967 {
1968  Assert(level < this->get_triangulation().n_global_levels(),
1969  ExcMessage("The given level index exceeds the number of levels "
1970  "present in the triangulation"));
1971  Assert(
1972  mg_number_cache.size() == this->get_triangulation().n_global_levels(),
1973  ExcMessage(
1974  "The level dofs are not set up properly! Did you call distribute_mg_dofs()?"));
1975  if (mg_number_cache[level].locally_owned_dofs_per_processor.empty() &&
1976  mg_number_cache[level].n_global_dofs > 0)
1977  {
1978  MPI_Comm comm;
1979 
1981  (dynamic_cast<const parallel::TriangulationBase<dim, spacedim> *>(
1982  &this->get_triangulation()));
1983  if (tr != nullptr)
1984  comm = tr->get_communicator();
1985  else
1986  comm = MPI_COMM_SELF;
1987 
1989  mg_number_cache[level])
1990  .locally_owned_dofs_per_processor =
1991  mg_number_cache[level].get_locally_owned_dofs_per_processor(comm);
1992  }
1993  return mg_number_cache[level].locally_owned_dofs_per_processor;
1994 }
1995 
1996 
1997 
1998 template <int dim, int spacedim>
1999 inline const FiniteElement<dim, spacedim> &
2000 DoFHandler<dim, spacedim>::get_fe(const unsigned int number) const
2001 {
2002  Assert(fe_collection.size() > 0,
2003  ExcMessage("No finite element collection is associated with "
2004  "this DoFHandler"));
2005  return fe_collection[number];
2006 }
2007 
2008 
2009 
2010 template <int dim, int spacedim>
2011 inline const hp::FECollection<dim, spacedim> &
2013 {
2014  Assert(fe_collection.size() > 0,
2015  ExcMessage("No finite element collection is associated with "
2016  "this DoFHandler"));
2017  return fe_collection;
2018 }
2019 
2020 
2021 
2022 template <int dim, int spacedim>
2023 inline const Triangulation<dim, spacedim> &
2025 {
2026  Assert(tria != nullptr,
2027  ExcMessage("This DoFHandler object has not been associated "
2028  "with a triangulation."));
2029  return *tria;
2030 }
2031 
2032 
2033 
2034 template <int dim, int spacedim>
2035 inline MPI_Comm
2037 {
2038  Assert(tria != nullptr,
2039  ExcMessage("This DoFHandler object has not been associated "
2040  "with a triangulation."));
2041  return tria->get_communicator();
2042 }
2043 
2044 
2045 
2046 template <int dim, int spacedim>
2047 inline const BlockInfo &
2049 {
2050  Assert(this->hp_capability_enabled == false, ExcNotImplementedWithHP());
2051 
2052  return block_info_object;
2053 }
2054 
2055 
2056 
2057 template <int dim, int spacedim>
2058 template <typename number>
2061  const std::map<types::boundary_id, const Function<spacedim, number> *>
2062  &boundary_ids) const
2063 {
2064  Assert(!(dim == 2 && spacedim == 3) || this->hp_capability_enabled == false,
2065  ExcNotImplementedWithHP());
2066 
2067  // extract the set of boundary ids and forget about the function object
2068  // pointers
2069  std::set<types::boundary_id> boundary_ids_only;
2070  for (typename std::map<types::boundary_id,
2071  const Function<spacedim, number> *>::const_iterator p =
2072  boundary_ids.begin();
2073  p != boundary_ids.end();
2074  ++p)
2075  boundary_ids_only.insert(p->first);
2076 
2077  // then just hand everything over to the other function that does the work
2078  return n_boundary_dofs(boundary_ids_only);
2079 }
2080 
2081 
2082 
2083 namespace internal
2084 {
2092  template <int dim, int spacedim>
2093  std::string
2094  policy_to_string(const ::internal::DoFHandlerImplementation::Policy::
2095  PolicyBase<dim, spacedim> &policy);
2096 } // namespace internal
2097 
2098 
2099 
2100 template <int dim, int spacedim>
2101 template <class Archive>
2102 void
2103 DoFHandler<dim, spacedim>::save(Archive &ar, const unsigned int) const
2104 {
2105  if (this->hp_capability_enabled)
2106  {
2107  ar & this->object_dof_indices;
2108  ar & this->object_dof_ptr;
2109 
2110  ar & this->cell_dof_cache_indices;
2111  ar & this->cell_dof_cache_ptr;
2112 
2113  ar & this->hp_cell_active_fe_indices;
2114  ar & this->hp_cell_future_fe_indices;
2115 
2116  ar &hp_object_fe_ptr;
2117  ar &hp_object_fe_indices;
2118 
2119  ar &number_cache;
2120 
2121  ar &mg_number_cache;
2122 
2123  // write out the number of triangulation cells and later check during
2124  // loading that this number is indeed correct; same with something that
2125  // identifies the policy
2126  const unsigned int n_cells = this->tria->n_cells();
2127  std::string policy_name =
2128  ::internal::policy_to_string(*this->policy);
2129 
2130  ar &n_cells &policy_name;
2131  }
2132  else
2133  {
2134  ar & this->block_info_object;
2135  ar &number_cache;
2136 
2137  ar & this->object_dof_indices;
2138  ar & this->object_dof_ptr;
2139 
2140  ar & this->cell_dof_cache_indices;
2141  ar & this->cell_dof_cache_ptr;
2142 
2143  // write out the number of triangulation cells and later check during
2144  // loading that this number is indeed correct; same with something that
2145  // identifies the FE and the policy
2146  unsigned int n_cells = this->tria->n_cells();
2147  std::string fe_name = this->get_fe(0).get_name();
2148  std::string policy_name = internal::policy_to_string(*this->policy);
2149 
2150  ar &n_cells &fe_name &policy_name;
2151  }
2152 }
2153 
2154 
2155 
2156 template <int dim, int spacedim>
2157 template <class Archive>
2158 void
2159 DoFHandler<dim, spacedim>::load(Archive &ar, const unsigned int)
2160 {
2161  if (this->hp_capability_enabled)
2162  {
2163  ar & this->object_dof_indices;
2164  ar & this->object_dof_ptr;
2165 
2166  ar & this->cell_dof_cache_indices;
2167  ar & this->cell_dof_cache_ptr;
2168 
2169  ar & this->hp_cell_active_fe_indices;
2170  ar & this->hp_cell_future_fe_indices;
2171 
2172  ar &hp_object_fe_ptr;
2173  ar &hp_object_fe_indices;
2174 
2175  ar &number_cache;
2176 
2177  ar &mg_number_cache;
2178 
2179  // these are the checks that correspond to the last block in the save()
2180  // function
2181  unsigned int n_cells;
2182  std::string policy_name;
2183 
2184  ar &n_cells &policy_name;
2185 
2186  AssertThrow(
2187  n_cells == this->tria->n_cells(),
2188  ExcMessage(
2189  "The object being loaded into does not match the triangulation "
2190  "that has been stored previously."));
2191  AssertThrow(
2192  policy_name == ::internal::policy_to_string(*this->policy),
2193  ExcMessage("The policy currently associated with this DoFHandler (" +
2194  ::internal::policy_to_string(*this->policy) +
2195  ") does not match the one that was associated with the "
2196  "DoFHandler previously stored (" +
2197  policy_name + ")."));
2198  }
2199  else
2200  {
2201  ar & this->block_info_object;
2202  ar &number_cache;
2203 
2204  object_dof_indices.clear();
2205 
2206  object_dof_ptr.clear();
2207 
2208  ar & this->object_dof_indices;
2209  ar & this->object_dof_ptr;
2210 
2211  ar & this->cell_dof_cache_indices;
2212  ar & this->cell_dof_cache_ptr;
2213 
2214  // these are the checks that correspond to the last block in the save()
2215  // function
2216  unsigned int n_cells;
2217  std::string fe_name;
2218  std::string policy_name;
2219 
2220  ar &n_cells &fe_name &policy_name;
2221 
2222  AssertThrow(
2223  n_cells == this->tria->n_cells(),
2224  ExcMessage(
2225  "The object being loaded into does not match the triangulation "
2226  "that has been stored previously."));
2227  AssertThrow(
2228  fe_name == this->get_fe(0).get_name(),
2229  ExcMessage(
2230  "The finite element associated with this DoFHandler does not match "
2231  "the one that was associated with the DoFHandler previously stored."));
2232  AssertThrow(policy_name == internal::policy_to_string(*this->policy),
2233  ExcMessage(
2234  "The policy currently associated with this DoFHandler (" +
2235  internal::policy_to_string(*this->policy) +
2236  ") does not match the one that was associated with the "
2237  "DoFHandler previously stored (" +
2238  policy_name + ")."));
2239  }
2240 }
2241 
2242 
2243 
2244 template <int dim, int spacedim>
2247  const unsigned int level,
2248  const unsigned int dof_number,
2249  const unsigned int dofs_per_vertex) const
2250 {
2251  Assert((level >= coarsest_level) && (level <= finest_level),
2252  ExcInvalidLevel(level));
2253  return indices[dofs_per_vertex * (level - coarsest_level) + dof_number];
2254 }
2255 
2256 
2257 
2258 template <int dim, int spacedim>
2259 inline void
2261  const unsigned int level,
2262  const unsigned int dof_number,
2263  const unsigned int dofs_per_vertex,
2264  const types::global_dof_index index)
2265 {
2266  Assert((level >= coarsest_level) && (level <= finest_level),
2267  ExcInvalidLevel(level));
2268  indices[dofs_per_vertex * (level - coarsest_level) + dof_number] = index;
2269 }
2270 
2271 
2272 #endif // DOXYGEN
2273 
2275 
2276 #endif
std::vector< types::global_dof_index > get_n_locally_owned_dofs_per_processor(const MPI_Comm &mpi_communicator) const
Definition: number_cache.cc:87
std::vector< MGVertexDoFs > mg_vertex_dofs
Definition: dof_handler.h:1642
static const unsigned int invalid_unsigned_int
Definition: types.h:196
void reinit(MatrixBlock< MatrixType > &v, const BlockSparsityPattern &p)
Definition: matrix_block.h:618
typename ActiveSelector::FaceAccessor face_accessor
Definition: dof_handler.h:348
std::array< std::vector< offset_type >, dim+1 > hp_object_fe_ptr
Definition: dof_handler.h:1622
#define DeclException2(Exception2, type1, type2, outsequence)
Definition: exceptions.h:538
typename LevelSelector::face_iterator level_face_iterator
Definition: dof_handler.h:503
std::map< const cell_iterator, const unsigned int > coarsened_cells_fe_index
Definition: dof_handler.h:1511
typename ActiveSelector::quad_iterator quad_iterator
Definition: dof_handler.h:381
unsigned short int active_fe_index_type
Definition: dof_handler.h:529
::internal::DoFHandlerImplementation::NumberCache number_cache
Definition: dof_handler.h:1570
std::vector< std::array< std::vector< offset_type >, dim+1 > > object_dof_ptr
Definition: dof_handler.h:1609
typename ActiveSelector::CellAccessor cell_accessor
Definition: dof_handler.h:334
#define AssertThrow(cond, exc)
Definition: exceptions.h:1576
std::vector< std::unique_ptr<::internal::DoFHandlerImplementation::DoFLevel< dim > > > mg_levels
Definition: dof_handler.h:1649
void save(Archive &ar, const unsigned int version) const
std::vector< std::vector< active_fe_index_type > > hp_cell_future_fe_indices
Definition: dof_handler.h:1636
typename ActiveSelector::face_iterator face_iterator
Definition: dof_handler.h:484
typename ActiveSelector::active_face_iterator active_face_iterator
Definition: dof_handler.h:497
MPI_Comm get_communicator() const
const hp::FECollection< dim, spacedim > & get_fe_collection() const
const FiniteElement< dim, spacedim > & get_fe(const unsigned int index=0) const
std::vector< std::vector< types::global_dof_index > > cell_dof_cache_indices
Definition: dof_handler.h:1584
std::map< const cell_iterator, const unsigned int > refined_cells_fe_index
Definition: dof_handler.h:1505
BlockInfo block_info_object
Definition: dof_handler.h:1534
virtual MPI_Comm get_communicator() const override
Definition: tria_base.cc:139
static ::ExceptionBase & ExcMessage(std::string arg1)
std::map< const cell_iterator, const unsigned int > persisting_cells_fe_index
Definition: dof_handler.h:1499
#define DeclException1(Exception1, type1, outsequence)
Definition: exceptions.h:515
typename LevelSelector::CellAccessor level_cell_accessor
Definition: dof_handler.h:499
typename ActiveSelector::hex_iterator hex_iterator
Definition: dof_handler.h:405
std::vector<::internal::DoFHandlerImplementation::NumberCache > mg_number_cache
Definition: dof_handler.h:1576
bool has_active_dofs() const
#define Assert(cond, exc)
Definition: exceptions.h:1466
hp::FECollection< dim, spacedim > fe_collection
Definition: dof_handler.h:1553
std::vector< IndexSet > get_locally_owned_dofs_per_processor(const MPI_Comm &mpi_communicator) const
types::global_dof_index n_dofs() const
std::unique_ptr< ActiveFEIndexTransfer > active_fe_index_transfer
Definition: dof_handler.h:1661
std::vector< std::array< std::vector< types::global_dof_index >, dim+1 > > object_dof_indices
Definition: dof_handler.h:1598
#define DeclExceptionMsg(Exception, defaulttext)
Definition: exceptions.h:493
std::unique_ptr<::internal::DoFHandlerImplementation::DoFFaces< dim > > mg_faces
Definition: dof_handler.h:1655
#define DeclException0(Exception0)
Definition: exceptions.h:470
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:394
unsigned int level
Definition: grid_out.cc:4578
SmartPointer< const Triangulation< dim, spacedim >, DoFHandler< dim, spacedim > > tria
Definition: dof_handler.h:1546
VectorType::value_type * end(VectorType &V)
typename LevelSelector::cell_iterator level_cell_iterator
Definition: dof_handler.h:502
void load(Archive &ar, const unsigned int version)
std::unique_ptr<::internal::DoFHandlerImplementation::Policy::PolicyBase< dim, spacedim > > policy
Definition: dof_handler.h:1561
void set_index(const unsigned int level, const unsigned int dof_number, const unsigned int dofs_per_vertex, const types::global_dof_index index)
std::unique_ptr< parallel::distributed::CellDataTransfer< dim, spacedim, std::vector< unsigned int > > > cell_data_transfer
Definition: dof_handler.h:1528
Definition: hp.h:117
std::vector< std::vector< active_fe_index_type > > hp_cell_active_fe_indices
Definition: dof_handler.h:1629
unsigned int n_cells(const internal::TriangulationImplementation::NumberCache< 1 > &c)
Definition: tria.cc:12648
typename LevelSelector::FaceAccessor level_face_accessor
Definition: dof_handler.h:500
std::vector< unsigned int > active_fe_indices
Definition: dof_handler.h:1518
std::array< std::vector< active_fe_index_type >, dim+1 > hp_object_fe_indices
Definition: dof_handler.h:1617
const IndexSet & locally_owned_dofs() const
typename ActiveSelector::active_line_iterator active_line_iterator
Definition: dof_handler.h:372
std::unique_ptr< types::global_dof_index[]> indices
Definition: dof_handler.h:1484
std::string policy_to_string(const ::internal::DoFHandlerImplementation::Policy::PolicyBase< dim, spacedim > &policy)
Definition: dof_handler.cc:49
bool has_hp_capabilities() const
*braid_SplitCommworld & comm
typename ActiveSelector::line_iterator line_iterator
Definition: dof_handler.h:357
const Triangulation< dim, spacedim > & get_triangulation() const
unsigned int coarsest_level
Definition: dof_handler.h:1468
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:393
VectorType::value_type * begin(VectorType &V)
const std::vector< IndexSet > & locally_owned_dofs_per_processor() const
types::global_dof_index get_index(const unsigned int level, const unsigned int dof_number, const unsigned int dofs_per_vertex) const
types::global_dof_index n_boundary_dofs() const
void get_active_fe_indices(const DoFHandler< dim, spacedim > &dof_handler, std::vector< unsigned int > &active_fe_indices)
Definition: dof_tools.cc:1386
std::vector< IndexSet > locally_owned_dofs_per_processor
Definition: number_cache.h:180
A small class collecting the different BlockIndices involved in global, multilevel and local computat...
Definition: block_info.h:93
static ::ExceptionBase & ExcInvalidBoundaryIndicator()
TrilinosWrappers::types::int_type global_index(const Epetra_BlockMap &map, const ::types::global_dof_index i)
typename ActiveSelector::cell_iterator cell_iterator
Definition: dof_handler.h:466
const std::vector< types::global_dof_index > & n_locally_owned_dofs_per_processor() const
const IndexSet & locally_owned_mg_dofs(const unsigned int level) const
typename ActiveSelector::active_cell_iterator active_cell_iterator
Definition: dof_handler.h:438
std::vector< boost::signals2::connection > tria_listeners
Definition: dof_handler.h:1667
std::vector< boost::signals2::connection > tria_listeners_for_transfer
Definition: dof_handler.h:1674
bool has_level_dofs() const
#define DEAL_II_DEPRECATED
Definition: config.h:156
const BlockInfo & block_info() const
static ::ExceptionBase & ExcNoFESelected()
bool hp_capability_enabled
Definition: dof_handler.h:1540
const std::vector< IndexSet > & locally_owned_mg_dofs_per_processor(const unsigned int level) const
typename ActiveSelector::active_quad_iterator active_quad_iterator
Definition: dof_handler.h:396
types::global_dof_index n_locally_owned_dofs() const
std::vector< std::vector< offset_type > > cell_dof_cache_ptr
Definition: dof_handler.h:1590
std::enable_if< std::is_fundamental< T >::value, std::size_t >::type memory_consumption(const T &t)
typename ActiveSelector::active_hex_iterator active_hex_iterator
Definition: dof_handler.h:416