Reference documentation for deal.II version Git cb0bd54b52 2019-09-21 16:31:22 -0400
\(\newcommand{\dealcoloneq}{\mathrel{\vcenter{:}}=}\)
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 
784  n_boundary_dofs() const;
785 
796  template <typename number>
798  n_boundary_dofs(
799  const std::map<types::boundary_id, const Function<spacedim, number> *>
800  &boundary_ids) const;
801 
807  n_boundary_dofs(const std::set<types::boundary_id> &boundary_ids) const;
808 
827  n_locally_owned_dofs() const;
828 
834  const IndexSet &
835  locally_owned_dofs() const;
836 
854  std::vector<IndexSet>
855  compute_locally_owned_dofs_per_processor() const;
856 
877  std::vector<types::global_dof_index>
878  compute_n_locally_owned_dofs_per_processor() const;
879 
892  DEAL_II_DEPRECATED const std::vector<IndexSet> &
893  locally_owned_dofs_per_processor() const;
894 
910  DEAL_II_DEPRECATED const std::vector<types::global_dof_index> &
911  n_locally_owned_dofs_per_processor() const;
912 
919  const IndexSet &
920  locally_owned_mg_dofs(const unsigned int level) const;
921 
937  std::vector<IndexSet>
938  compute_locally_owned_mg_dofs_per_processor(const unsigned int level) const;
939 
953  DEAL_II_DEPRECATED const std::vector<IndexSet> &
954  locally_owned_mg_dofs_per_processor(const unsigned int level) const;
955 
962  DEAL_II_DEPRECATED
964  get_fe() const;
965 
971  get_fe(const unsigned int index) const;
972 
978  get_fe_collection() const;
979 
985  get_triangulation() const;
986 
995  virtual std::size_t
996  memory_consumption() const;
997 
1014  void
1015  prepare_for_serialization_of_active_fe_indices();
1016 
1032  void
1033  deserialize_active_fe_indices();
1034 
1039  template <class Archive>
1040  void
1041  save(Archive &ar, const unsigned int version) const;
1042 
1047  template <class Archive>
1048  void
1049  load(Archive &ar, const unsigned int version);
1050 
1051  BOOST_SERIALIZATION_SPLIT_MEMBER()
1052 
1053 
1060  DeclException0(ExcGridsDoNotMatch);
1068  DeclException1(ExcMatrixHasWrongSize,
1069  int,
1070  << "The matrix has the wrong dimension " << arg1);
1074  DeclException0(ExcFunctionNotUseful);
1078  DeclException1(ExcNewNumbersNotConsecutive,
1079  types::global_dof_index,
1080  << "The given list of new dof indices is not consecutive: "
1081  << "the index " << arg1 << " does not exist.");
1085  DeclException2(ExcInvalidFEIndex,
1086  int,
1087  int,
1088  << "The mesh contains a cell with an active_fe_index of "
1089  << arg1 << ", but the finite element collection only has "
1090  << arg2 << " elements");
1094  DeclException1(ExcInvalidLevel,
1095  int,
1096  << "The given level " << arg1
1097  << " is not in the valid range!");
1105  DeclException1(ExcEmptyLevel,
1106  int,
1107  << "You tried to do something on level " << arg1
1108  << ", but this level is empty.");
1109 
1110  private:
1114  SmartPointer<const Triangulation<dim, spacedim>, DoFHandler<dim, spacedim>>
1115  tria;
1116 
1120  hp::FECollection<dim, spacedim> fe_collection;
1121 
1126  std::unique_ptr<::internal::DoFHandlerImplementation::Policy::
1127  PolicyBase<dim, spacedim>>
1128  policy;
1129 
1130 
1134  void
1135  setup_policy_and_listeners();
1136 
1140  void
1141  clear_space();
1142 
1143  template <int structdim>
1144  types::global_dof_index
1145  get_dof_index(const unsigned int obj_level,
1146  const unsigned int obj_index,
1147  const unsigned int fe_index,
1148  const unsigned int local_index) const;
1149 
1150  template <int structdim>
1151  void
1152  set_dof_index(const unsigned int obj_level,
1153  const unsigned int obj_index,
1154  const unsigned int fe_index,
1155  const unsigned int local_index,
1156  const types::global_dof_index global_index) const;
1157 
1165  void
1166  create_active_fe_table();
1167 
1176  void
1177  pre_refinement_action();
1178 
1186  void
1187  post_refinement_action();
1188 
1198  void
1199  pre_active_fe_index_transfer();
1200 
1209  void
1210  pre_distributed_active_fe_index_transfer();
1211 
1220  void
1221  post_active_fe_index_transfer();
1222 
1231  void
1232  post_distributed_active_fe_index_transfer();
1233 
1242  void
1243  post_distributed_serialization_of_active_fe_indices();
1244 
1249  std::vector<std::unique_ptr<::internal::hp::DoFLevel>> levels;
1250 
1255  std::unique_ptr<::internal::hp::DoFIndicesOnFaces<dim>> faces;
1256 
1264  ::internal::DoFHandlerImplementation::NumberCache number_cache;
1265 
1271  std::vector<::internal::DoFHandlerImplementation::NumberCache>
1272  mg_number_cache;
1273 
1286  std::vector<types::global_dof_index> vertex_dofs;
1287 
1300  std::vector<unsigned int> vertex_dof_offsets;
1301 
1309  {
1314  std::map<const cell_iterator, const unsigned int>
1316 
1321  std::map<const cell_iterator, const unsigned int> refined_cells_fe_index;
1322 
1327  std::map<const cell_iterator, const unsigned int>
1329 
1335  std::vector<unsigned int> active_fe_indices;
1336 
1342  std::unique_ptr<
1343  parallel::distributed::
1344  CellDataTransfer<dim, spacedim, std::vector<unsigned int>>>
1346  };
1347 
1352  std::unique_ptr<ActiveFEIndexTransfer> active_fe_index_transfer;
1353 
1358  std::vector<boost::signals2::connection> tria_listeners;
1359 
1360  // Make accessor objects friends.
1361  template <int, class, bool>
1362  friend class ::DoFAccessor;
1363  template <class, bool>
1364  friend class ::DoFCellAccessor;
1365  friend struct ::internal::DoFAccessorImplementation::Implementation;
1366  friend struct ::internal::DoFCellAccessorImplementation::
1367  Implementation;
1368 
1369  // Likewise for DoFLevel objects since they need to access the vertex dofs
1370  // in the functions that set and retrieve vertex dof indices.
1371  template <int>
1372  friend class ::internal::hp::DoFIndicesOnFacesOrEdges;
1373  friend struct ::internal::hp::DoFHandlerImplementation::
1374  Implementation;
1375  friend struct ::internal::DoFHandlerImplementation::Policy::
1376  Implementation;
1377  };
1378 
1379 
1380 
1381 #ifndef DOXYGEN
1382 
1383 
1384  /* ----------------------- Inline functions ----------------------------------
1385  */
1386 
1387 
1388  template <int dim, int spacedim>
1389  template <typename number>
1392  const std::map<types::boundary_id, const Function<spacedim, number> *>
1393  &boundary_ids) const
1394  {
1395  // extract the set of boundary ids and forget about the function object
1396  // pointers
1397  std::set<types::boundary_id> boundary_ids_only;
1398  for (typename std::map<types::boundary_id,
1399  const Function<spacedim, number> *>::const_iterator
1400  p = boundary_ids.begin();
1401  p != boundary_ids.end();
1402  ++p)
1403  boundary_ids_only.insert(p->first);
1404 
1405  // then just hand everything over to the other function that does the work
1406  return n_boundary_dofs(boundary_ids_only);
1407  }
1408 }
1409 
1410 
1411 namespace internal
1412 {
1420  template <int dim, int spacedim>
1421  std::string
1422  policy_to_string(const ::internal::DoFHandlerImplementation::Policy::
1423  PolicyBase<dim, spacedim> &policy);
1424 } // namespace internal
1425 
1426 
1427 namespace hp
1428 {
1429  template <int dim, int spacedim>
1430  template <class Archive>
1431  void
1432  DoFHandler<dim, spacedim>::save(Archive &ar, unsigned int) const
1433  {
1434  ar &vertex_dofs;
1435  ar &vertex_dof_offsets;
1436  ar &number_cache;
1437  ar &mg_number_cache;
1438 
1439  // some versions of gcc have trouble with loading vectors of
1440  // std::unique_ptr objects because std::unique_ptr does not
1441  // have a copy constructor. do it one level at a time
1442  const unsigned int n_levels = levels.size();
1443  ar & n_levels;
1444  for (unsigned int i = 0; i < n_levels; ++i)
1445  ar &levels[i];
1446 
1447  // boost dereferences a nullptr when serializing a nullptr
1448  // at least up to 1.65.1. This causes problems with clang-5.
1449  // Therefore, work around it.
1450  bool faces_is_nullptr = (faces.get() == nullptr);
1451  ar & faces_is_nullptr;
1452  if (!faces_is_nullptr)
1453  ar &faces;
1454 
1455  // write out the number of triangulation cells and later check during
1456  // loading that this number is indeed correct; same with something that
1457  // identifies the policy
1458  const unsigned int n_cells = tria->n_cells();
1459  std::string policy_name = ::internal::policy_to_string(*policy);
1460 
1461  ar &n_cells &policy_name;
1462  }
1463 
1464 
1465 
1466  template <int dim, int spacedim>
1467  template <class Archive>
1468  void
1469  DoFHandler<dim, spacedim>::load(Archive &ar, unsigned int)
1470  {
1471  ar &vertex_dofs;
1472  ar &vertex_dof_offsets;
1473  ar &number_cache;
1474  ar &mg_number_cache;
1475 
1476  // boost::serialization can restore pointers just fine, but if the
1477  // pointer object still points to something useful, that object is not
1478  // destroyed and we end up with a memory leak. consequently, first delete
1479  // previous content before re-loading stuff
1480  levels.clear();
1481  faces.reset();
1482 
1483  // some versions of gcc have trouble with loading vectors of
1484  // std::unique_ptr objects because std::unique_ptr does not
1485  // have a copy constructor. do it one level at a time
1486  unsigned int size;
1487  ar & size;
1488  levels.resize(size);
1489  for (unsigned int i = 0; i < size; ++i)
1490  {
1491  std::unique_ptr<::internal::hp::DoFLevel> level;
1492  ar & level;
1493  levels[i] = std::move(level);
1494  }
1495 
1496  // Workaround for nullptr, see in save().
1497  bool faces_is_nullptr = true;
1498  ar & faces_is_nullptr;
1499  if (!faces_is_nullptr)
1500  ar &faces;
1501 
1502  // these are the checks that correspond to the last block in the save()
1503  // function
1504  unsigned int n_cells;
1505  std::string policy_name;
1506 
1507  ar &n_cells &policy_name;
1508 
1509  AssertThrow(
1510  n_cells == tria->n_cells(),
1511  ExcMessage(
1512  "The object being loaded into does not match the triangulation "
1513  "that has been stored previously."));
1514  AssertThrow(policy_name == ::internal::policy_to_string(*policy),
1515  ExcMessage(
1516  "The policy currently associated with this DoFHandler (" +
1517  ::internal::policy_to_string(*policy) +
1518  ") does not match the one that was associated with the "
1519  "DoFHandler previously stored (" +
1520  policy_name + ")."));
1521  }
1522 
1523  template <int dim, int spacedim>
1526  {
1527  return number_cache.n_global_dofs;
1528  }
1529 
1530 
1531 
1532  template <int dim, int spacedim>
1534  DoFHandler<dim, spacedim>::n_dofs(const unsigned int) const
1535  {
1536  Assert(false, ExcNotImplemented());
1538  }
1539 
1540 
1541 
1542  template <int dim, int spacedim>
1545  {
1546  return number_cache.n_locally_owned_dofs;
1547  }
1548 
1549 
1550 
1551  template <int dim, int spacedim>
1552  const IndexSet &
1554  {
1555  return number_cache.locally_owned_dofs;
1556  }
1557 
1558 
1559 
1560  template <int dim, int spacedim>
1561  const std::vector<types::global_dof_index> &
1563  {
1564  if (number_cache.n_locally_owned_dofs_per_processor.empty() &&
1565  number_cache.n_global_dofs > 0)
1566  {
1568  number_cache)
1569  .n_locally_owned_dofs_per_processor =
1570  compute_n_locally_owned_dofs_per_processor();
1571  }
1572  return number_cache.n_locally_owned_dofs_per_processor;
1573  }
1574 
1575 
1576 
1577  template <int dim, int spacedim>
1578  const std::vector<IndexSet> &
1580  {
1581  if (number_cache.locally_owned_dofs_per_processor.empty() &&
1582  number_cache.n_global_dofs > 0)
1583  {
1585  number_cache)
1586  .locally_owned_dofs_per_processor =
1587  compute_locally_owned_dofs_per_processor();
1588  }
1589  return number_cache.locally_owned_dofs_per_processor;
1590  }
1591 
1592 
1593 
1594  template <int dim, int spacedim>
1595  std::vector<types::global_dof_index>
1597  {
1599  (dynamic_cast<const parallel::TriangulationBase<dim, spacedim> *>(
1600  &this->get_triangulation()));
1601  if (tr != nullptr)
1602  return number_cache.get_n_locally_owned_dofs_per_processor(
1603  tr->get_communicator());
1604  else
1605  return number_cache.get_n_locally_owned_dofs_per_processor(MPI_COMM_SELF);
1606  }
1607 
1608 
1609 
1610  template <int dim, int spacedim>
1611  std::vector<IndexSet>
1613  {
1615  (dynamic_cast<const parallel::TriangulationBase<dim, spacedim> *>(
1616  &this->get_triangulation()));
1617  if (tr != nullptr)
1618  return number_cache.get_locally_owned_dofs_per_processor(
1619  tr->get_communicator());
1620  else
1621  return number_cache.get_locally_owned_dofs_per_processor(MPI_COMM_SELF);
1622  }
1623 
1624 
1625 
1626  template <int dim, int spacedim>
1627  const IndexSet &
1629  const unsigned int level) const
1630  {
1631  Assert(false, ExcNotImplemented());
1632  (void)level;
1633  Assert(level < this->get_triangulation().n_global_levels(),
1634  ExcMessage("The given level index exceeds the number of levels "
1635  "present in the triangulation"));
1636  return mg_number_cache[0].locally_owned_dofs;
1637  }
1638 
1639 
1640 
1641  template <int dim, int spacedim>
1642  const std::vector<IndexSet> &
1644  const unsigned int level) const
1645  {
1646  Assert(level < this->get_triangulation().n_global_levels(),
1647  ExcMessage("The given level index exceeds the number of levels "
1648  "present in the triangulation"));
1649  Assert(
1650  mg_number_cache.size() == this->get_triangulation().n_global_levels(),
1651  ExcMessage(
1652  "The level dofs are not set up properly! Did you call distribute_mg_dofs()?"));
1653  if (mg_number_cache[level].locally_owned_dofs_per_processor.empty() &&
1654  mg_number_cache[level].n_global_dofs > 0)
1655  {
1657  mg_number_cache[level])
1658  .locally_owned_dofs_per_processor =
1659  compute_locally_owned_mg_dofs_per_processor(level);
1660  }
1661  return mg_number_cache[level].locally_owned_dofs_per_processor;
1662  }
1663 
1664 
1665 
1666  template <int dim, int spacedim>
1667  std::vector<IndexSet>
1669  const unsigned int level) const
1670  {
1671  Assert(false, ExcNotImplemented());
1672  (void)level;
1673  Assert(level < this->get_triangulation().n_global_levels(),
1674  ExcMessage("The given level index exceeds the number of levels "
1675  "present in the triangulation"));
1677  (dynamic_cast<const parallel::TriangulationBase<dim, spacedim> *>(
1678  &this->get_triangulation()));
1679  if (tr != nullptr)
1680  return mg_number_cache[level].get_locally_owned_dofs_per_processor(
1681  tr->get_communicator());
1682  else
1683  return mg_number_cache[level].get_locally_owned_dofs_per_processor(
1684  MPI_COMM_SELF);
1685  }
1686 
1687 
1688 
1689  template <int dim, int spacedim>
1690  inline const hp::FECollection<dim, spacedim> &
1692  {
1693  Assert(fe_collection.size() > 0,
1694  ExcMessage("No finite element collection is associated with "
1695  "this DoFHandler"));
1696  return fe_collection;
1697  }
1698 
1699 
1700 
1701  template <int dim, int spacedim>
1702  inline const FiniteElement<dim, spacedim> &
1703  DoFHandler<dim, spacedim>::get_fe(const unsigned int number) const
1704  {
1705  Assert(fe_collection.size() > 0,
1706  ExcMessage("No finite element collection is associated with "
1707  "this DoFHandler"));
1708  return fe_collection[number];
1709  }
1710 
1711 
1712 
1713  template <int dim, int spacedim>
1714  inline const hp::FECollection<dim, spacedim> &
1716  {
1717  Assert(fe_collection.size() > 0,
1718  ExcMessage("No finite element collection is associated with "
1719  "this DoFHandler"));
1720  return fe_collection;
1721  }
1722 
1723 
1724 
1725  template <int dim, int spacedim>
1726  inline const Triangulation<dim, spacedim> &
1728  {
1729  Assert(tria != nullptr,
1730  ExcMessage("This DoFHandler object has not been associated "
1731  "with a triangulation."));
1732  return *tria;
1733  }
1734 
1735 #endif
1736 
1737 } // namespace hp
1738 
1739 DEAL_II_NAMESPACE_CLOSE
1740 
1741 #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:1335
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:1321
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:1328
STL namespace.
typename ActiveSelector::CellAccessor cell_accessor
Definition: dof_handler.h:223
#define AssertThrow(cond, exc)
Definition: exceptions.h:1519
std::unique_ptr< ActiveFEIndexTransfer > active_fe_index_transfer
Definition: dof_handler.h:1352
std::vector< boost::signals2::connection > tria_listeners
Definition: dof_handler.h:1358
std::unique_ptr< parallel::distributed::CellDataTransfer< dim, spacedim, std::vector< unsigned int > > > cell_data_transfer
Definition: dof_handler.h:1345
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:1407
#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
virtual MPI_Comm get_communicator() const
Definition: tria_base.cc:173
Definition: hp.h:117
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:1315
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