Reference documentation for deal.II version GIT ca9e7e8105 2023-03-24 14:15:03+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\}}\)
tria.h
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 1998 - 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_tria_h
17 #define dealii_tria_h
18 
19 
20 #include <deal.II/base/config.h>
21 
25 #include <deal.II/base/point.h>
28 
29 #include <deal.II/grid/cell_id.h>
33 
34 #include <boost/serialization/map.hpp>
35 #include <boost/serialization/split_member.hpp>
36 #include <boost/serialization/unique_ptr.hpp>
37 #include <boost/serialization/vector.hpp>
38 #include <boost/signals2.hpp>
39 
40 #include <bitset>
41 #include <functional>
42 #include <list>
43 #include <map>
44 #include <memory>
45 #include <numeric>
46 #include <vector>
47 
48 
50 
51 #ifdef signals
52 # error \
53  "The name 'signals' is already defined. You are most likely using the QT library \
54 and using the 'signals' keyword. You can either #include the Qt headers (or any conflicting headers) \
55 *after* the deal.II headers or you can define the 'QT_NO_KEYWORDS' macro and use the 'Q_SIGNALS' macro."
56 #endif
57 
58 // Forward declarations
59 #ifndef DOXYGEN
60 template <int dim, int spacedim>
61 class Manifold;
62 
63 template <int dim>
64 struct CellData;
65 
66 struct SubCellData;
67 
69 {
70  template <int, int>
71  struct Description;
72 }
73 
74 namespace GridTools
75 {
76  template <typename CellIterator>
77  struct PeriodicFacePair;
78 }
79 
80 template <int, int, int>
81 class TriaAccessor;
82 template <int spacedim>
83 class TriaAccessor<0, 1, spacedim>;
84 template <int, int, int>
85 class TriaAccessorBase;
86 
87 namespace internal
88 {
89  namespace TriangulationImplementation
90  {
91  class TriaFaces;
92 
93  class TriaObjects;
94 
95  template <int, int>
96  class Policy;
97 
103  struct Implementation;
104  struct ImplementationMixedMesh;
105  } // namespace TriangulationImplementation
106 
107  namespace TriaAccessorImplementation
108  {
109  struct Implementation;
110  }
111 } // namespace internal
112 #endif
113 
114 
115 /*------------------------------------------------------------------------*/
116 
117 
118 namespace internal
119 {
124  namespace TriangulationImplementation
125  {
137  template <int dim>
138  struct NumberCache
139  {};
140 
152  template <>
153  struct NumberCache<1>
154  {
158  unsigned int n_levels;
159 
163  unsigned int n_lines;
164 
168  std::vector<unsigned int> n_lines_level;
169 
173  unsigned int n_active_lines;
174 
178  std::vector<unsigned int> n_active_lines_level;
179 
183  std::shared_ptr<const Utilities::MPI::Partitioner>
185 
189  std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
191 
195  NumberCache();
196 
201  std::size_t
202  memory_consumption() const;
203 
209  template <class Archive>
210  void
211  serialize(Archive &ar, const unsigned int version);
212  };
213 
214 
227  template <>
228  struct NumberCache<2> : public NumberCache<1>
229  {
233  unsigned int n_quads;
234 
238  std::vector<unsigned int> n_quads_level;
239 
243  unsigned int n_active_quads;
244 
248  std::vector<unsigned int> n_active_quads_level;
249 
253  NumberCache();
254 
259  std::size_t
260  memory_consumption() const;
261 
267  template <class Archive>
268  void
269  serialize(Archive &ar, const unsigned int version);
270  };
271 
272 
286  template <>
287  struct NumberCache<3> : public NumberCache<2>
288  {
292  unsigned int n_hexes;
293 
297  std::vector<unsigned int> n_hexes_level;
298 
302  unsigned int n_active_hexes;
303 
307  std::vector<unsigned int> n_active_hexes_level;
308 
312  NumberCache();
313 
318  std::size_t
319  memory_consumption() const;
320 
326  template <class Archive>
327  void
328  serialize(Archive &ar, const unsigned int version);
329  };
330  } // namespace TriangulationImplementation
331 } // namespace internal
332 
333 
334 /*------------------------------------------------------------------------*/
335 
336 
1133 template <int dim, int spacedim = dim>
1134 DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
1136 {
1137 private:
1144 
1145 public:
1151  {
1156  none = 0x0,
1200  limit_level_difference_at_vertices = 0x1,
1221  eliminate_unrefined_islands = 0x2,
1237  patch_level_1 = 0x4,
1261  coarsest_level_1 = 0x8,
1286  allow_anisotropic_smoothing = 0x10,
1319  eliminate_refined_inner_islands = 0x100,
1324  eliminate_refined_boundary_islands = 0x200,
1330  do_not_produce_unrefined_islands = 0x400,
1331 
1336  smoothing_on_refinement =
1337  (limit_level_difference_at_vertices | eliminate_unrefined_islands),
1342  smoothing_on_coarsening =
1343  (eliminate_refined_inner_islands | eliminate_refined_boundary_islands |
1344  do_not_produce_unrefined_islands),
1345 
1351  maximum_smoothing = 0xffff ^ allow_anisotropic_smoothing
1352  };
1353 
1370 
1376 
1394 
1408  using face_iterator = TriaIterator<TriaAccessor<dim - 1, dim, spacedim>>;
1409 
1422  TriaActiveIterator<TriaAccessor<dim - 1, dim, spacedim>>;
1423 
1433 
1448 
1456  using line_iterator = typename IteratorSelector::line_iterator;
1457 
1471  using active_line_iterator = typename IteratorSelector::active_line_iterator;
1472 
1480  using quad_iterator = typename IteratorSelector::quad_iterator;
1481 
1495  using active_quad_iterator = typename IteratorSelector::active_quad_iterator;
1496 
1504  using hex_iterator = typename IteratorSelector::hex_iterator;
1505 
1515  using active_hex_iterator = typename IteratorSelector::active_hex_iterator;
1516 
1536  {
1543  virtual ~DistortedCellList() noexcept override;
1544 
1549  std::list<typename Triangulation<dim, spacedim>::cell_iterator>
1550  distorted_cells;
1551  };
1552 
1556  static constexpr unsigned int dimension = dim;
1557 
1561  static constexpr unsigned int space_dimension = spacedim;
1562 
1577  Triangulation(const MeshSmoothing smooth_grid = none,
1578  const bool check_for_distorted_cells = false);
1579 
1595  Triangulation(const Triangulation<dim, spacedim> &) = delete;
1596 
1603  Triangulation(Triangulation<dim, spacedim> &&tria) noexcept;
1604 
1608  Triangulation &
1609  operator=(Triangulation<dim, spacedim> &&tria) noexcept;
1610 
1614  virtual ~Triangulation() override;
1615 
1622  virtual void
1623  clear();
1624 
1629  virtual MPI_Comm
1630  get_communicator() const;
1631 
1637  virtual const std::weak_ptr<const Utilities::MPI::Partitioner>
1638  global_active_cell_index_partitioner() const;
1639 
1645  virtual const std::weak_ptr<const Utilities::MPI::Partitioner>
1646  global_level_cell_index_partitioner(const unsigned int level) const;
1647 
1653  virtual void
1654  set_mesh_smoothing(const MeshSmoothing mesh_smoothing);
1655 
1659  virtual const MeshSmoothing &
1660  get_mesh_smoothing() const;
1661 
1684  void
1685  set_manifold(const types::manifold_id number,
1686  const Manifold<dim, spacedim> &manifold_object);
1687 
1700  void
1701  reset_manifold(const types::manifold_id manifold_number);
1702 
1714  void
1715  reset_all_manifolds();
1716 
1725  void
1726  set_all_manifold_ids(const types::manifold_id number);
1727 
1736  void
1737  set_all_manifold_ids_on_boundary(const types::manifold_id number);
1738 
1748  void
1749  set_all_manifold_ids_on_boundary(const types::boundary_id b_id,
1750  const types::manifold_id number);
1751 
1763  const Manifold<dim, spacedim> &
1764  get_manifold(const types::manifold_id number) const;
1765 
1778  virtual std::vector<types::boundary_id>
1779  get_boundary_ids() const;
1780 
1793  virtual std::vector<types::manifold_id>
1794  get_manifold_ids() const;
1795 
1822  virtual void
1823  copy_triangulation(const Triangulation<dim, spacedim> &other_tria);
1824 
1872  virtual void
1873  create_triangulation(const std::vector<Point<spacedim>> &vertices,
1874  const std::vector<CellData<dim>> & cells,
1875  const SubCellData & subcelldata);
1876 
1889  virtual void
1891  const TriangulationDescription::Description<dim, spacedim>
1892  &construction_data);
1893 
1903  virtual void
1904  create_triangulation_compatibility(
1905  const std::vector<Point<spacedim>> &vertices,
1906  const std::vector<CellData<dim>> & cells,
1907  const SubCellData & subcelldata);
1908 
1915  void
1916  flip_all_direction_flags();
1917 
1929  void
1930  set_all_refine_flags();
1931 
1954  void
1955  refine_global(const unsigned int times = 1);
1956 
1969  void
1970  coarsen_global(const unsigned int times = 1);
1971 
2003  virtual void
2004  execute_coarsening_and_refinement();
2005 
2035  virtual bool
2036  prepare_coarsening_and_refinement();
2037 
2038  /*
2039  * @}
2040  */
2041 
2056  {
2073  CELL_INVALID
2074  };
2075 
2081  template <typename T>
2083  {
2084  using result_type = T;
2085 
2086  template <typename InputIterator>
2087  T
2088  operator()(InputIterator first, InputIterator last) const
2089  {
2090  return std::accumulate(first, last, T());
2091  }
2092  };
2093 
2103  struct Signals
2104  {
2112  boost::signals2::signal<void()> create;
2113 
2121  boost::signals2::signal<void()> pre_refinement;
2122 
2128  boost::signals2::signal<void()> post_refinement;
2129 
2136  boost::signals2::signal<void()> pre_partition;
2137 
2145  boost::signals2::signal<void()> mesh_movement;
2146 
2154  boost::signals2::signal<void(
2155  const typename Triangulation<dim, spacedim>::cell_iterator &cell)>
2157 
2164  boost::signals2::signal<void(
2165  const typename Triangulation<dim, spacedim>::cell_iterator &cell)>
2167 
2174  boost::signals2::signal<void(
2175  const Triangulation<dim, spacedim> &destination_tria)>
2177 
2191  boost::signals2::signal<void()> clear;
2192 
2202  boost::signals2::signal<void()> any_change;
2203 
2239  boost::signals2::signal<unsigned int(const cell_iterator &,
2240  const CellStatus),
2243 
2250  : cell_weight(weight)
2251  {}
2252 
2257  {
2258  public:
2259  using signature_type = unsigned int(const cell_iterator &,
2260  const CellStatus);
2262 
2263  using slot_function_type = boost::function<signature_type>;
2264  using slot_type =
2265  boost::signals2::slot<signature_type, slot_function_type>;
2266 
2271  boost::signals2::signal<signature_type, combiner_type> &new_signal)
2272  : new_signal(new_signal)
2273  {}
2274 
2279  {
2280  base_weight.disconnect();
2281  }
2282 
2290  boost::signals2::connection
2292  const slot_type & slot,
2293  boost::signals2::connect_position position = boost::signals2::at_back)
2294  {
2295  if (base_weight.connected() == false)
2296  {
2297  base_weight = new_signal.connect(
2298  [](const cell_iterator &, const CellStatus) -> unsigned int {
2299  return 1000;
2300  });
2301  Assert(base_weight.connected() && new_signal.num_slots() == 1,
2302  ExcInternalError());
2303  }
2304 
2305  return new_signal.connect(slot, position);
2306  }
2307 
2313  std::size_t
2314  num_slots() const
2315  {
2316  return new_signal.num_slots() -
2317  static_cast<std::size_t>(base_weight.connected());
2318  }
2319 
2324  bool
2325  empty() const
2326  {
2327  if (num_slots() == 0)
2328  {
2329  Assert(new_signal.num_slots() == 0, ExcInternalError());
2330  return true;
2331  }
2332  return false;
2333  }
2334 
2341  template <typename S>
2342  DEAL_II_DEPRECATED void
2343  disconnect(const S &connection)
2344  {
2345  new_signal.disconnect(connection);
2346 
2347  if (num_slots() == 0)
2348  {
2349  Assert(base_weight.connected() && new_signal.num_slots() == 1,
2350  ExcInternalError());
2351  new_signal.disconnect(base_weight);
2352  }
2353  }
2354 
2359  unsigned int
2360  operator()(const cell_iterator &iterator, const CellStatus status)
2361  {
2362  return new_signal(iterator, status);
2363  }
2364 
2365  private:
2369  boost::signals2::connection base_weight;
2370 
2374  boost::signals2::signal<signature_type, combiner_type> &new_signal;
2375  };
2376 
2397 
2409  boost::signals2::signal<void()> pre_distributed_refinement;
2410 
2418  boost::signals2::signal<void()> post_p4est_refinement;
2419 
2428  boost::signals2::signal<void()> post_distributed_refinement;
2429 
2435  boost::signals2::signal<void()> pre_distributed_repartition;
2436 
2442  boost::signals2::signal<void()> post_distributed_repartition;
2443 
2450  boost::signals2::signal<void()> pre_distributed_save;
2451 
2457  boost::signals2::signal<void()> post_distributed_save;
2458 
2465  boost::signals2::signal<void()> pre_distributed_load;
2466 
2472  boost::signals2::signal<void()> post_distributed_load;
2473  };
2474 
2478  mutable Signals signals;
2479 
2480  /*
2481  * @}
2482  */
2483 
2493  void
2494  save_refine_flags(std::ostream &out) const;
2495 
2499  void
2500  save_refine_flags(std::vector<bool> &v) const;
2501 
2505  void
2506  load_refine_flags(std::istream &in);
2507 
2511  void
2512  load_refine_flags(const std::vector<bool> &v);
2513 
2517  void
2518  save_coarsen_flags(std::ostream &out) const;
2519 
2523  void
2524  save_coarsen_flags(std::vector<bool> &v) const;
2525 
2529  void
2530  load_coarsen_flags(std::istream &out);
2531 
2535  void
2536  load_coarsen_flags(const std::vector<bool> &v);
2537 
2542  bool
2544 
2545  /*
2546  * @}
2547  */
2548 
2558  void
2560 
2566  void
2567  save_user_flags(std::ostream &out) const;
2568 
2574  void
2575  save_user_flags(std::vector<bool> &v) const;
2576 
2581  void
2582  load_user_flags(std::istream &in);
2583 
2588  void
2589  load_user_flags(const std::vector<bool> &v);
2590 
2595  void
2597 
2602  void
2603  save_user_flags_line(std::ostream &out) const;
2604 
2610  void
2611  save_user_flags_line(std::vector<bool> &v) const;
2612 
2617  void
2618  load_user_flags_line(std::istream &in);
2619 
2624  void
2625  load_user_flags_line(const std::vector<bool> &v);
2626 
2631  void
2633 
2638  void
2639  save_user_flags_quad(std::ostream &out) const;
2640 
2646  void
2647  save_user_flags_quad(std::vector<bool> &v) const;
2648 
2653  void
2654  load_user_flags_quad(std::istream &in);
2655 
2660  void
2661  load_user_flags_quad(const std::vector<bool> &v);
2662 
2663 
2668  void
2670 
2675  void
2676  save_user_flags_hex(std::ostream &out) const;
2677 
2683  void
2684  save_user_flags_hex(std::vector<bool> &v) const;
2685 
2690  void
2691  load_user_flags_hex(std::istream &in);
2692 
2697  void
2698  load_user_flags_hex(const std::vector<bool> &v);
2699 
2705  void
2707 
2713  void
2714  save_user_indices(std::vector<unsigned int> &v) const;
2715 
2720  void
2721  load_user_indices(const std::vector<unsigned int> &v);
2722 
2728  void
2729  save_user_pointers(std::vector<void *> &v) const;
2730 
2735  void
2736  load_user_pointers(const std::vector<void *> &v);
2737 
2743  void
2744  save_user_indices_line(std::vector<unsigned int> &v) const;
2745 
2750  void
2751  load_user_indices_line(const std::vector<unsigned int> &v);
2752 
2758  void
2759  save_user_indices_quad(std::vector<unsigned int> &v) const;
2760 
2765  void
2766  load_user_indices_quad(const std::vector<unsigned int> &v);
2767 
2773  void
2774  save_user_indices_hex(std::vector<unsigned int> &v) const;
2775 
2780  void
2781  load_user_indices_hex(const std::vector<unsigned int> &v);
2787  void
2788  save_user_pointers_line(std::vector<void *> &v) const;
2789 
2794  void
2795  load_user_pointers_line(const std::vector<void *> &v);
2796 
2802  void
2803  save_user_pointers_quad(std::vector<void *> &v) const;
2804 
2809  void
2810  load_user_pointers_quad(const std::vector<void *> &v);
2811 
2817  void
2818  save_user_pointers_hex(std::vector<void *> &v) const;
2819 
2824  void
2825  load_user_pointers_hex(const std::vector<void *> &v);
2826 
2827  /*
2828  * @}
2829  */
2830 
2854  begin(const unsigned int level = 0) const;
2855 
2887  begin_active(const unsigned int level = 0) const;
2888 
2894  end() const;
2895 
2915  end(const unsigned int level) const;
2916 
2937  end_active(const unsigned int level) const;
2938 
2939 
2944  last() const;
2945 
2950  last_active() const;
2951 
2965  create_cell_iterator(const CellId &cell_id) const;
2966 
2983 
3021 
3038  cell_iterators_on_level(const unsigned int level) const;
3039 
3056  active_cell_iterators_on_level(const unsigned int level) const;
3057 
3058  /*
3059  * @}
3060  */
3061 
3062  /*-------------------------------------------------------------------------*/
3063 
3073  begin_face() const;
3074 
3080 
3086  end_face() const;
3087 
3108 
3109  /*
3110  * @}
3111  */
3112 
3113  /*-------------------------------------------------------------------------*/
3114 
3125  begin_vertex() const;
3126 
3134 
3141  end_vertex() const;
3142 
3143  /*
3144  * @}
3145  */
3146 
3164  unsigned int
3165  n_lines() const;
3166 
3170  unsigned int
3171  n_lines(const unsigned int level) const;
3172 
3176  unsigned int
3178 
3182  unsigned int
3183  n_active_lines(const unsigned int level) const;
3184 
3188  unsigned int
3189  n_quads() const;
3190 
3194  unsigned int
3195  n_quads(const unsigned int level) const;
3196 
3200  unsigned int
3202 
3206  unsigned int
3207  n_active_quads(const unsigned int level) const;
3208 
3212  unsigned int
3213  n_hexs() const;
3214 
3219  unsigned int
3220  n_hexs(const unsigned int level) const;
3221 
3225  unsigned int
3226  n_active_hexs() const;
3227 
3232  unsigned int
3233  n_active_hexs(const unsigned int level) const;
3234 
3239  unsigned int
3240  n_cells() const;
3241 
3246  unsigned int
3247  n_cells(const unsigned int level) const;
3248 
3253  unsigned int
3255 
3263  virtual types::global_cell_index
3265 
3266 
3271  unsigned int
3272  n_active_cells(const unsigned int level) const;
3273 
3278  virtual types::coarse_cell_id
3280 
3286  unsigned int
3287  n_faces() const;
3288 
3294  unsigned int
3296 
3314  unsigned int
3315  n_levels() const;
3316 
3323  virtual unsigned int
3325 
3335  virtual bool
3337 
3345  unsigned int
3346  n_vertices() const;
3347 
3356  const std::vector<Point<spacedim>> &
3357  get_vertices() const;
3358 
3363  unsigned int
3365 
3369  bool
3370  vertex_used(const unsigned int index) const;
3371 
3376  const std::vector<bool> &
3378 
3390  unsigned int
3392 
3399  virtual types::subdomain_id
3401 
3413 
3420 
3421 
3422  /*
3423  * @}
3424  */
3425 
3440  unsigned int
3441  n_raw_lines() const;
3442 
3452  unsigned int
3453  n_raw_lines(const unsigned int level) const;
3454 
3464  unsigned int
3465  n_raw_quads() const;
3466 
3476  unsigned int
3477  n_raw_quads(const unsigned int level) const;
3478 
3488  unsigned int
3489  n_raw_hexs(const unsigned int level) const;
3490 
3500  unsigned int
3501  n_raw_cells(const unsigned int level) const;
3502 
3514  unsigned int
3515  n_raw_faces() const;
3516 
3517  /*
3518  * @}
3519  */
3520 
3529  virtual std::size_t
3531 
3541  template <class Archive>
3542  void
3543  save(Archive &ar, const unsigned int version) const;
3544 
3562  template <class Archive>
3563  void
3564  load(Archive &ar, const unsigned int version);
3565 
3566 
3582  virtual void
3584  const std::vector<GridTools::PeriodicFacePair<cell_iterator>> &);
3585 
3589  const std::map<
3590  std::pair<cell_iterator, unsigned int>,
3591  std::pair<std::pair<cell_iterator, unsigned int>, std::bitset<3>>> &
3593 
3598  const std::vector<ReferenceCell> &
3600 
3605  bool
3607 
3612  bool
3614 
3620  bool
3621  is_mixed_mesh() const;
3622 
3623 #ifdef DOXYGEN
3629  template <class Archive>
3630  void
3631  serialize(Archive &archive, const unsigned int version);
3632 #else
3633  // This macro defines the serialize() method that is compatible with
3634  // the templated save() and load() method that have been implemented.
3635  BOOST_SERIALIZATION_SPLIT_MEMBER()
3636 #endif
3637 
3648  DeclException2(ExcInvalidLevel,
3649  int,
3650  int,
3651  << "You are requesting information from refinement level "
3652  << arg1
3653  << " of a triangulation, but this triangulation only has "
3654  << arg2 << " refinement levels. The given level " << arg1
3655  << " must be *less* than " << arg2 << '.');
3663  ExcTriangulationNotEmpty,
3664  int,
3665  int,
3666  << "You are trying to perform an operation on a triangulation "
3667  << "that is only allowed if the triangulation is currently empty. "
3668  << "However, it currently stores " << arg1 << " vertices and has "
3669  << "cells on " << arg2 << " levels.");
3675  DeclException0(ExcGridReadError);
3686  DeclException1(ExcEmptyLevel,
3687  int,
3688  << "You tried to do something on level " << arg1
3689  << ", but this level is empty.");
3695  DeclException0(ExcNonOrientableTriangulation);
3696 
3704  DeclException1(ExcBoundaryIdNotFound,
3706  << "The given boundary_id " << arg1
3707  << " is not defined in this Triangulation!");
3708 
3715  ExcInconsistentCoarseningFlags,
3716  "A cell is flagged for coarsening, but either not all of its siblings "
3717  "are active or flagged for coarsening as well. Please clean up all "
3718  "coarsen flags on your triangulation via "
3719  "Triangulation::prepare_coarsening_and_refinement() beforehand!");
3720 
3721  /*
3722  * @}
3723  */
3724 
3725 protected:
3731 
3736  std::vector<ReferenceCell> reference_cells;
3737 
3751  static void
3752  write_bool_vector(const unsigned int magic_number1,
3753  const std::vector<bool> &v,
3754  const unsigned int magic_number2,
3755  std::ostream & out);
3756 
3761  static void
3762  read_bool_vector(const unsigned int magic_number1,
3763  std::vector<bool> &v,
3764  const unsigned int magic_number2,
3765  std::istream & in);
3766 
3771  void
3773 
3777  virtual void
3779 
3780 
3781 private:
3786  std::unique_ptr<
3789 
3796  std::vector<GridTools::PeriodicFacePair<cell_iterator>>
3798 
3803  std::map<std::pair<cell_iterator, unsigned int>,
3804  std::pair<std::pair<cell_iterator, unsigned int>, std::bitset<3>>>
3806 
3822  TriaRawIterator<TriaAccessor<dim - 1, dim, spacedim>>;
3825  using raw_line_iterator = typename IteratorSelector::raw_line_iterator;
3826  using raw_quad_iterator = typename IteratorSelector::raw_quad_iterator;
3827  using raw_hex_iterator = typename IteratorSelector::raw_hex_iterator;
3828 
3834  begin_raw(const unsigned int level = 0) const;
3835 
3841  end_raw(const unsigned int level) const;
3842 
3843  /*
3844  * @}
3845  */
3846 
3859  begin_raw_line(const unsigned int level = 0) const;
3860 
3879  begin_line(const unsigned int level = 0) const;
3880 
3899  begin_active_line(const unsigned int level = 0) const;
3900 
3906  end_line() const;
3907 
3908  /*
3909  * @}
3910  */
3911 
3937  begin_raw_quad(const unsigned int level = 0) const;
3938 
3957  begin_quad(const unsigned int level = 0) const;
3958 
3977  begin_active_quad(const unsigned int level = 0) const;
3978 
3984  end_quad() const;
3985 
3986  /*
3987  * @}
3988  */
3989 
4014  begin_raw_hex(const unsigned int level = 0) const;
4015 
4033  hex_iterator
4034  begin_hex(const unsigned int level = 0) const;
4035 
4054  begin_active_hex(const unsigned int level = 0) const;
4055 
4060  hex_iterator
4061  end_hex() const;
4062 
4063  /*
4064  * @}
4065  */
4066 
4067 
4081  void
4083 
4087  void
4089 
4096  void
4098 
4102  void
4104 
4108  void
4110 
4126 
4133  void
4135 
4140  void
4142 
4156  virtual unsigned int
4159 
4160 
4173  virtual types::coarse_cell_id
4175  const unsigned int coarse_cell_index) const;
4176 
4181  std::vector<
4182  std::unique_ptr<::internal::TriangulationImplementation::TriaLevel>>
4184 
4190  std::unique_ptr<::internal::TriangulationImplementation::TriaFaces>
4192 
4193 
4197  std::vector<Point<spacedim>> vertices;
4198 
4202  std::vector<bool> vertices_used;
4203 
4208  std::map<types::manifold_id, std::unique_ptr<const Manifold<dim, spacedim>>>
4210 
4215 
4216 
4222 
4233 
4248  std::unique_ptr<std::map<unsigned int, types::boundary_id>>
4250 
4251 
4271  std::unique_ptr<std::map<unsigned int, types::manifold_id>>
4273 
4274  // make a couple of classes friends
4275  template <int, int, int>
4276  friend class TriaAccessorBase;
4277  template <int, int, int>
4278  friend class TriaAccessor;
4279  friend class TriaAccessor<0, 1, spacedim>;
4280 
4281  friend class CellAccessor<dim, spacedim>;
4282 
4283  friend struct ::internal::TriaAccessorImplementation::Implementation;
4284 
4285  friend struct ::internal::TriangulationImplementation::Implementation;
4286  friend struct ::internal::TriangulationImplementation::
4287  ImplementationMixedMesh;
4288 
4289  friend class ::internal::TriangulationImplementation::TriaObjects;
4290 
4291  // explicitly check for sensible template arguments, but not on windows
4292  // because MSVC creates bogus warnings during normal compilation
4293 #ifndef DEAL_II_MSVC
4294  static_assert(dim <= spacedim,
4295  "The dimension <dim> of a Triangulation must be less than or "
4296  "equal to the space dimension <spacedim> in which it lives.");
4297 #endif
4298 };
4299 
4300 
4301 #ifndef DOXYGEN
4302 
4303 
4304 
4305 namespace internal
4306 {
4307  namespace TriangulationImplementation
4308  {
4309  template <class Archive>
4310  void
4311  NumberCache<1>::serialize(Archive &ar, const unsigned int)
4312  {
4313  ar &n_levels;
4314  ar &n_lines &n_lines_level;
4315  ar &n_active_lines &n_active_lines_level;
4316  }
4317 
4318 
4319  template <class Archive>
4320  void
4321  NumberCache<2>::serialize(Archive &ar, const unsigned int version)
4322  {
4323  this->NumberCache<1>::serialize(ar, version);
4324 
4325  ar &n_quads &n_quads_level;
4326  ar &n_active_quads &n_active_quads_level;
4327  }
4328 
4329 
4330  template <class Archive>
4331  void
4332  NumberCache<3>::serialize(Archive &ar, const unsigned int version)
4333  {
4334  this->NumberCache<2>::serialize(ar, version);
4335 
4336  ar &n_hexes &n_hexes_level;
4337  ar &n_active_hexes &n_active_hexes_level;
4338  }
4339 
4340  } // namespace TriangulationImplementation
4341 } // namespace internal
4342 
4343 
4344 template <int dim, int spacedim>
4345 DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
4347  const unsigned int index) const
4348 {
4349  AssertIndexRange(index, vertices_used.size());
4350  return vertices_used[index];
4351 }
4352 
4353 
4354 
4355 template <int dim, int spacedim>
4356 DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
4357 inline unsigned int Triangulation<dim, spacedim>::n_levels() const
4358 {
4359  return number_cache.n_levels;
4360 }
4361 
4362 template <int dim, int spacedim>
4363 DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
4364 inline unsigned int Triangulation<dim, spacedim>::n_global_levels() const
4365 {
4366  return number_cache.n_levels;
4367 }
4368 
4369 
4370 template <int dim, int spacedim>
4371 DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
4372 inline unsigned int Triangulation<dim, spacedim>::n_vertices() const
4373 {
4374  return vertices.size();
4375 }
4376 
4377 
4378 
4379 template <int dim, int spacedim>
4380 DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
4381 inline const std::vector<Point<spacedim>>
4383 {
4384  return vertices;
4385 }
4386 
4387 
4388 template <int dim, int spacedim>
4389 DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
4390 template <class Archive>
4391 void Triangulation<dim, spacedim>::save(Archive &ar, const unsigned int) const
4392 {
4393  // as discussed in the documentation, do not store the signals as
4394  // well as boundary and manifold description but everything else
4395  ar &smooth_grid;
4396 
4397  unsigned int n_levels = levels.size();
4398  ar & n_levels;
4399  for (const auto &level : levels)
4400  ar &level;
4401 
4402  // boost dereferences a nullptr when serializing a nullptr
4403  // at least up to 1.65.1. This causes problems with clang-5.
4404  // Therefore, work around it.
4405  bool faces_is_nullptr = (faces.get() == nullptr);
4406  ar & faces_is_nullptr;
4407  if (!faces_is_nullptr)
4408  ar &faces;
4409 
4410  ar &vertices;
4411  ar &vertices_used;
4412 
4414  ar &number_cache;
4415 
4417 
4418  if (dim == 1)
4419  {
4422  }
4423 }
4424 
4425 
4426 
4427 template <int dim, int spacedim>
4428 DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
4429 template <class Archive>
4430 void Triangulation<dim, spacedim>::load(Archive &ar, const unsigned int)
4431 {
4432  // clear previous content. this also calls the respective signal
4433  clear();
4434 
4435  // as discussed in the documentation, do not store the signals as
4436  // well as boundary and manifold description but everything else
4437  ar &smooth_grid;
4438 
4439  unsigned int size;
4440  ar & size;
4441  levels.resize(size);
4442  for (auto &level_ : levels)
4443  {
4444  std::unique_ptr<internal::TriangulationImplementation::TriaLevel> level;
4445  ar & level;
4446  level_ = std::move(level);
4447  }
4448 
4449  // Workaround for nullptr, see in save().
4450  bool faces_is_nullptr = true;
4451  ar & faces_is_nullptr;
4452  if (!faces_is_nullptr)
4453  ar &faces;
4454 
4455  ar &vertices;
4456  ar &vertices_used;
4457 
4459  ar &number_cache;
4460 
4461  // the levels do not serialize the active_cell_indices because
4462  // they are easy enough to rebuild upon re-loading data. do
4463  // this here. don't forget to first resize the fields appropriately
4464  {
4465  for (auto &level : levels)
4466  {
4467  level->active_cell_indices.resize(level->refine_flags.size());
4468  level->global_active_cell_indices.resize(level->refine_flags.size());
4469  level->global_level_cell_indices.resize(level->refine_flags.size());
4470  }
4474  }
4475 
4476  reset_policy();
4477 
4478  bool my_check_for_distorted_cells;
4479  ar & my_check_for_distorted_cells;
4480 
4481  Assert(my_check_for_distorted_cells == check_for_distorted_cells,
4482  ExcMessage("The triangulation loaded into here must have the "
4483  "same setting with regard to reporting distorted "
4484  "cell as the one previously stored."));
4485 
4486  if (dim == 1)
4487  {
4490  }
4491 
4492  // trigger the create signal to indicate
4493  // that new content has been imported into
4494  // the triangulation
4495  signals.create();
4496 }
4497 
4498 
4499 
4500 template <int dim, int spacedim>
4501 DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
4502 inline unsigned int Triangulation<dim, spacedim>::
4505 {
4506  return coarse_cell_id;
4507 }
4508 
4509 
4510 
4511 template <int dim, int spacedim>
4512 DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
4513 inline types::coarse_cell_id
4515  const unsigned int coarse_cell_index) const
4516 {
4517  return coarse_cell_index;
4518 }
4519 
4520 
4521 
4522 /* -------------- declaration of explicit specializations ------------- */
4523 
4524 template <>
4525 unsigned int
4527 template <>
4528 unsigned int
4529 Triangulation<1, 1>::n_quads(const unsigned int level) const;
4530 template <>
4531 unsigned int
4532 Triangulation<1, 1>::n_raw_quads(const unsigned int level) const;
4533 template <>
4534 unsigned int
4535 Triangulation<2, 2>::n_raw_quads(const unsigned int level) const;
4536 template <>
4537 unsigned int
4538 Triangulation<3, 3>::n_raw_quads(const unsigned int level) const;
4539 template <>
4540 unsigned int
4542 template <>
4543 unsigned int
4544 Triangulation<1, 1>::n_active_quads(const unsigned int level) const;
4545 template <>
4546 unsigned int
4548 template <>
4549 unsigned int
4550 Triangulation<1, 1>::n_raw_hexs(const unsigned int level) const;
4551 template <>
4552 unsigned int
4553 Triangulation<3, 3>::n_raw_hexs(const unsigned int level) const;
4554 template <>
4555 unsigned int
4557 template <>
4558 unsigned int
4560 template <>
4561 unsigned int
4562 Triangulation<3, 3>::n_active_hexs(const unsigned int) const;
4563 template <>
4564 unsigned int
4565 Triangulation<3, 3>::n_hexs(const unsigned int level) const;
4566 
4567 template <>
4568 unsigned int
4570 
4571 
4572 // -------------------------------------------------------------------
4573 // -- Explicit specializations for codimension one grids
4574 
4575 
4576 template <>
4577 unsigned int
4579 template <>
4580 unsigned int
4581 Triangulation<1, 2>::n_quads(const unsigned int level) const;
4582 template <>
4583 unsigned int
4584 Triangulation<1, 2>::n_raw_quads(const unsigned int level) const;
4585 template <>
4586 unsigned int
4587 Triangulation<2, 3>::n_raw_quads(const unsigned int level) const;
4588 template <>
4589 unsigned int
4590 Triangulation<1, 2>::n_raw_hexs(const unsigned int level) const;
4591 template <>
4592 unsigned int
4593 Triangulation<1, 2>::n_active_quads(const unsigned int level) const;
4594 template <>
4595 unsigned int
4597 template <>
4598 unsigned int
4600 
4601 // -------------------------------------------------------------------
4602 // -- Explicit specializations for codimension two grids
4603 
4604 template <>
4605 unsigned int
4607 template <>
4608 unsigned int
4609 Triangulation<1, 3>::n_quads(const unsigned int level) const;
4610 template <>
4611 unsigned int
4612 Triangulation<1, 3>::n_raw_quads(const unsigned int level) const;
4613 template <>
4614 unsigned int
4615 Triangulation<2, 3>::n_raw_quads(const unsigned int level) const;
4616 template <>
4617 unsigned int
4618 Triangulation<1, 3>::n_raw_hexs(const unsigned int level) const;
4619 template <>
4620 unsigned int
4621 Triangulation<1, 3>::n_active_quads(const unsigned int level) const;
4622 template <>
4623 unsigned int
4625 template <>
4626 unsigned int
4628 
4629 template <>
4630 bool
4632 template <>
4633 bool
4635 template <>
4636 bool
4638 
4639 
4640 extern template class Triangulation<1, 1>;
4641 extern template class Triangulation<1, 2>;
4642 extern template class Triangulation<1, 3>;
4643 extern template class Triangulation<2, 2>;
4644 extern template class Triangulation<2, 3>;
4645 extern template class Triangulation<3, 3>;
4646 
4647 #endif // DOXYGEN
4648 
4650 
4651 // Include tria_accessor.h here, so that it is possible for an end
4652 // user to use the iterators of Triangulation<dim> directly without
4653 // the need to include tria_accessor.h separately. (Otherwise the
4654 // iterators are an 'opaque' or 'incomplete' type.)
4656 
4657 #endif
Definition: cell_id.h:72
Definition: point.h:110
unsigned int operator()(const cell_iterator &iterator, const CellStatus status)
Definition: tria.h:2360
boost::signals2::slot< signature_type, slot_function_type > slot_type
Definition: tria.h:2265
std::size_t num_slots() const
Definition: tria.h:2314
boost::function< signature_type > slot_function_type
Definition: tria.h:2263
boost::signals2::connection connect(const slot_type &slot, boost::signals2::connect_position position=boost::signals2::at_back)
Definition: tria.h:2291
boost::signals2::signal< signature_type, combiner_type > & new_signal
Definition: tria.h:2374
LegacySignal(boost::signals2::signal< signature_type, combiner_type > &new_signal)
Definition: tria.h:2270
unsigned int(const cell_iterator &, const CellStatus) signature_type
Definition: tria.h:2260
boost::signals2::connection base_weight
Definition: tria.h:2369
void disconnect(const S &connection)
Definition: tria.h:2343
unsigned int n_hexs(const unsigned int level) const
void save_user_flags_line(std::vector< bool > &v) const
virtual types::global_cell_index n_global_active_cells() const
const std::vector< bool > & get_used_vertices() const
quad_iterator begin_quad(const unsigned int level=0) const
typename IteratorSelector::raw_line_iterator raw_line_iterator
Definition: tria.h:3825
active_vertex_iterator begin_active_vertex() const
void load_user_indices_quad(const std::vector< unsigned int > &v)
unsigned int n_quads() const
void load_user_indices(const std::vector< unsigned int > &v)
std::vector< bool > vertices_used
Definition: tria.h:4202
virtual void clear()
bool anisotropic_refinement
Definition: tria.h:4214
active_quad_iterator begin_active_quad(const unsigned int level=0) const
bool get_anisotropic_refinement_flag() const
virtual types::coarse_cell_id n_global_coarse_cells() const
std::unique_ptr< std::map< unsigned int, types::manifold_id > > vertex_to_manifold_id_map_1d
Definition: tria.h:4272
void save_user_pointers_quad(std::vector< void * > &v) const
void save_user_flags_hex(std::ostream &out) const
void clear_user_flags_quad()
unsigned int n_faces() const
active_hex_iterator begin_active_hex(const unsigned int level=0) const
@ CELL_COARSEN
Definition: tria.h:2069
@ CELL_REFINE
Definition: tria.h:2065
@ CELL_PERSIST
Definition: tria.h:2061
static void read_bool_vector(const unsigned int magic_number1, std::vector< bool > &v, const unsigned int magic_number2, std::istream &in)
unsigned int n_active_lines(const unsigned int level) const
bool all_reference_cells_are_hyper_cube() const
void load_user_flags_line(std::istream &in)
void clear_user_data()
raw_hex_iterator begin_raw_hex(const unsigned int level=0) const
void save_user_flags_line(std::ostream &out) const
active_cell_iterator last_active() const
void save(Archive &ar, const unsigned int version) const
void reset_global_cell_indices()
face_iterator end_face() const
void reset_active_cell_indices()
cell_iterator create_cell_iterator(const CellId &cell_id) const
cell_iterator begin(const unsigned int level=0) const
std::map< std::pair< cell_iterator, unsigned int >, std::pair< std::pair< cell_iterator, unsigned int >, std::bitset< 3 > > > periodic_face_map
Definition: tria.h:3805
void fix_coarsen_flags()
unsigned int n_active_cells(const unsigned int level) const
unsigned int n_cells(const unsigned int level) const
void save_user_pointers_line(std::vector< void * > &v) const
void save_user_flags_quad(std::vector< bool > &v) const
void load_refine_flags(std::istream &in)
void save_user_indices_line(std::vector< unsigned int > &v) const
raw_cell_iterator begin_raw(const unsigned int level=0) const
unsigned int n_lines() const
void load_coarsen_flags(const std::vector< bool > &v)
unsigned int n_raw_lines() const
virtual std::size_t memory_consumption() const
std::vector< Point< spacedim > > vertices
Definition: tria.h:4197
raw_quad_iterator begin_raw_quad(const unsigned int level=0) const
virtual types::subdomain_id locally_owned_subdomain() const
unsigned int n_raw_faces() const
unsigned int n_active_faces() const
const bool check_for_distorted_cells
Definition: tria.h:4221
raw_cell_iterator end_raw(const unsigned int level) const
line_iterator end_line() const
std::unique_ptr< std::map< unsigned int, types::boundary_id > > vertex_to_boundary_id_map_1d
Definition: tria.h:4249
void load_user_flags_quad(std::istream &in)
unsigned int n_active_cells() const
virtual void update_reference_cells()
std::vector< ReferenceCell > reference_cells
Definition: tria.h:3736
void update_periodic_face_map()
unsigned int n_raw_lines(const unsigned int level) const
void clear_despite_subscriptions()
void save_user_flags(std::ostream &out) const
void load_user_flags_hex(std::istream &in)
void load_user_pointers_quad(const std::vector< void * > &v)
std::unique_ptr<::internal::TriangulationImplementation::TriaFaces > faces
Definition: tria.h:4191
virtual void add_periodicity(const std::vector< GridTools::PeriodicFacePair< cell_iterator >> &)
unsigned int n_used_vertices() const
void reset_cell_vertex_indices_cache()
unsigned int n_active_lines() const
unsigned int n_levels() const
void load_user_flags_hex(const std::vector< bool > &v)
void load_user_indices_line(const std::vector< unsigned int > &v)
void clear_user_flags_hex()
void save_user_pointers_hex(std::vector< void * > &v) const
typename IteratorSelector::raw_quad_iterator raw_quad_iterator
Definition: tria.h:3826
void load_user_pointers(const std::vector< void * > &v)
::internal::TriangulationImplementation::NumberCache< dim > number_cache
Definition: tria.h:4232
void load_user_flags_quad(const std::vector< bool > &v)
void load_user_flags_line(const std::vector< bool > &v)
void save_user_indices_hex(std::vector< unsigned int > &v) const
DistortedCellList execute_refinement()
active_line_iterator begin_active_line(const unsigned int level=0) const
void save_user_indices_quad(std::vector< unsigned int > &v) const
void load_user_pointers_hex(const std::vector< void * > &v)
cell_iterator end() const
virtual bool has_hanging_nodes() const
std::vector< GridTools::PeriodicFacePair< cell_iterator > > periodic_face_pairs_level_0
Definition: tria.h:3797
unsigned int n_raw_cells(const unsigned int level) const
cell_iterator end(const unsigned int level) const
virtual types::coarse_cell_id coarse_cell_index_to_coarse_cell_id(const unsigned int coarse_cell_index) const
unsigned int n_raw_quads(const unsigned int level) const
void load_coarsen_flags(std::istream &out)
quad_iterator end_quad() const
line_iterator begin_line(const unsigned int level=0) const
unsigned int max_adjacent_cells() const
vertex_iterator begin_vertex() const
void clear_user_flags()
unsigned int n_hexs() const
vertex_iterator end_vertex() const
bool vertex_used(const unsigned int index) const
void load_user_pointers_line(const std::vector< void * > &v)
void save_user_flags(std::vector< bool > &v) const
hex_iterator end_hex() const
const Triangulation< dim, spacedim > & get_triangulation() const
hex_iterator begin_hex(const unsigned int level=0) const
virtual unsigned int n_global_levels() const
active_cell_iterator end_active(const unsigned int level) const
bool is_mixed_mesh() const
cell_iterator last() const
unsigned int n_active_quads() const
void save_coarsen_flags(std::vector< bool > &v) const
void load_user_indices_hex(const std::vector< unsigned int > &v)
unsigned int n_raw_quads() const
void save_user_pointers(std::vector< void * > &v) const
face_iterator begin_face() const
unsigned int n_cells() const
virtual bool prepare_coarsening_and_refinement()
unsigned int n_active_quads(const unsigned int level) const
void load_user_flags(const std::vector< bool > &v)
typename IteratorSelector::raw_hex_iterator raw_hex_iterator
Definition: tria.h:3827
const std::map< std::pair< cell_iterator, unsigned int >, std::pair< std::pair< cell_iterator, unsigned int >, std::bitset< 3 > > > & get_periodic_face_map() const
std::map< types::manifold_id, std::unique_ptr< const Manifold< dim, spacedim > > > manifolds
Definition: tria.h:4209
void serialize(Archive &archive, const unsigned int version)
void load_refine_flags(const std::vector< bool > &v)
MeshSmoothing smooth_grid
Definition: tria.h:3730
void save_refine_flags(std::ostream &out) const
std::unique_ptr< ::internal::TriangulationImplementation::Policy< dim, spacedim > > policy
Definition: tria.h:3788
Triangulation< dim, spacedim > & get_triangulation()
void save_user_flags_quad(std::ostream &out) const
Signals signals
Definition: tria.h:2478
unsigned int n_active_hexs(const unsigned int level) const
unsigned int n_vertices() const
void load(Archive &ar, const unsigned int version)
void save_user_indices(std::vector< unsigned int > &v) const
void save_user_flags_hex(std::vector< bool > &v) const
bool all_reference_cells_are_simplex() const
std::vector< std::unique_ptr<::internal::TriangulationImplementation::TriaLevel > > levels
Definition: tria.h:4183
unsigned int n_raw_hexs(const unsigned int level) const
unsigned int n_lines(const unsigned int level) const
unsigned int n_active_hexs() const
virtual unsigned int coarse_cell_id_to_coarse_cell_index(const types::coarse_cell_id coarse_cell_id) const
unsigned int n_quads(const unsigned int level) const
void load_user_flags(std::istream &in)
void reset_policy()
const std::vector< ReferenceCell > & get_reference_cells() const
void save_coarsen_flags(std::ostream &out) const
active_face_iterator begin_active_face() const
void clear_user_flags_line()
raw_line_iterator begin_raw_line(const unsigned int level=0) const
static void write_bool_vector(const unsigned int magic_number1, const std::vector< bool > &v, const unsigned int magic_number2, std::ostream &out)
const std::vector< Point< spacedim > > & get_vertices() const
active_cell_iterator begin_active(const unsigned int level=0) const
void execute_coarsening()
void save_refine_flags(std::vector< bool > &v) const
#define DEAL_II_DEPRECATED
Definition: config.h:174
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:474
#define DEAL_II_CXX20_REQUIRES(condition)
Definition: config.h:162
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:475
Point< 3 > vertices[4]
Point< 2 > first
Definition: grid_out.cc:4615
unsigned int level
Definition: grid_out.cc:4618
IteratorRange< active_cell_iterator > active_cell_iterators() const
IteratorRange< active_face_iterator > active_face_iterators() const
IteratorRange< active_cell_iterator > active_cell_iterators_on_level(const unsigned int level) const
IteratorRange< cell_iterator > cell_iterators() const
IteratorRange< cell_iterator > cell_iterators_on_level(const unsigned int level) const
#define DeclException0(Exception0)
Definition: exceptions.h:465
static ::ExceptionBase & ExcInternalError()
#define Assert(cond, exc)
Definition: exceptions.h:1586
#define DeclException2(Exception2, type1, type2, outsequence)
Definition: exceptions.h:533
#define AssertIndexRange(index, range)
Definition: exceptions.h:1827
#define DeclExceptionMsg(Exception, defaulttext)
Definition: exceptions.h:488
#define DeclException1(Exception1, type1, outsequence)
Definition: exceptions.h:510
static ::ExceptionBase & ExcMessage(std::string arg1)
static ::ExceptionBase & ExcFacesHaveNoLevel()
typename IteratorSelector::hex_iterator hex_iterator
Definition: tria.h:1504
typename IteratorSelector::active_quad_iterator active_quad_iterator
Definition: tria.h:1495
typename IteratorSelector::active_hex_iterator active_hex_iterator
Definition: tria.h:1515
typename IteratorSelector::quad_iterator quad_iterator
Definition: tria.h:1480
typename IteratorSelector::line_iterator line_iterator
Definition: tria.h:1456
typename IteratorSelector::active_line_iterator active_line_iterator
Definition: tria.h:1471
void create_triangulation(Triangulation< dim, dim > &tria, const AdditionalData &additional_data=AdditionalData())
static const char T
std::enable_if_t< std::is_fundamental< T >::value, std::size_t > memory_consumption(const T &t)
Definition: types.h:33
unsigned int manifold_id
Definition: types.h:153
global_cell_index coarse_cell_id
Definition: types.h:127
unsigned int subdomain_id
Definition: types.h:44
unsigned int global_cell_index
Definition: types.h:118
unsigned int boundary_id
Definition: types.h:141
T operator()(InputIterator first, InputIterator last) const
Definition: tria.h:2088
virtual ~DistortedCellList() noexcept override
boost::signals2::signal< unsigned int(const cell_iterator &, const CellStatus), CellWeightSum< unsigned int > > weight
Definition: tria.h:2242
boost::signals2::signal< void()> mesh_movement
Definition: tria.h:2145
boost::signals2::signal< void()> post_distributed_load
Definition: tria.h:2472
boost::signals2::signal< void()> pre_distributed_save
Definition: tria.h:2450
boost::signals2::signal< void(const Triangulation< dim, spacedim > &destination_tria)> copy
Definition: tria.h:2176
boost::signals2::signal< void()> pre_distributed_refinement
Definition: tria.h:2409
boost::signals2::signal< void()> post_distributed_refinement
Definition: tria.h:2428
boost::signals2::signal< void()> pre_refinement
Definition: tria.h:2121
boost::signals2::signal< void()> any_change
Definition: tria.h:2202
boost::signals2::signal< void()> create
Definition: tria.h:2112
boost::signals2::signal< void()> clear
Definition: tria.h:2191
boost::signals2::signal< void(const typename Triangulation< dim, spacedim >::cell_iterator &cell)> post_refinement_on_cell
Definition: tria.h:2166
LegacySignal cell_weight
Definition: tria.h:2396
boost::signals2::signal< void(const typename Triangulation< dim, spacedim >::cell_iterator &cell)> pre_coarsening_on_cell
Definition: tria.h:2156
boost::signals2::signal< void()> post_refinement
Definition: tria.h:2128
boost::signals2::signal< void()> pre_partition
Definition: tria.h:2136
boost::signals2::signal< void()> pre_distributed_repartition
Definition: tria.h:2435
boost::signals2::signal< void()> pre_distributed_load
Definition: tria.h:2465
boost::signals2::signal< void()> post_p4est_refinement
Definition: tria.h:2418
boost::signals2::signal< void()> post_distributed_repartition
Definition: tria.h:2442
boost::signals2::signal< void()> post_distributed_save
Definition: tria.h:2457
std::shared_ptr< const Utilities::MPI::Partitioner > active_cell_index_partitioner
Definition: tria.h:184
void serialize(Archive &ar, const unsigned int version)
std::vector< unsigned int > n_active_lines_level
Definition: tria.h:178
std::vector< std::shared_ptr< const Utilities::MPI::Partitioner > > level_cell_index_partitioners
Definition: tria.h:190
std::vector< unsigned int > n_active_quads_level
Definition: tria.h:248
void serialize(Archive &ar, const unsigned int version)
void serialize(Archive &ar, const unsigned int version)
std::vector< unsigned int > n_active_hexes_level
Definition: tria.h:307
const ::Triangulation< dim, spacedim > & tria