Reference documentation for deal.II version Git 2276b94619 2020-02-28 10:11:55 +0100
\(\newcommand{\vcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\vcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
dof_handler.h
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2005 - 2019 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_hp_dof_handler_h
17 #define dealii_hp_dof_handler_h
18 
19 
20 
21 #include <deal.II/base/config.h>
22 
23 #include <deal.II/base/exceptions.h>
24 #include <deal.II/base/function.h>
25 #include <deal.II/base/iterator_range.h>
26 #include <deal.II/base/smartpointer.h>
27 #include <deal.II/base/template_constraints.h>
28 
29 #include <deal.II/dofs/deprecated_function_map.h>
30 #include <deal.II/dofs/dof_accessor.h>
31 #include <deal.II/dofs/dof_iterator_selector.h>
32 #include <deal.II/dofs/number_cache.h>
33 
34 #include <deal.II/hp/dof_faces.h>
35 #include <deal.II/hp/dof_level.h>
36 #include <deal.II/hp/fe_collection.h>
37 
38 #include <map>
39 #include <memory>
40 #include <set>
41 #include <vector>
42 
43 DEAL_II_NAMESPACE_OPEN
44 
45 // Forward declarations
46 #ifndef DOXYGEN
47 template <int dim, int spacedim>
48 class Triangulation;
49 
50 namespace parallel
51 {
52  namespace distributed
53  {
54  template <int dim, int spacedim, typename VectorType>
55  class CellDataTransfer;
56  }
57 } // namespace parallel
58 
59 namespace internal
60 {
61  namespace DoFHandlerImplementation
62  {
63  struct Implementation;
64 
65  namespace Policy
66  {
67  template <int dim, int spacedim>
68  class PolicyBase;
69  struct Implementation;
70  } // namespace Policy
71  } // namespace DoFHandlerImplementation
72 
73  namespace hp
74  {
75  class DoFLevel;
76 
77  namespace DoFHandlerImplementation
78  {
79  struct Implementation;
80  }
81  } // namespace hp
82 } // namespace internal
83 
84 namespace internal
85 {
86  namespace DoFAccessorImplementation
87  {
88  struct Implementation;
89  }
90 
91  namespace DoFCellAccessorImplementation
92  {
93  struct Implementation;
94  }
95 } // namespace internal
96 #endif
97 
98 
99 namespace hp
100 {
202  template <int dim, int spacedim = dim>
203  class DoFHandler : public Subscriptor
204  {
205  using ActiveSelector = ::internal::DoFHandlerImplementation::
206  Iterators<DoFHandler<dim, spacedim>, false>;
207  using LevelSelector = ::internal::DoFHandlerImplementation::
208  Iterators<DoFHandler<dim, spacedim>, true>;
209 
210  public:
223  using cell_accessor = typename ActiveSelector::CellAccessor;
224 
237  using face_accessor = typename ActiveSelector::FaceAccessor;
238 
246  using line_iterator = typename ActiveSelector::line_iterator;
247 
261  using active_line_iterator = typename ActiveSelector::active_line_iterator;
262 
270  using quad_iterator = typename ActiveSelector::quad_iterator;
271 
285  using active_quad_iterator = typename ActiveSelector::active_quad_iterator;
286 
294  using hex_iterator = typename ActiveSelector::hex_iterator;
295 
305  using active_hex_iterator = typename ActiveSelector::active_hex_iterator;
306 
311 #ifndef _MSC_VER
312  using active_cell_iterator = typename ActiveSelector::active_cell_iterator;
313 #else
316 #endif
317 
318  using level_cell_iterator = typename LevelSelector::cell_iterator;
319 
324 #ifndef _MSC_VER
325  using cell_iterator = typename ActiveSelector::cell_iterator;
326 #else
327  using cell_iterator =
329 #endif
330 
335  using face_iterator = typename ActiveSelector::face_iterator;
336 
341  using active_face_iterator = typename ActiveSelector::active_face_iterator;
342 
343  using level_cell_accessor = typename LevelSelector::CellAccessor;
344  using level_face_accessor = typename LevelSelector::FaceAccessor;
345 
346  using level_face_iterator = typename LevelSelector::face_iterator;
347 
351  static const unsigned int dimension = dim;
352 
356  static const unsigned int space_dimension = spacedim;
357 
361  static const bool is_hp_dof_handler = true;
362 
374  DEAL_II_DEPRECATED
375  static const types::global_dof_index invalid_dof_index =
377 
388  static const unsigned int default_fe_index = numbers::invalid_unsigned_int;
389 
390 
394  DoFHandler();
395 
400 
407  DoFHandler(const DoFHandler &) = delete;
408 
412  virtual ~DoFHandler() override;
413 
420  DoFHandler &
421  operator=(const DoFHandler &) = delete;
422 
427  void
428  initialize(const Triangulation<dim, spacedim> & tria,
430 
447  virtual void
448  set_fe(const hp::FECollection<dim, spacedim> &fe);
449 
475  virtual void
476  distribute_dofs(const hp::FECollection<dim, spacedim> &fe);
477 
482  void
483  set_active_fe_indices(const std::vector<unsigned int> &active_fe_indices);
484 
490  void
491  get_active_fe_indices(std::vector<unsigned int> &active_fe_indices) const;
492 
498  virtual void
499  clear();
500 
553  void
554  renumber_dofs(const std::vector<types::global_dof_index> &new_numbers);
555 
573  unsigned int
574  max_couplings_between_dofs() const;
575 
588  unsigned int
589  max_couplings_between_boundary_dofs() const;
590 
599  begin(const unsigned int level = 0) const;
600 
618  begin_active(const unsigned int level = 0) const;
619 
625  end() const;
626 
632  end(const unsigned int level) const;
633 
640  end_active(const unsigned int level) const;
641 
657  cell_iterators() const;
658 
700  active_cell_iterators() const;
701 
718  cell_iterators_on_level(const unsigned int level) const;
719 
736  active_cell_iterators_on_level(const unsigned int level) const;
737 
738  /*
739  * @}
740  */
741 
742  /*---------------------------------------*/
743 
744 
770  n_dofs() const;
771 
778  n_dofs(const unsigned int level) const;
779 
785  n_boundary_dofs() const;
786 
797  template <typename number>
799  n_boundary_dofs(
800  const std::map<types::boundary_id, const Function<spacedim, number> *>
801  &boundary_ids) const;
802 
809  n_boundary_dofs(const std::set<types::boundary_id> &boundary_ids) const;
810 
829  n_locally_owned_dofs() const;
830 
836  const IndexSet &
837  locally_owned_dofs() const;
838 
856  std::vector<IndexSet>
857  compute_locally_owned_dofs_per_processor() const;
858 
879  std::vector<types::global_dof_index>
880  compute_n_locally_owned_dofs_per_processor() const;
881 
894  DEAL_II_DEPRECATED const std::vector<IndexSet> &
895  locally_owned_dofs_per_processor() const;
896 
912  DEAL_II_DEPRECATED const std::vector<types::global_dof_index> &
913  n_locally_owned_dofs_per_processor() const;
914 
921  const IndexSet &
922  locally_owned_mg_dofs(const unsigned int level) const;
923 
939  std::vector<IndexSet>
940  compute_locally_owned_mg_dofs_per_processor(const unsigned int level) const;
941 
955  DEAL_II_DEPRECATED const std::vector<IndexSet> &
956  locally_owned_mg_dofs_per_processor(const unsigned int level) const;
957 
964  DEAL_II_DEPRECATED
966  get_fe() const;
967 
973  get_fe(const unsigned int index) const;
974 
980  get_fe_collection() const;
981 
987  get_triangulation() const;
988 
997  virtual std::size_t
998  memory_consumption() const;
999 
1016  void
1017  prepare_for_serialization_of_active_fe_indices();
1018 
1034  void
1035  deserialize_active_fe_indices();
1036 
1041  template <class Archive>
1042  void
1043  save(Archive &ar, const unsigned int version) const;
1044 
1049  template <class Archive>
1050  void
1051  load(Archive &ar, const unsigned int version);
1052 
1053  BOOST_SERIALIZATION_SPLIT_MEMBER()
1054 
1055 
1062  DeclException0(ExcGridsDoNotMatch);
1070  DeclException1(ExcMatrixHasWrongSize,
1071  int,
1072  << "The matrix has the wrong dimension " << arg1);
1076  DeclException0(ExcFunctionNotUseful);
1080  DeclException1(ExcNewNumbersNotConsecutive,
1081  types::global_dof_index,
1082  << "The given list of new dof indices is not consecutive: "
1083  << "the index " << arg1 << " does not exist.");
1087  DeclException2(ExcInvalidFEIndex,
1088  int,
1089  int,
1090  << "The mesh contains a cell with an active_fe_index of "
1091  << arg1 << ", but the finite element collection only has "
1092  << arg2 << " elements");
1096  DeclException1(ExcInvalidLevel,
1097  int,
1098  << "The given level " << arg1
1099  << " is not in the valid range!");
1107  DeclException1(ExcEmptyLevel,
1108  int,
1109  << "You tried to do something on level " << arg1
1110  << ", but this level is empty.");
1111 
1112  private:
1116  SmartPointer<const Triangulation<dim, spacedim>, DoFHandler<dim, spacedim>>
1117  tria;
1118 
1122  hp::FECollection<dim, spacedim> fe_collection;
1123 
1128  std::unique_ptr<::internal::DoFHandlerImplementation::Policy::
1129  PolicyBase<dim, spacedim>>
1130  policy;
1131 
1132 
1136  void
1137  setup_policy_and_listeners();
1138 
1142  void
1143  clear_space();
1144 
1145  template <int structdim>
1146  types::global_dof_index
1147  get_dof_index(const unsigned int obj_level,
1148  const unsigned int obj_index,
1149  const unsigned int fe_index,
1150  const unsigned int local_index) const;
1151 
1152  template <int structdim>
1153  void
1154  set_dof_index(const unsigned int obj_level,
1155  const unsigned int obj_index,
1156  const unsigned int fe_index,
1157  const unsigned int local_index,
1158  const types::global_dof_index global_index) const;
1159 
1167  void
1168  create_active_fe_table();
1169 
1178  void
1179  pre_refinement_action();
1180 
1188  void
1189  post_refinement_action();
1190 
1200  void
1201  pre_active_fe_index_transfer();
1202 
1211  void
1212  pre_distributed_active_fe_index_transfer();
1213 
1222  void
1223  post_active_fe_index_transfer();
1224 
1233  void
1234  post_distributed_active_fe_index_transfer();
1235 
1244  void
1245  post_distributed_serialization_of_active_fe_indices();
1246 
1251  std::vector<std::unique_ptr<::internal::hp::DoFLevel>> levels;
1252 
1257  std::unique_ptr<::internal::hp::DoFIndicesOnFaces<dim>> faces;
1258 
1266  ::internal::DoFHandlerImplementation::NumberCache number_cache;
1267 
1273  std::vector<::internal::DoFHandlerImplementation::NumberCache>
1274  mg_number_cache;
1275 
1288  std::vector<types::global_dof_index> vertex_dofs;
1289 
1302  std::vector<unsigned int> vertex_dof_offsets;
1303 
1311  {
1316  std::map<const cell_iterator, const unsigned int>
1318 
1323  std::map<const cell_iterator, const unsigned int> refined_cells_fe_index;
1324 
1329  std::map<const cell_iterator, const unsigned int>
1331 
1337  std::vector<unsigned int> active_fe_indices;
1338 
1344  std::unique_ptr<
1345  parallel::distributed::
1346  CellDataTransfer<dim, spacedim, std::vector<unsigned int>>>
1348  };
1349 
1354  std::unique_ptr<ActiveFEIndexTransfer> active_fe_index_transfer;
1355 
1360  std::vector<boost::signals2::connection> tria_listeners;
1361 
1362  // Make accessor objects friends.
1363  template <int, class, bool>
1364  friend class ::DoFAccessor;
1365  template <class, bool>
1366  friend class ::DoFCellAccessor;
1367  friend struct ::internal::DoFAccessorImplementation::Implementation;
1368  friend struct ::internal::DoFCellAccessorImplementation::
1369  Implementation;
1370 
1371  // Likewise for DoFLevel objects since they need to access the vertex dofs
1372  // in the functions that set and retrieve vertex dof indices.
1373  template <int>
1374  friend class ::internal::hp::DoFIndicesOnFacesOrEdges;
1375  friend struct ::internal::hp::DoFHandlerImplementation::
1376  Implementation;
1377  friend struct ::internal::DoFHandlerImplementation::Policy::
1378  Implementation;
1379  };
1380 
1381 
1382 
1383 #ifndef DOXYGEN
1384 
1385 
1386  /* ----------------------- Inline functions ----------------------------------
1387  */
1388 
1389 
1390  template <int dim, int spacedim>
1391  template <typename number>
1394  const std::map<types::boundary_id, const Function<spacedim, number> *>
1395  &boundary_ids) const
1396  {
1397  // extract the set of boundary ids and forget about the function object
1398  // pointers
1399  std::set<types::boundary_id> boundary_ids_only;
1400  for (typename std::map<types::boundary_id,
1401  const Function<spacedim, number> *>::const_iterator
1402  p = boundary_ids.begin();
1403  p != boundary_ids.end();
1404  ++p)
1405  boundary_ids_only.insert(p->first);
1406 
1407  // then just hand everything over to the other function that does the work
1408  return n_boundary_dofs(boundary_ids_only);
1409  }
1410 
1411 
1412 
1413  template <>
1416  {
1417  Assert(false, ExcNotImplemented());
1418  return 0;
1419  }
1420 
1421 
1422 
1423  template <>
1424  template <typename number>
1427  const std::map<types::boundary_id, const Function<3, number> *> &) const
1428  {
1429  Assert(false, ExcNotImplemented());
1430  return 0;
1431  }
1432 
1433 
1434 
1435  template <>
1437  DoFHandler<2, 3>::n_boundary_dofs(const std::set<types::boundary_id> &) const
1438  {
1439  Assert(false, ExcNotImplemented());
1440  return 0;
1441  }
1442 }
1443 
1444 
1445 namespace internal
1446 {
1454  template <int dim, int spacedim>
1455  std::string
1456  policy_to_string(const ::internal::DoFHandlerImplementation::Policy::
1457  PolicyBase<dim, spacedim> &policy);
1458 } // namespace internal
1459 
1460 
1461 namespace hp
1462 {
1463  template <int dim, int spacedim>
1464  template <class Archive>
1465  void
1466  DoFHandler<dim, spacedim>::save(Archive &ar, unsigned int) const
1467  {
1468  ar &vertex_dofs;
1469  ar &vertex_dof_offsets;
1470  ar &number_cache;
1471  ar &mg_number_cache;
1472 
1473  // some versions of gcc have trouble with loading vectors of
1474  // std::unique_ptr objects because std::unique_ptr does not
1475  // have a copy constructor. do it one level at a time
1476  const unsigned int n_levels = levels.size();
1477  ar & n_levels;
1478  for (unsigned int i = 0; i < n_levels; ++i)
1479  ar &levels[i];
1480 
1481  // boost dereferences a nullptr when serializing a nullptr
1482  // at least up to 1.65.1. This causes problems with clang-5.
1483  // Therefore, work around it.
1484  bool faces_is_nullptr = (faces.get() == nullptr);
1485  ar & faces_is_nullptr;
1486  if (!faces_is_nullptr)
1487  ar &faces;
1488 
1489  // write out the number of triangulation cells and later check during
1490  // loading that this number is indeed correct; same with something that
1491  // identifies the policy
1492  const unsigned int n_cells = tria->n_cells();
1493  std::string policy_name = ::internal::policy_to_string(*policy);
1494 
1495  ar &n_cells &policy_name;
1496  }
1497 
1498 
1499 
1500  template <int dim, int spacedim>
1501  template <class Archive>
1502  void
1503  DoFHandler<dim, spacedim>::load(Archive &ar, unsigned int)
1504  {
1505  ar &vertex_dofs;
1506  ar &vertex_dof_offsets;
1507  ar &number_cache;
1508  ar &mg_number_cache;
1509 
1510  // boost::serialization can restore pointers just fine, but if the
1511  // pointer object still points to something useful, that object is not
1512  // destroyed and we end up with a memory leak. consequently, first delete
1513  // previous content before re-loading stuff
1514  levels.clear();
1515  faces.reset();
1516 
1517  // some versions of gcc have trouble with loading vectors of
1518  // std::unique_ptr objects because std::unique_ptr does not
1519  // have a copy constructor. do it one level at a time
1520  unsigned int size;
1521  ar & size;
1522  levels.resize(size);
1523  for (unsigned int i = 0; i < size; ++i)
1524  {
1525  std::unique_ptr<::internal::hp::DoFLevel> level;
1526  ar & level;
1527  levels[i] = std::move(level);
1528  }
1529 
1530  // Workaround for nullptr, see in save().
1531  bool faces_is_nullptr = true;
1532  ar & faces_is_nullptr;
1533  if (!faces_is_nullptr)
1534  ar &faces;
1535 
1536  // these are the checks that correspond to the last block in the save()
1537  // function
1538  unsigned int n_cells;
1539  std::string policy_name;
1540 
1541  ar &n_cells &policy_name;
1542 
1543  AssertThrow(
1544  n_cells == tria->n_cells(),
1545  ExcMessage(
1546  "The object being loaded into does not match the triangulation "
1547  "that has been stored previously."));
1548  AssertThrow(policy_name == ::internal::policy_to_string(*policy),
1549  ExcMessage(
1550  "The policy currently associated with this DoFHandler (" +
1551  ::internal::policy_to_string(*policy) +
1552  ") does not match the one that was associated with the "
1553  "DoFHandler previously stored (" +
1554  policy_name + ")."));
1555  }
1556 
1557  template <int dim, int spacedim>
1560  {
1561  return number_cache.n_global_dofs;
1562  }
1563 
1564 
1565 
1566  template <int dim, int spacedim>
1568  DoFHandler<dim, spacedim>::n_dofs(const unsigned int) const
1569  {
1570  Assert(false, ExcNotImplemented());
1572  }
1573 
1574 
1575 
1576  template <int dim, int spacedim>
1579  {
1580  return number_cache.n_locally_owned_dofs;
1581  }
1582 
1583 
1584 
1585  template <int dim, int spacedim>
1586  const IndexSet &
1588  {
1589  return number_cache.locally_owned_dofs;
1590  }
1591 
1592 
1593 
1594  template <int dim, int spacedim>
1595  const std::vector<types::global_dof_index> &
1597  {
1598  if (number_cache.n_locally_owned_dofs_per_processor.empty() &&
1599  number_cache.n_global_dofs > 0)
1600  {
1602  number_cache)
1603  .n_locally_owned_dofs_per_processor =
1604  compute_n_locally_owned_dofs_per_processor();
1605  }
1606  return number_cache.n_locally_owned_dofs_per_processor;
1607  }
1608 
1609 
1610 
1611  template <int dim, int spacedim>
1612  const std::vector<IndexSet> &
1614  {
1615  if (number_cache.locally_owned_dofs_per_processor.empty() &&
1616  number_cache.n_global_dofs > 0)
1617  {
1619  number_cache)
1620  .locally_owned_dofs_per_processor =
1621  compute_locally_owned_dofs_per_processor();
1622  }
1623  return number_cache.locally_owned_dofs_per_processor;
1624  }
1625 
1626 
1627 
1628  template <int dim, int spacedim>
1629  std::vector<types::global_dof_index>
1631  {
1633  (dynamic_cast<const parallel::TriangulationBase<dim, spacedim> *>(
1634  &this->get_triangulation()));
1635  if (tr != nullptr)
1636  return number_cache.get_n_locally_owned_dofs_per_processor(
1637  tr->get_communicator());
1638  else
1639  return number_cache.get_n_locally_owned_dofs_per_processor(MPI_COMM_SELF);
1640  }
1641 
1642 
1643 
1644  template <int dim, int spacedim>
1645  std::vector<IndexSet>
1647  {
1649  (dynamic_cast<const parallel::TriangulationBase<dim, spacedim> *>(
1650  &this->get_triangulation()));
1651  if (tr != nullptr)
1652  return number_cache.get_locally_owned_dofs_per_processor(
1653  tr->get_communicator());
1654  else
1655  return number_cache.get_locally_owned_dofs_per_processor(MPI_COMM_SELF);
1656  }
1657 
1658 
1659 
1660  template <int dim, int spacedim>
1661  const IndexSet &
1663  const unsigned int level) const
1664  {
1665  Assert(false, ExcNotImplemented());
1666  (void)level;
1667  Assert(level < this->get_triangulation().n_global_levels(),
1668  ExcMessage("The given level index exceeds the number of levels "
1669  "present in the triangulation"));
1670  return mg_number_cache[0].locally_owned_dofs;
1671  }
1672 
1673 
1674 
1675  template <int dim, int spacedim>
1676  const std::vector<IndexSet> &
1678  const unsigned int level) const
1679  {
1680  Assert(level < this->get_triangulation().n_global_levels(),
1681  ExcMessage("The given level index exceeds the number of levels "
1682  "present in the triangulation"));
1683  Assert(
1684  mg_number_cache.size() == this->get_triangulation().n_global_levels(),
1685  ExcMessage(
1686  "The level dofs are not set up properly! Did you call distribute_mg_dofs()?"));
1687  if (mg_number_cache[level].locally_owned_dofs_per_processor.empty() &&
1688  mg_number_cache[level].n_global_dofs > 0)
1689  {
1691  mg_number_cache[level])
1692  .locally_owned_dofs_per_processor =
1693  compute_locally_owned_mg_dofs_per_processor(level);
1694  }
1695  return mg_number_cache[level].locally_owned_dofs_per_processor;
1696  }
1697 
1698 
1699 
1700  template <int dim, int spacedim>
1701  std::vector<IndexSet>
1703  const unsigned int level) const
1704  {
1705  Assert(false, ExcNotImplemented());
1706  (void)level;
1707  Assert(level < this->get_triangulation().n_global_levels(),
1708  ExcMessage("The given level index exceeds the number of levels "
1709  "present in the triangulation"));
1711  (dynamic_cast<const parallel::TriangulationBase<dim, spacedim> *>(
1712  &this->get_triangulation()));
1713  if (tr != nullptr)
1714  return mg_number_cache[level].get_locally_owned_dofs_per_processor(
1715  tr->get_communicator());
1716  else
1717  return mg_number_cache[level].get_locally_owned_dofs_per_processor(
1718  MPI_COMM_SELF);
1719  }
1720 
1721 
1722 
1723  template <int dim, int spacedim>
1724  inline const hp::FECollection<dim, spacedim> &
1726  {
1727  Assert(fe_collection.size() > 0,
1728  ExcMessage("No finite element collection is associated with "
1729  "this DoFHandler"));
1730  return fe_collection;
1731  }
1732 
1733 
1734 
1735  template <int dim, int spacedim>
1736  inline const FiniteElement<dim, spacedim> &
1737  DoFHandler<dim, spacedim>::get_fe(const unsigned int number) const
1738  {
1739  Assert(fe_collection.size() > 0,
1740  ExcMessage("No finite element collection is associated with "
1741  "this DoFHandler"));
1742  return fe_collection[number];
1743  }
1744 
1745 
1746 
1747  template <int dim, int spacedim>
1748  inline const hp::FECollection<dim, spacedim> &
1750  {
1751  Assert(fe_collection.size() > 0,
1752  ExcMessage("No finite element collection is associated with "
1753  "this DoFHandler"));
1754  return fe_collection;
1755  }
1756 
1757 
1758 
1759  template <int dim, int spacedim>
1760  inline const Triangulation<dim, spacedim> &
1762  {
1763  Assert(tria != nullptr,
1764  ExcMessage("This DoFHandler object has not been associated "
1765  "with a triangulation."));
1766  return *tria;
1767  }
1768 
1769 #endif
1770 
1771 } // namespace hp
1772 
1773 DEAL_II_NAMESPACE_CLOSE
1774 
1775 #endif
const Triangulation< dim, spacedim > & get_triangulation() const
static const unsigned int invalid_unsigned_int
Definition: types.h:187
typename ActiveSelector::face_iterator face_iterator
Definition: dof_handler.h:335
#define DeclException2(Exception2, type1, type2, outsequence)
Definition: exceptions.h:541
std::vector< unsigned int > active_fe_indices
Definition: dof_handler.h:1337
std::vector< IndexSet > compute_locally_owned_mg_dofs_per_processor(const unsigned int level) const
std::map< const cell_iterator, const unsigned int > refined_cells_fe_index
Definition: dof_handler.h:1323
const std::vector< IndexSet > & locally_owned_mg_dofs_per_processor(const unsigned int level) const
std::map< const cell_iterator, const unsigned int > coarsened_cells_fe_index
Definition: dof_handler.h:1330
STL namespace.
typename ActiveSelector::CellAccessor cell_accessor
Definition: dof_handler.h:223
#define AssertThrow(cond, exc)
Definition: exceptions.h:1523
std::unique_ptr< ActiveFEIndexTransfer > active_fe_index_transfer
Definition: dof_handler.h:1354
std::vector< boost::signals2::connection > tria_listeners
Definition: dof_handler.h:1360
std::unique_ptr< parallel::distributed::CellDataTransfer< dim, spacedim, std::vector< unsigned int > > > cell_data_transfer
Definition: dof_handler.h:1347
static ::ExceptionBase & ExcFacesHaveNoLevel()
const FiniteElement< dim, spacedim > & get_fe(const unsigned int index=0) const
typename ActiveSelector::active_cell_iterator active_cell_iterator
Definition: dof_handler.h:312
unsigned int n_locally_owned_dofs() const
const std::vector< types::global_dof_index > & n_locally_owned_dofs_per_processor() const
static ::ExceptionBase & ExcMessage(std::string arg1)
typename ActiveSelector::active_quad_iterator active_quad_iterator
Definition: dof_handler.h:285
typename ActiveSelector::quad_iterator quad_iterator
Definition: dof_handler.h:270
typename ActiveSelector::cell_iterator cell_iterator
Definition: dof_handler.h:325
#define DeclException1(Exception1, type1, outsequence)
Definition: exceptions.h:518
Definition: types.h:31
std::vector< types::global_dof_index > compute_n_locally_owned_dofs_per_processor() const
typename ActiveSelector::active_line_iterator active_line_iterator
Definition: dof_handler.h:261
#define Assert(cond, exc)
Definition: exceptions.h:1411
#define DeclException0(Exception0)
Definition: exceptions.h:473
types::global_dof_index n_boundary_dofs() const
std::vector< types::global_dof_index > n_locally_owned_dofs_per_processor
Definition: number_cache.h:169
types::global_dof_index n_dofs() const
const hp::FECollection< dim, spacedim > & get_fe_collection() const
const IndexSet & locally_owned_mg_dofs(const unsigned int level) const
Definition: hp.h:117
virtual const MPI_Comm & get_communicator() const
Definition: tria_base.cc:171
unsigned int global_dof_index
Definition: types.h:89
const std::vector< IndexSet > & locally_owned_dofs_per_processor() const
typename ActiveSelector::active_face_iterator active_face_iterator
Definition: dof_handler.h:341
void load(Archive &ar, const unsigned int version)
std::vector< IndexSet > locally_owned_dofs_per_processor
Definition: number_cache.h:180
static ::ExceptionBase & ExcInvalidBoundaryIndicator()
static ::ExceptionBase & ExcNotImplemented()
std::map< const cell_iterator, const unsigned int > persisting_cells_fe_index
Definition: dof_handler.h:1317
const types::global_dof_index invalid_dof_index
Definition: types.h:202
std::vector< IndexSet > compute_locally_owned_dofs_per_processor() const
const IndexSet & locally_owned_dofs() const
unsigned int boundary_id
Definition: types.h:125
static ::ExceptionBase & ExcNoFESelected()
typename ActiveSelector::FaceAccessor face_accessor
Definition: dof_handler.h:237
void save(Archive &ar, const unsigned int version) const
typename ActiveSelector::active_hex_iterator active_hex_iterator
Definition: dof_handler.h:305
typename ActiveSelector::line_iterator line_iterator
Definition: dof_handler.h:246
typename ActiveSelector::hex_iterator hex_iterator
Definition: dof_handler.h:294