Reference documentation for deal.II version GIT 44af803bb8 2022-12-03 23:15:02+00:00
PersistentTriangulation< dim, spacedim > Class Template Reference

#include <deal.II/grid/persistent_tria.h>

Inheritance diagram for PersistentTriangulation< dim, spacedim >:
[legend]

## Public Types

enum  MeshSmoothing

using cell_iterator = TriaIterator< CellAccessor< dim, spacedim > >

using level_cell_iterator = cell_iterator

using active_cell_iterator = TriaActiveIterator< CellAccessor< dim, spacedim > >

using face_iterator = TriaIterator< TriaAccessor< dim - 1, dim, spacedim > >

using active_face_iterator = TriaActiveIterator< TriaAccessor< dim - 1, dim, spacedim > >

using vertex_iterator = TriaIterator<::TriaAccessor< 0, dim, spacedim > >

using active_vertex_iterator = TriaActiveIterator<::TriaAccessor< 0, dim, spacedim > >

using line_iterator = typename IteratorSelector::line_iterator

using active_line_iterator = typename IteratorSelector::active_line_iterator

using hex_iterator = typename IteratorSelector::hex_iterator

using active_hex_iterator = typename IteratorSelector::active_hex_iterator

## Public Member Functions

PersistentTriangulation (const Triangulation< dim, spacedim > &coarse_grid)

PersistentTriangulation (const PersistentTriangulation< dim, spacedim > &old_tria)

virtual ~PersistentTriangulation () override=default

virtual void execute_coarsening_and_refinement () override

void restore ()

void restore (const unsigned int step_no)

unsigned int n_refinement_steps () const

virtual void copy_triangulation (const Triangulation< dim, spacedim > &tria) override

virtual void create_triangulation (const std::vector< Point< spacedim >> &vertices, const std::vector< CellData< dim >> &cells, const SubCellData &subcelldata) override

virtual void create_triangulation (const TriangulationDescription::Description< dim, spacedim > &construction_data) override

virtual void create_triangulation_compatibility (const std::vector< Point< spacedim >> &vertices, const std::vector< CellData< dim >> &cells, const SubCellData &subcelldata) override

virtual void write_flags (std::ostream &out) const

virtual void clear_flags ()

virtual std::size_t memory_consumption () const override

virtual void clear ()

virtual MPI_Comm get_communicator () const

virtual const std::weak_ptr< const Utilities::MPI::Partitionerglobal_active_cell_index_partitioner () const

virtual const std::weak_ptr< const Utilities::MPI::Partitionerglobal_level_cell_index_partitioner (const unsigned int level) const

virtual void set_mesh_smoothing (const MeshSmoothing mesh_smoothing)

virtual const MeshSmoothingget_mesh_smoothing () const

void set_manifold (const types::manifold_id number, const Manifold< dim, spacedim > &manifold_object)

void reset_manifold (const types::manifold_id manifold_number)

void reset_all_manifolds ()

void set_all_manifold_ids (const types::manifold_id number)

void set_all_manifold_ids_on_boundary (const types::manifold_id number)

void set_all_manifold_ids_on_boundary (const types::boundary_id b_id, const types::manifold_id number)

const Manifold< dim, spacedim > & get_manifold (const types::manifold_id number) const

virtual std::vector< types::boundary_idget_boundary_ids () const

virtual std::vector< types::manifold_idget_manifold_ids () const

void flip_all_direction_flags ()

bool prepare_coarsening_and_refinement ()

bool prepare_coarsening_and_refinement ()

bool prepare_coarsening_and_refinement ()

unsigned int n_quads (const unsigned int) const

unsigned int n_quads (const unsigned int) const

unsigned int n_quads (const unsigned int) const

unsigned int n_active_quads (const unsigned int) const

unsigned int n_active_quads (const unsigned int) const

unsigned int n_active_quads (const unsigned int) const

unsigned int n_hexs () const

unsigned int n_hexs (const unsigned int level) const

unsigned int n_active_hexs () const

unsigned int n_active_hexs (const unsigned int level) const

unsigned int n_raw_quads (const unsigned int) const

unsigned int n_raw_quads (const unsigned int) const

unsigned int n_raw_quads (const unsigned int) const

unsigned int n_raw_quads (const unsigned int level) const

unsigned int n_raw_quads (const unsigned int level) const

unsigned int n_raw_quads (const unsigned int) const

unsigned int n_raw_hexs (const unsigned int) const

unsigned int n_raw_hexs (const unsigned int) const

unsigned int n_raw_hexs (const unsigned int) const

unsigned int n_raw_hexs (const unsigned int level) const

Mesh refinement
void set_all_refine_flags ()

void refine_global (const unsigned int times=1)

void coarsen_global (const unsigned int times=1)

virtual bool prepare_coarsening_and_refinement ()

History of a triangulation
void save_refine_flags (std::ostream &out) const

void save_refine_flags (std::vector< bool > &v) const

void load_refine_flags (const std::vector< bool > &v)

void save_coarsen_flags (std::ostream &out) const

void save_coarsen_flags (std::vector< bool > &v) const

void load_coarsen_flags (const std::vector< bool > &v)

bool get_anisotropic_refinement_flag () const

User data
void clear_user_flags ()

void save_user_flags (std::ostream &out) const

void save_user_flags (std::vector< bool > &v) const

void load_user_flags (const std::vector< bool > &v)

void clear_user_flags_line ()

void save_user_flags_line (std::ostream &out) const

void save_user_flags_line (std::vector< bool > &v) const

void load_user_flags_line (const std::vector< bool > &v)

void save_user_flags_quad (std::vector< bool > &v) const

void clear_user_flags_hex ()

void save_user_flags_hex (std::ostream &out) const

void save_user_flags_hex (std::vector< bool > &v) const

void load_user_flags_hex (const std::vector< bool > &v)

void clear_user_data ()

void save_user_indices (std::vector< unsigned int > &v) const

void load_user_indices (const std::vector< unsigned int > &v)

void save_user_pointers (std::vector< void * > &v) const

void load_user_pointers (const std::vector< void * > &v)

void save_user_indices_line (std::vector< unsigned int > &v) const

void load_user_indices_line (const std::vector< unsigned int > &v)

void save_user_indices_quad (std::vector< unsigned int > &v) const

void save_user_indices_hex (std::vector< unsigned int > &v) const

void load_user_indices_hex (const std::vector< unsigned int > &v)

void save_user_pointers_line (std::vector< void * > &v) const

void load_user_pointers_line (const std::vector< void * > &v)

void save_user_pointers_quad (std::vector< void * > &v) const

void save_user_pointers_hex (std::vector< void * > &v) const

void load_user_pointers_hex (const std::vector< void * > &v)

Cell iterator functions
cell_iterator begin (const unsigned int level=0) const

active_cell_iterator begin_active (const unsigned int level=0) const

cell_iterator end () const

cell_iterator end (const unsigned int level) const

active_cell_iterator end_active (const unsigned int level) const

cell_iterator last () const

active_cell_iterator last_active () const

cell_iterator create_cell_iterator (const CellId &cell_id) const

Cell iterator functions returning ranges of iterators
IteratorRange< cell_iteratorcell_iterators () const

IteratorRange< active_cell_iteratoractive_cell_iterators () const

IteratorRange< cell_iteratorcell_iterators_on_level (const unsigned int level) const

IteratorRange< active_cell_iteratoractive_cell_iterators_on_level (const unsigned int level) const

Face iterator functions
face_iterator begin_face () const

active_face_iterator begin_active_face () const

face_iterator end_face () const

IteratorRange< active_face_iteratoractive_face_iterators () const

Vertex iterator functions
vertex_iterator begin_vertex () const

active_vertex_iterator begin_active_vertex () const

vertex_iterator end_vertex () const

unsigned int n_lines () const

unsigned int n_lines (const unsigned int level) const

unsigned int n_active_lines () const

unsigned int n_active_lines (const unsigned int level) const

unsigned int n_quads (const unsigned int level) const

unsigned int n_active_quads (const unsigned int level) const

unsigned int n_hexs () const

unsigned int n_hexs (const unsigned int level) const

unsigned int n_active_hexs () const

unsigned int n_active_hexs (const unsigned int level) const

unsigned int n_cells () const

unsigned int n_cells (const unsigned int level) const

unsigned int n_active_cells () const

unsigned int n_active_cells (const unsigned int level) const

virtual types::global_cell_index n_global_active_cells () const

virtual types::coarse_cell_id n_global_coarse_cells () const

unsigned int n_faces () const

unsigned int n_active_faces () const

unsigned int n_levels () const

virtual unsigned int n_global_levels () const

virtual bool has_hanging_nodes () const

unsigned int n_vertices () const

const std::vector< Point< spacedim > > & get_vertices () const

unsigned int n_used_vertices () const

bool vertex_used (const unsigned int index) const

const std::vector< bool > & get_used_vertices () const

virtual types::subdomain_id locally_owned_subdomain () const

Triangulation< dim, spacedim > & get_triangulation ()

const Triangulation< dim, spacedim > & get_triangulation () const

Internal information about the number of objects
unsigned int n_raw_lines () const

unsigned int n_raw_lines (const unsigned int level) const

unsigned int n_raw_quads (const unsigned int level) const

unsigned int n_raw_hexs (const unsigned int level) const

unsigned int n_raw_cells (const unsigned int level) const

unsigned int n_raw_faces () const

void save (Archive &ar, const unsigned int version) const

void load (Archive &ar, const unsigned int version)

virtual void add_periodicity (const std::vector< GridTools::PeriodicFacePair< cell_iterator >> &)

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

const std::vector< ReferenceCell > & get_reference_cells () const

bool all_reference_cells_are_hyper_cube () const

bool all_reference_cells_are_simplex () const

bool is_mixed_mesh () const

void serialize (Archive &archive, const unsigned int version)

Subscriptor functionality

Classes derived from Subscriptor provide a facility to subscribe to this object. This is mostly used by the SmartPointer class.

void subscribe (std::atomic< bool > *const validity, const std::string &identifier="") const

void unsubscribe (std::atomic< bool > *const validity, const std::string &identifier="") const

unsigned int n_subscriptions () const

template<typename StreamType >
void list_subscribers (StreamType &stream) const

void list_subscribers () const

## Static Public Member Functions

static ::ExceptionBaseExcTriaNotEmpty ()

static ::ExceptionBaseExcFlagsNotCleared ()

static ::ExceptionBaseExcInUse (int arg1, std::string arg2, std::string arg3)

static ::ExceptionBaseExcNoSubscriber (std::string arg1, std::string arg2)

## Static Public Attributes

static constexpr unsigned int dimension = dim

static const unsigned int spacedimension = spacedim

static constexpr unsigned int space_dimension

## Private Types

using IteratorSelector = ::internal::TriangulationImplementation::Iterators< dim, spacedim >

using map_value_type = decltype(counter_map)::value_type

using map_iterator = decltype(counter_map)::iterator

## Private Member Functions

void check_no_subscribers () const noexcept

Line iterator functions for internal use
raw_line_iterator begin_raw_line (const unsigned int level=0) const

line_iterator begin_line (const unsigned int level=0) const

active_line_iterator begin_active_line (const unsigned int level=0) const

line_iterator end_line () const

Quad iterator functions for internal use

## Private Attributes

SmartPointer< const Triangulation< dim, spacedim >, PersistentTriangulation< dim, spacedim > > coarse_grid

std::vector< std::vector< bool > > refine_flags

std::vector< std::vector< bool > > coarsen_flags

std::atomic< unsigned int > counter

std::map< std::string, unsigned int > counter_map

std::vector< std::atomic< bool > * > validity_pointers

const std::type_info * object_info

## Static Private Attributes

static std::mutex mutex

## Exceptions

std::unique_ptr< ::internal::TriangulationImplementation::Policy< dim, spacedim > > policy

std::vector< GridTools::PeriodicFacePair< cell_iterator > > periodic_face_pairs_level_0

std::map< std::pair< cell_iterator, unsigned int >, std::pair< std::pair< cell_iterator, unsigned int >, std::bitset< 3 > > > periodic_face_map

static ::ExceptionBaseExcInvalidLevel (int arg1, int arg2)

static ::ExceptionBaseExcTriangulationNotEmpty (int arg1, int arg2)

static ::ExceptionBaseExcFacesHaveNoLevel ()

static ::ExceptionBaseExcEmptyLevel (int arg1)

static ::ExceptionBaseExcNonOrientableTriangulation ()

static ::ExceptionBaseExcBoundaryIdNotFound (types::boundary_id arg1)

static ::ExceptionBaseExcInconsistentCoarseningFlags ()

MeshSmoothing smooth_grid

std::vector< ReferenceCellreference_cells

static void write_bool_vector (const unsigned int magic_number1, const std::vector< bool > &v, const unsigned int magic_number2, std::ostream &out)

static void read_bool_vector (const unsigned int magic_number1, std::vector< bool > &v, const unsigned int magic_number2, std::istream &in)

void update_periodic_face_map ()

virtual void update_reference_cells ()

## Hex iterator functions for internal use

std::vector< std::unique_ptr<::internal::TriangulationImplementation::TriaLevel > > levels

std::unique_ptr<::internal::TriangulationImplementation::TriaFacesfaces

std::vector< Point< spacedim > > vertices

std::vector< boolvertices_used

std::map< types::manifold_id, std::unique_ptr< const Manifold< dim, spacedim > > > manifolds

bool anisotropic_refinement

const bool check_for_distorted_cells

::internal::TriangulationImplementation::NumberCache< dim > number_cache

std::unique_ptr< std::map< unsigned int, types::boundary_id > > vertex_to_boundary_id_map_1d

std::unique_ptr< std::map< unsigned int, types::manifold_id > > vertex_to_manifold_id_map_1d

raw_hex_iterator begin_raw_hex (const unsigned int level=0) const

hex_iterator begin_hex (const unsigned int level=0) const

active_hex_iterator begin_active_hex (const unsigned int level=0) const

hex_iterator end_hex () const

void clear_despite_subscriptions ()

void reset_policy ()

void reset_active_cell_indices ()

void reset_global_cell_indices ()

void reset_cell_vertex_indices_cache ()

DistortedCellList execute_refinement ()

void execute_coarsening ()

void fix_coarsen_flags ()

virtual unsigned int coarse_cell_id_to_coarse_cell_index (const types::coarse_cell_id coarse_cell_id) const

virtual types::coarse_cell_id coarse_cell_index_to_coarse_cell_id (const unsigned int coarse_cell_index) const

enum  CellStatus

Signals signals

## Cell iterator functions for internal use

using raw_cell_iterator = TriaRawIterator< CellAccessor< dim, spacedim > >

using raw_face_iterator = TriaRawIterator< TriaAccessor< dim - 1, dim, spacedim > >

using raw_vertex_iterator = TriaRawIterator<::TriaAccessor< 0, dim, spacedim > >

using raw_line_iterator = typename IteratorSelector::raw_line_iterator

using raw_hex_iterator = typename IteratorSelector::raw_hex_iterator

raw_cell_iterator begin_raw (const unsigned int level=0) const

raw_cell_iterator end_raw (const unsigned int level) const

## Detailed Description

### template<int dim, int spacedim = dim> class PersistentTriangulation< dim, spacedim >

This class handles the history of a triangulation and can rebuild it after it was deleted some time before. Its main purpose is support for time- dependent problems where one frequently deletes a triangulation due to memory pressure and later wants to rebuild it; this class has all the information to rebuild it exactly as it was before including the mapping of cell numbers to the geometrical cells.

Basically, this is a drop-in replacement for the triangulation. Since it is derived from the Triangulation class, it shares all the functionality, but it overrides some virtual functions and adds some functions, too. The main change to the base class is that it overrides the execute_coarsening_and_refinement function, where the new version first stores all refinement and coarsening flags and only then calls the respective function of the base class. The stored flags may later be used to restore the grid just as it was before. Some other functions have been extended slightly as well, see their documentation for more information.

We note that since the triangulation is created in exactly the same state as it was before, other objects working on it should result in the same state as well. This holds in particular for the DoFHandler object, which will assign the same degrees of freedom to the original cells and the ones after reconstruction of the triangulation. You can therefore safely use data vectors computed on the original grid on the reconstructed grid as well.

### Usage

You can use objects of this class almost in the same way as objects of the Triangulation class. One of the few differences is that you can only construct such an object by giving a coarse grid to the constructor. The coarse grid will be used to base the triangulation on, and therefore the lifetime of the coarse grid has to be longer than the lifetime of the object of this class.

Basically, usage looks like this:

... // initialize coarse grid
for (...)
{
// restore grid from coarse grid
// and stored refinement flags
grid.restore ();
... // do something with the grid
... // flag some cells for refinement
// or coarsening
grid.execute_coarsening_and_refinement ();
// actually refine grid and store
// the flags
... // so something more with the grid
grid.clear (); // delete the grid, but keep the
// refinement flags for later use
// in grid.restore() above
... // do something where the grid
// is not needed anymore, e.g.
// working with another grid
};
SmartPointer< const Triangulation< dim, spacedim >, PersistentTriangulation< dim, spacedim > > coarse_grid

Note that initially, the PersistentTriangulation object does not constitute a triangulation; it only becomes one after restore is first called. Note also that the execute_coarsening_and_refinement stores all necessary flags for later reconstruction using the restore function. Triangulation::clear() resets the underlying triangulation to a virgin state, but does not affect the stored refinement flags needed for later reconstruction and does also not touch the coarse grid which is used within restore().

Definition at line 108 of file persistent_tria.h.

## ◆ IteratorSelector

 using Triangulation< dim, spacedim >::IteratorSelector = ::internal::TriangulationImplementation::Iterators
privateinherited

An internal alias to make the definition of the iterator classes simpler.

Definition at line 1141 of file tria.h.

## ◆ cell_iterator

 using Triangulation< dim, spacedim >::cell_iterator = TriaIterator >
inherited

An alias that is used to identify cell iterators. The concept of iterators is discussed at length in the iterators documentation module.

The current alias identifies cells in a triangulation. The TriaIterator class works like a pointer that when you dereference it yields an object of type CellAccessor. CellAccessor is a class that identifies properties that are specific to cells in a triangulation, but it is derived (and consequently inherits) from TriaAccessor that describes what you can ask of more general objects (lines, faces, as well as cells) in a triangulation.

Definition at line 1368 of file tria.h.

## ◆ level_cell_iterator

 using Triangulation< dim, spacedim >::level_cell_iterator = cell_iterator
inherited

The same as above to allow the usage of the "MeshType concept" also on the refinement levels.

Definition at line 1374 of file tria.h.

## ◆ active_cell_iterator

 using Triangulation< dim, spacedim >::active_cell_iterator = TriaActiveIterator >
inherited

An alias that is used to identify active cell iterators. The concept of iterators is discussed at length in the iterators documentation module.

The current alias identifies active cells in a triangulation. The TriaActiveIterator class works like a pointer to active objects that when you dereference it yields an object of type CellAccessor. CellAccessor is a class that identifies properties that are specific to cells in a triangulation, but it is derived (and consequently inherits) from TriaAccessor that describes what you can ask of more general objects (lines, faces, as well as cells) in a triangulation.

Definition at line 1392 of file tria.h.

## ◆ face_iterator

 using Triangulation< dim, spacedim >::face_iterator = TriaIterator >
inherited

An alias that is used to identify iterators that point to faces. The concept of iterators is discussed at length in the iterators documentation module.

The current alias identifies faces in a triangulation. The TriaIterator class works like a pointer to objects that when you dereference it yields an object of type TriaAccessor, i.e., class that can be used to query geometric properties of faces such as their vertices, their area, etc.

Definition at line 1407 of file tria.h.

## ◆ active_face_iterator

 using Triangulation< dim, spacedim >::active_face_iterator = TriaActiveIterator >
inherited

An alias that is used to identify iterators that point to active faces, i.e., to faces that have no children. Active faces must be faces of at least one active cell.

Other than the "active" qualification, this alias is identical to the face_iterator alias. In particular, dereferencing either yields the same kind of object.

Definition at line 1420 of file tria.h.

## ◆ vertex_iterator

 using Triangulation< dim, spacedim >::vertex_iterator = TriaIterator<::TriaAccessor<0, dim, spacedim> >
inherited

An alias that defines an iterator type to iterate over vertices of a mesh. The concept of iterators is discussed at length in the iterators documentation module.

Definition at line 1431 of file tria.h.

## ◆ active_vertex_iterator

 using Triangulation< dim, spacedim >::active_vertex_iterator = TriaActiveIterator<::TriaAccessor<0, dim, spacedim> >
inherited

An alias that defines an iterator type to iterate over vertices of a mesh. The concept of iterators is discussed at length in the iterators documentation module.

This alias is in fact identical to the vertex_iterator alias above since all vertices in a mesh are active (i.e., are a vertex of an active cell).

Definition at line 1445 of file tria.h.

## ◆ line_iterator

 using Triangulation< dim, spacedim >::line_iterator = typename IteratorSelector::line_iterator
inherited

An alias that defines an iterator over the (one-dimensional) lines of a mesh. In one-dimensional meshes, these are the cells of the mesh, whereas in two-dimensional meshes the lines are the faces of cells.

Definition at line 1455 of file tria.h.

## ◆ active_line_iterator

 using Triangulation< dim, spacedim >::active_line_iterator = typename IteratorSelector::active_line_iterator
inherited

An alias that allows iterating over the active lines, i.e., that subset of lines that have no children. In one-dimensional meshes, these are the cells of the mesh, whereas in two-dimensional meshes the lines are the faces of cells.

In two- or three-dimensional meshes, lines without children (i.e., the active lines) are part of at least one active cell. Each such line may additionally be a child of a line of a coarser cell adjacent to a cell that is active. (This coarser neighbor would then also be active.)

Definition at line 1470 of file tria.h.

inherited

An alias that defines an iterator over the (two-dimensional) quads of a mesh. In two-dimensional meshes, these are the cells of the mesh, whereas in three-dimensional meshes the quads are the faces of cells.

Definition at line 1479 of file tria.h.

inherited

An alias that allows iterating over the active quads, i.e., that subset of quads that have no children. In two-dimensional meshes, these are the cells of the mesh, whereas in three-dimensional meshes the quads are the faces of cells.

In three-dimensional meshes, quads without children (i.e., the active quads) are faces of at least one active cell. Each such quad may additionally be a child of a quad face of a coarser cell adjacent to a cell that is active. (This coarser neighbor would then also be active.)

Definition at line 1494 of file tria.h.

## ◆ hex_iterator

 using Triangulation< dim, spacedim >::hex_iterator = typename IteratorSelector::hex_iterator
inherited

An alias that defines an iterator over the (three-dimensional) hexes of a mesh. This iterator only makes sense in three-dimensional meshes, where hexes are the cells of the mesh.

Definition at line 1503 of file tria.h.

## ◆ active_hex_iterator

 using Triangulation< dim, spacedim >::active_hex_iterator = typename IteratorSelector::active_hex_iterator
inherited

An alias that allows iterating over the active hexes of a mesh. This iterator only makes sense in three-dimensional meshes, where hexes are the cells of the mesh. Consequently, in these three-dimensional meshes, this iterator is equivalent to the active_cell_iterator alias.

Definition at line 1514 of file tria.h.

## ◆ raw_cell_iterator

 using Triangulation< dim, spacedim >::raw_cell_iterator = TriaRawIterator >
privateinherited

Declare a number of iterator types for raw iterators, i.e., iterators that also iterate over holes in the list of cells left by cells that have been coarsened away in previous mesh refinement cycles.

Since users should never have to access these internal properties of how we store data, these iterator types are made private.

Definition at line 3819 of file tria.h.

## ◆ raw_face_iterator

 using Triangulation< dim, spacedim >::raw_face_iterator = TriaRawIterator >
privateinherited

Definition at line 3820 of file tria.h.

## ◆ raw_vertex_iterator

 using Triangulation< dim, spacedim >::raw_vertex_iterator = TriaRawIterator<::TriaAccessor<0, dim, spacedim> >
privateinherited

Definition at line 3822 of file tria.h.

## ◆ raw_line_iterator

 using Triangulation< dim, spacedim >::raw_line_iterator = typename IteratorSelector::raw_line_iterator
privateinherited

Definition at line 3824 of file tria.h.

privateinherited

Definition at line 3825 of file tria.h.

## ◆ raw_hex_iterator

 using Triangulation< dim, spacedim >::raw_hex_iterator = typename IteratorSelector::raw_hex_iterator
privateinherited

Definition at line 3826 of file tria.h.

## ◆ map_value_type

 using Subscriptor::map_value_type = decltype(counter_map)::value_type
privateinherited

The data type used in counter_map.

Definition at line 230 of file subscriptor.h.

## ◆ map_iterator

 using Subscriptor::map_iterator = decltype(counter_map)::iterator
privateinherited

The iterator type used in counter_map.

Definition at line 235 of file subscriptor.h.

## ◆ MeshSmoothing

 inherited

Declare some symbolic names for mesh smoothing algorithms. The meaning of these flags is documented in the Triangulation class.

Definition at line 1149 of file tria.h.

## ◆ CellStatus

 inherited

Used to inform functions in derived classes how the cell with the given cell_iterator is going to change. Note that this may me different than the refine_flag() and coarsen_flag() in the cell_iterator in parallel calculations because of refinement constraints that this machine does not see.

Definition at line 2054 of file tria.h.

## ◆ PersistentTriangulation() [1/2]

template<int dim, int spacedim>
 PersistentTriangulation< dim, spacedim >::PersistentTriangulation ( const Triangulation< dim, spacedim > & coarse_grid )

Build up the triangulation from the coarse grid in future. Copy smoothing flags, etc from that grid as well. Note that the initial state of the triangulation is empty, until restore_grid is called for the first time.

The coarse grid must persist until the end of this object, since it will be used upon reconstruction of the grid.

Definition at line 34 of file persistent_tria.cc.

## ◆ PersistentTriangulation() [2/2]

template<int dim, int spacedim>
 PersistentTriangulation< dim, spacedim >::PersistentTriangulation ( const PersistentTriangulation< dim, spacedim > & old_tria )

Copy constructor. This operation is only allowed, if the triangulation underlying the object to be copied is presently empty. Refinement flags as well as the pointer to the coarse grid are copied, however.

Definition at line 42 of file persistent_tria.cc.

## ◆ ~PersistentTriangulation()

template<int dim, int spacedim = dim>
 virtual PersistentTriangulation< dim, spacedim >::~PersistentTriangulation ( )
overridevirtualdefault

Destructor.

## ◆ execute_coarsening_and_refinement()

template<int dim, int spacedim>
 void PersistentTriangulation< dim, spacedim >::execute_coarsening_and_refinement
overridevirtual

Overloaded version of the same function in the base class which stores the refinement and coarsening flags for later reconstruction of the triangulation and after that calls the respective function of the base class.

Reimplemented from Triangulation< dim, dim >.

Definition at line 59 of file persistent_tria.cc.

## ◆ restore() [1/2]

template<int dim, int spacedim>
 void PersistentTriangulation< dim, spacedim >::restore

Restore the grid according to the saved data. For this, the coarse grid is copied and the grid is stepwise rebuilt using the saved flags.

Note that this function will result in an error if the underlying triangulation is not empty, i.e. it will only succeed if this object is newly created or the clear() function of the base class was called on it before.

Repeatedly calls the restore(unsigned int) function in a loop over all refinement steps.

Definition at line 78 of file persistent_tria.cc.

## ◆ restore() [2/2]

template<int dim, int spacedim>
 void PersistentTriangulation< dim, spacedim >::restore ( const unsigned int step_no )

Differential restore. Performs the step_noth local refinement and coarsening step. Step 0 stands for the copying of the coarse grid.

This function will only succeed if the triangulation is in just the state it were if restore would have been called from step=0...step_no-1 before.

Definition at line 90 of file persistent_tria.cc.

## ◆ n_refinement_steps()

template<int dim, int spacedim>
 unsigned int PersistentTriangulation< dim, spacedim >::n_refinement_steps

Return the number of refinement and coarsening steps. This is given by the size of the refine_flags vector.

Definition at line 116 of file persistent_tria.cc.

## ◆ copy_triangulation()

template<int dim, int spacedim>
 void PersistentTriangulation< dim, spacedim >::copy_triangulation ( const Triangulation< dim, spacedim > & tria )
overridevirtual

Overload this function to use tria as a new coarse grid. The present triangulation and all refinement and coarsening flags storing its history are deleted, and the state of the underlying triangulation is reset to be empty, until restore_grid is called the next time.

The coarse grid must persist until the end of this object, since it will be used upon reconstruction of the grid.

Reimplemented from Triangulation< dim, dim >.

Definition at line 125 of file persistent_tria.cc.

## ◆ create_triangulation() [1/2]

template<int dim, int spacedim>
 void PersistentTriangulation< dim, spacedim >::create_triangulation ( const std::vector< Point< spacedim >> & vertices, const std::vector< CellData< dim >> & cells, const SubCellData & subcelldata )
overridevirtual

Throw an error, since this function is not useful in the context of this class.

Reimplemented from Triangulation< dim, dim >.

Definition at line 138 of file persistent_tria.cc.

## ◆ create_triangulation() [2/2]

template<int dim, int spacedim>
 void PersistentTriangulation< dim, spacedim >::create_triangulation ( const TriangulationDescription::Description< dim, spacedim > & construction_data )
overridevirtual

Create a triangulation from a list of vertices and a list of cells, each of the latter being a list of 1<<dim vertex indices. The triangulation must be empty upon calling this function and the cell list should be useful (connected domain, etc.). The result of calling this function is a coarse mesh.

Material data for the cells is given within the cells array, while boundary information is given in the subcelldata field.

The numbering of vertices within the cells array is subject to some constraints; see the general class documentation for this.

For conditions when this function can generate a valid triangulation, see the documentation of this class, and the GridIn and GridReordering class.

If the check_for_distorted_cells flag was specified upon creation of this object, at the very end of its operation, the current function walks over all cells and verifies that none of the cells is deformed (see the entry on distorted cells in the glossary), where we call a cell deformed if the determinant of the Jacobian of the mapping from reference cell to real cell is negative at least at one of the vertices (this computation is done using the GeometryInfo::jacobian_determinants_at_vertices function). If there are deformed cells, this function throws an exception of kind DistortedCellList. Since this happens after all data structures have been set up, you can catch and ignore this exception if you know what you do – for example, it may be that the determinant is zero (indicating that you have collapsed edges in a cell) but that this is ok because you didn't intend to integrate on this cell anyway. On the other hand, deformed cells are often a sign of a mesh that is too coarse to resolve the geometry of the domain, and in this case ignoring the exception is probably unwise.

Note
This function is used in step-14 and step-19.
This function triggers the "create" signal after doing its work. See the section on signals in the general documentation of this class. For example as a consequence of this, all DoFHandler objects connected to this triangulation will be reinitialized via DoFHandler::reinit().
The check for distorted cells is only done if dim==spacedim, as otherwise cells can legitimately be twisted if the manifold they describe is twisted.
Not implemented yet.

Reimplemented from Triangulation< dim, dim >.

Definition at line 150 of file persistent_tria.cc.

## ◆ create_triangulation_compatibility()

template<int dim, int spacedim>
 void PersistentTriangulation< dim, spacedim >::create_triangulation_compatibility ( const std::vector< Point< spacedim >> & vertices, const std::vector< CellData< dim >> & cells, const SubCellData & subcelldata )
overridevirtual

An overload of the respective function of the base class.

Throw an error, since this function is not useful in the context of this class.

Reimplemented from Triangulation< dim, dim >.

Definition at line 162 of file persistent_tria.cc.

## ◆ write_flags()

template<int dim, int spacedim>
 void PersistentTriangulation< dim, spacedim >::write_flags ( std::ostream & out ) const
virtual

Write all refine and coarsen flags to the ostream out.

Definition at line 174 of file persistent_tria.cc.

template<int dim, int spacedim>
 void PersistentTriangulation< dim, spacedim >::read_flags ( std::istream & in )
virtual

Reads all refine and coarsen flags that previously were written by write_flags(...). This is especially useful for rebuilding the triangulation after the end or breakdown of a program and its restart.

Definition at line 203 of file persistent_tria.cc.

## ◆ clear_flags()

template<int dim, int spacedim>
 void PersistentTriangulation< dim, spacedim >::clear_flags
virtual

Clear all flags. Retains the same coarse grid.

Definition at line 241 of file persistent_tria.cc.

## ◆ memory_consumption()

template<int dim, int spacedim>
 std::size_t PersistentTriangulation< dim, spacedim >::memory_consumption
overridevirtual

Determine an estimate for the memory consumption (in bytes) of this object.

Reimplemented from Triangulation< dim, dim >.

Definition at line 251 of file persistent_tria.cc.

## ◆ clear()

 virtual void Triangulation< dim, spacedim >::clear ( )
virtualinherited

Reset this triangulation into a virgin state by deleting all data.

Note that this operation is only allowed if no subscriptions to this object exist any more, such as DoFHandler objects using it.

## ◆ get_communicator()

 virtual MPI_Comm Triangulation< dim, spacedim >::get_communicator ( ) const
virtualinherited

Return MPI communicator used by this triangulation. In the case of a serial Triangulation object, MPI_COMM_SELF is returned.

Reimplemented in parallel::TriangulationBase< dim, spacedim >.

## ◆ global_active_cell_index_partitioner()

 virtual const std::weak_ptr Triangulation< dim, spacedim >::global_active_cell_index_partitioner ( ) const
virtualinherited

Return the partitioner for the global indices of the cells on the active level of the triangulation, which is returned by the function CellAccessor::global_active_cell_index().

Reimplemented in parallel::TriangulationBase< dim, spacedim >.

## ◆ global_level_cell_index_partitioner()

 virtual const std::weak_ptr Triangulation< dim, spacedim >::global_level_cell_index_partitioner ( const unsigned int level ) const
virtualinherited

Return the partitioner for the global indices of the cells on the given level of the triangulation, which is returned by the function CellAccessor::global_level_cell_index().

Reimplemented in parallel::TriangulationBase< dim, spacedim >.

## ◆ set_mesh_smoothing()

 virtual void Triangulation< dim, spacedim >::set_mesh_smoothing ( const MeshSmoothing mesh_smoothing )
virtualinherited

Set the mesh smoothing to mesh_smoothing. This overrides the MeshSmoothing given to the constructor. It is allowed to call this function only if the triangulation is empty.

## ◆ get_mesh_smoothing()

 virtual const MeshSmoothing& Triangulation< dim, spacedim >::get_mesh_smoothing ( ) const
virtualinherited

Return the mesh smoothing requirements that are obeyed.

## ◆ set_manifold()

 void Triangulation< dim, spacedim >::set_manifold ( const types::manifold_id number, const Manifold< dim, spacedim > & manifold_object )
inherited

Assign a manifold object to a certain part of the triangulation. If an object with manifold number number is refined, this object is used to find the location of new vertices (see the results section of step-49 for a more in-depth discussion of this, with examples). It is also used for non-linear (i.e.: non-Q1) transformations of cells to the unit cell in shape function calculations.

A copy of manifold_object is created using Manifold<dim, spacedim>::clone() and stored internally.

It is possible to remove or replace a Manifold object during the lifetime of a non-empty triangulation. Usually, this is done before the first refinement and is dangerous afterwards. Removal of a manifold object is done by reset_manifold(). This operation then replaces the manifold object given before by a straight manifold approximation.

Glossary entry on manifold indicators

## ◆ reset_manifold()

 void Triangulation< dim, spacedim >::reset_manifold ( const types::manifold_id manifold_number )
inherited

Reset those parts of the triangulation with the given manifold_number to use a FlatManifold object. This is the default state of a non-curved triangulation, and undoes assignment of a different Manifold object by the function Triangulation::set_manifold().

Glossary entry on manifold indicators

## ◆ reset_all_manifolds()

 void Triangulation< dim, spacedim >::reset_all_manifolds ( )
inherited

Reset all parts of the triangulation, regardless of their manifold_id, to use a FlatManifold object. This undoes assignment of all Manifold objects by the function Triangulation::set_manifold().

Glossary entry on manifold indicators

## ◆ set_all_manifold_ids()

 void Triangulation< dim, spacedim >::set_all_manifold_ids ( const types::manifold_id number )
inherited

Set the manifold_id of all cells and faces to the given argument.

Glossary entry on manifold indicators

## ◆ set_all_manifold_ids_on_boundary() [1/2]

 void Triangulation< dim, spacedim >::set_all_manifold_ids_on_boundary ( const types::manifold_id number )
inherited

Set the manifold_id of all boundary faces to the given argument.

Glossary entry on manifold indicators

## ◆ set_all_manifold_ids_on_boundary() [2/2]

 void Triangulation< dim, spacedim >::set_all_manifold_ids_on_boundary ( const types::boundary_id b_id, const types::manifold_id number )
inherited

Set the manifold_id of all boundary faces and edges with given boundary_id b_id to the given manifold_id number.

Glossary entry on manifold indicators

## ◆ get_manifold()

 const Manifold& Triangulation< dim, spacedim >::get_manifold ( const types::manifold_id number ) const
inherited

Return a constant reference to a Manifold object used for this triangulation. number is the same as in set_manifold().

Note
If no manifold could be found, the default flat manifold is returned.
Glossary entry on manifold indicators

## ◆ get_boundary_ids()

 virtual std::vector Triangulation< dim, spacedim >::get_boundary_ids ( ) const
virtualinherited

Return a vector containing all boundary indicators assigned to boundary faces of active cells of this Triangulation object. Note, that each boundary indicator is reported only once. The size of the return vector will represent the number of different indicators (which is greater or equal one).

Glossary entry on boundary indicators

Reimplemented in parallel::TriangulationBase< dim, spacedim >.

## ◆ get_manifold_ids()

 virtual std::vector Triangulation< dim, spacedim >::get_manifold_ids ( ) const
virtualinherited

Return a vector containing all manifold indicators assigned to the objects of the active cells of this Triangulation. Note, that each manifold indicator is reported only once. The size of the return vector will represent the number of different indicators (which is greater or equal one).

Glossary entry on manifold indicators

Reimplemented in parallel::TriangulationBase< dim, spacedim >.

## ◆ flip_all_direction_flags()

 void Triangulation< dim, spacedim >::flip_all_direction_flags ( )
inherited

Revert or flip the direction_flags of a dim<spacedim triangulation, see GlossDirectionFlag.

This function throws an exception if dim equals spacedim.

## ◆ set_all_refine_flags()

 void Triangulation< dim, spacedim >::set_all_refine_flags ( )
inherited

Flag all active cells for refinement. This will refine all cells of all levels which are not already refined (i.e. only cells are refined which do not yet have children). The cells are only flagged, not refined, thus you have the chance to save the refinement flags.

## ◆ refine_global()

 void Triangulation< dim, spacedim >::refine_global ( const unsigned int times = 1 )
inherited

Refine all cells times times. In other words, in each one of the times iterations, loop over all cells and refine each cell uniformly into $$2^\text{dim}$$ children. In practice, this function repeats the following operations times times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of $$(2^\text{dim})^\text{times}=2^{\text{dim} \times \text{times}}$$.

The execute_coarsening_and_refinement() function called in this loop may throw an exception if it creates cells that are distorted (see its documentation for an explanation). This exception will be propagated through this function if that happens, and you may not get the actual number of refinement steps in that case.

Note
This function triggers the pre- and post-refinement signals before and after doing each individual refinement cycle (i.e. more than once if times > 1) . See the section on signals in the general documentation of this class.

## ◆ coarsen_global()

 void Triangulation< dim, spacedim >::coarsen_global ( const unsigned int times = 1 )
inherited

Coarsen all cells the given number of times.

In each of one of the times iterations, all cells will be marked for coarsening. If an active cell is already on the coarsest level, it will be ignored.

Note
This function triggers the pre- and post-refinement signals before and after doing each individual coarsening cycle (i.e. more than once if times > 1) . See the section on signals in the general documentation of this class.

## ◆ prepare_coarsening_and_refinement() [1/4]

 virtual bool Triangulation< dim, spacedim >::prepare_coarsening_and_refinement ( )
virtualinherited

Do both preparation for refinement and coarsening as well as mesh smoothing.

Regarding the refinement process it fixes the closure of the refinement in dim>=2 (make sure that no two cells are adjacent with a refinement level differing with more than one), etc. It performs some mesh smoothing if the according flag was given to the constructor of this class. The function returns whether additional cells have been flagged for refinement.

See the general doc of this class for more information on smoothing upon refinement.

Regarding the coarsening part, flagging and deflagging cells in preparation of the actual coarsening step are done. This includes deleting coarsen flags from cells which may not be deleted (e.g. because one neighbor is more refined than the cell), doing some smoothing, etc.

The effect is that only those cells are flagged for coarsening which will actually be coarsened. This includes the fact that all flagged cells belong to parent cells of which all children are flagged.

The function returns whether some cells' flagging has been changed in the process.

This function uses the user flags, so store them if you still need them afterwards.

## ◆ prepare_coarsening_and_refinement() [2/4]

 bool Triangulation< 1, 1 >::prepare_coarsening_and_refinement ( )
inherited

Definition at line 15065 of file tria.cc.

## ◆ prepare_coarsening_and_refinement() [3/4]

 bool Triangulation< 1, 2 >::prepare_coarsening_and_refinement ( )
inherited

Definition at line 15083 of file tria.cc.

## ◆ prepare_coarsening_and_refinement() [4/4]

 bool Triangulation< 1, 3 >::prepare_coarsening_and_refinement ( )
inherited

Definition at line 15101 of file tria.cc.

## ◆ save_refine_flags() [1/2]

 void Triangulation< dim, spacedim >::save_refine_flags ( std::ostream & out ) const
inherited

Save the addresses of the cells which are flagged for refinement to out. For usage, read the general documentation for this class.

## ◆ save_refine_flags() [2/2]

 void Triangulation< dim, spacedim >::save_refine_flags ( std::vector< bool > & v ) const
inherited

Same as above, but store the flags to a bitvector rather than to a file.

 void Triangulation< dim, spacedim >::load_refine_flags ( std::istream & in )
inherited

Read the information stored by save_refine_flags.

 void Triangulation< dim, spacedim >::load_refine_flags ( const std::vector< bool > & v )
inherited

Read the information stored by save_refine_flags.

## ◆ save_coarsen_flags() [1/2]

 void Triangulation< dim, spacedim >::save_coarsen_flags ( std::ostream & out ) const
inherited

Analogue to save_refine_flags.

## ◆ save_coarsen_flags() [2/2]

 void Triangulation< dim, spacedim >::save_coarsen_flags ( std::vector< bool > & v ) const
inherited

Same as above, but store the flags to a bitvector rather than to a file.

 void Triangulation< dim, spacedim >::load_coarsen_flags ( std::istream & out )
inherited

Analogue to load_refine_flags.

 void Triangulation< dim, spacedim >::load_coarsen_flags ( const std::vector< bool > & v )
inherited

Analogue to load_refine_flags.

## ◆ get_anisotropic_refinement_flag()

 bool Triangulation< dim, spacedim >::get_anisotropic_refinement_flag ( ) const
inherited

Return whether this triangulation has ever undergone anisotropic (as opposed to only isotropic) refinement.

## ◆ clear_user_flags()

 void Triangulation< dim, spacedim >::clear_user_flags ( )
inherited

## ◆ save_user_flags() [1/2]

 void Triangulation< dim, spacedim >::save_user_flags ( std::ostream & out ) const
inherited

Save all user flags. See the general documentation for this class and the documentation for the save_refine_flags for more details. See also GlossUserFlags.

## ◆ save_user_flags() [2/2]

 void Triangulation< dim, spacedim >::save_user_flags ( std::vector< bool > & v ) const
inherited

Same as above, but store the flags to a bitvector rather than to a file. The output vector is resized if necessary. See also GlossUserFlags.

 void Triangulation< dim, spacedim >::load_user_flags ( std::istream & in )
inherited

Read the information stored by save_user_flags. See also GlossUserFlags.

 void Triangulation< dim, spacedim >::load_user_flags ( const std::vector< bool > & v )
inherited

Read the information stored by save_user_flags. See also GlossUserFlags.

## ◆ clear_user_flags_line()

 void Triangulation< dim, spacedim >::clear_user_flags_line ( )
inherited

## ◆ save_user_flags_line() [1/2]

 void Triangulation< dim, spacedim >::save_user_flags_line ( std::ostream & out ) const
inherited

## ◆ save_user_flags_line() [2/2]

 void Triangulation< dim, spacedim >::save_user_flags_line ( std::vector< bool > & v ) const
inherited

Same as above, but store the flags to a bitvector rather than to a file. The output vector is resized if necessary. See also GlossUserFlags.

 void Triangulation< dim, spacedim >::load_user_flags_line ( std::istream & in )
inherited

 void Triangulation< dim, spacedim >::load_user_flags_line ( const std::vector< bool > & v )
inherited

 void Triangulation< dim, spacedim >::clear_user_flags_quad ( )
inherited

 void Triangulation< dim, spacedim >::save_user_flags_quad ( std::ostream & out ) const
inherited

 void Triangulation< dim, spacedim >::save_user_flags_quad ( std::vector< bool > & v ) const
inherited

Same as above, but store the flags to a bitvector rather than to a file. The output vector is resized if necessary. See also GlossUserFlags.

inherited

 void Triangulation< dim, spacedim >::load_user_flags_quad ( const std::vector< bool > & v )
inherited

## ◆ clear_user_flags_hex()

 void Triangulation< dim, spacedim >::clear_user_flags_hex ( )
inherited

## ◆ save_user_flags_hex() [1/2]

 void Triangulation< dim, spacedim >::save_user_flags_hex ( std::ostream & out ) const
inherited

## ◆ save_user_flags_hex() [2/2]

 void Triangulation< dim, spacedim >::save_user_flags_hex ( std::vector< bool > & v ) const
inherited

Same as above, but store the flags to a bitvector rather than to a file. The output vector is resized if necessary. See also GlossUserFlags.

 void Triangulation< dim, spacedim >::load_user_flags_hex ( std::istream & in )
inherited

 void Triangulation< dim, spacedim >::load_user_flags_hex ( const std::vector< bool > & v )
inherited

## ◆ clear_user_data()

 void Triangulation< dim, spacedim >::clear_user_data ( )
inherited

Clear all user pointers and indices and allow the use of both for next access. See also GlossUserData.

## ◆ save_user_indices()

 void Triangulation< dim, spacedim >::save_user_indices ( std::vector< unsigned int > & v ) const
inherited

Save all user indices. The output vector is resized if necessary. See also GlossUserData.

 void Triangulation< dim, spacedim >::load_user_indices ( const std::vector< unsigned int > & v )
inherited

## ◆ save_user_pointers()

 void Triangulation< dim, spacedim >::save_user_pointers ( std::vector< void * > & v ) const
inherited

Save all user pointers. The output vector is resized if necessary. See also GlossUserData.

 void Triangulation< dim, spacedim >::load_user_pointers ( const std::vector< void * > & v )
inherited

## ◆ save_user_indices_line()

 void Triangulation< dim, spacedim >::save_user_indices_line ( std::vector< unsigned int > & v ) const
inherited

Save the user indices on lines. The output vector is resized if necessary. See also GlossUserData.

 void Triangulation< dim, spacedim >::load_user_indices_line ( const std::vector< unsigned int > & v )
inherited

 void Triangulation< dim, spacedim >::save_user_indices_quad ( std::vector< unsigned int > & v ) const
inherited

 void Triangulation< dim, spacedim >::load_user_indices_quad ( const std::vector< unsigned int > & v )
inherited

## ◆ save_user_indices_hex()

 void Triangulation< dim, spacedim >::save_user_indices_hex ( std::vector< unsigned int > & v ) const
inherited

Save the user indices on hexes. The output vector is resized if necessary. See also GlossUserData.

 void Triangulation< dim, spacedim >::load_user_indices_hex ( const std::vector< unsigned int > & v )
inherited

## ◆ save_user_pointers_line()

 void Triangulation< dim, spacedim >::save_user_pointers_line ( std::vector< void * > & v ) const
inherited

Save the user indices on lines. The output vector is resized if necessary. See also GlossUserData.

 void Triangulation< dim, spacedim >::load_user_pointers_line ( const std::vector< void * > & v )
inherited

 void Triangulation< dim, spacedim >::save_user_pointers_quad ( std::vector< void * > & v ) const
inherited

 void Triangulation< dim, spacedim >::load_user_pointers_quad ( const std::vector< void * > & v )
inherited

## ◆ save_user_pointers_hex()

 void Triangulation< dim, spacedim >::save_user_pointers_hex ( std::vector< void * > & v ) const
inherited

Save the user pointers on hexes. The output vector is resized if necessary. See also GlossUserData.

 void Triangulation< dim, spacedim >::load_user_pointers_hex ( const std::vector< void * > & v )
inherited

## ◆ begin()

 cell_iterator Triangulation< dim, spacedim >::begin ( const unsigned int level = 0 ) const
inherited

Iterator to the first used cell on level level.

Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

## ◆ begin_active()

 active_cell_iterator Triangulation< dim, spacedim >::begin_active ( const unsigned int level = 0 ) const
inherited

Iterator to the first active cell on level level. If the given level does not contain any active cells (i.e., all cells on this level are further refined, then this function returns end_active(level) so that loops of the kind

for (const auto cell=tria.begin_active(level);
++cell)
{
...
}
active_cell_iterator end_active(const unsigned int level) const
active_cell_iterator begin_active(const unsigned int level=0) const
unsigned int level
Definition: grid_out.cc:4608
const ::Triangulation< dim, spacedim > & tria

have zero iterations, as may be expected if there are no active cells on this level.

Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

## ◆ end() [1/2]

 cell_iterator Triangulation< dim, spacedim >::end ( ) const
inherited

Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.

## ◆ end() [2/2]

 cell_iterator Triangulation< dim, spacedim >::end ( const unsigned int level ) const
inherited

Return an iterator which is the first iterator not on level. If level is the last level, then this returns end().

Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

## ◆ end_active()

 active_cell_iterator Triangulation< dim, spacedim >::end_active ( const unsigned int level ) const
inherited

Return an active iterator which is the first active iterator not on the given level. If level is the last level, then this returns end().

Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

## ◆ last()

 cell_iterator Triangulation< dim, spacedim >::last ( ) const
inherited

Return an iterator pointing to the last used cell.

## ◆ last_active()

 active_cell_iterator Triangulation< dim, spacedim >::last_active ( ) const
inherited

Return an iterator pointing to the last active cell.

## ◆ create_cell_iterator()

 cell_iterator Triangulation< dim, spacedim >::create_cell_iterator ( const CellId & cell_id ) const
inherited

Return an iterator to a cell of this Triangulation object constructed from an independent CellId object.

If the given argument corresponds to a valid cell in this triangulation, this operation will always succeed for sequential triangulations where the current processor stores all cells that are part of the triangulation. On the other hand, if this is a parallel triangulation, then the current processor may not actually know about this cell. In this case, this operation will succeed for locally relevant cells, but may not for artificial cells that are less refined on the current processor.

## ◆ cell_iterators()

 IteratorRange Triangulation< dim, spacedim >::cell_iterators ( ) const
inherited

Return an iterator range that contains all cells (active or not) that make up this triangulation. Such a range is useful to initialize range- based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Returns
The half open range [this->begin(), this->end())

## ◆ active_cell_iterators()

 IteratorRange Triangulation< dim, spacedim >::active_cell_iterators ( ) const
inherited

Return an iterator range that contains all active cells that make up this triangulation. Such a range is useful to initialize range-based for loops as supported by C++11, see also C++11 standard.

Range-based for loops are useful in that they require much less code than traditional loops (see here for a discussion of how they work). An example is that without range-based for loops, one often writes code such as the following (assuming for a moment that our goal is setting the user flag on every active cell):

...
cell = triangulation.begin_active(),
endc = triangulation.end();
for (; cell!=endc; ++cell)
cell->set_user_flag();
const ::parallel::distributed::Triangulation< dim, spacedim > * triangulation

Using C++11's range-based for loops, this is now entirely equivalent to the following:

...
for (const auto &cell : triangulation.active_cell_iterators())
cell->set_user_flag();
Returns
The half open range [this->begin_active(), this->end())

## ◆ cell_iterators_on_level()

 IteratorRange Triangulation< dim, spacedim >::cell_iterators_on_level ( const unsigned int level ) const
inherited

Return an iterator range that contains all cells (active or not) that make up the given level of this triangulation. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Parameters
 [in] level A given level in the refinement hierarchy of this triangulation.
Returns
The half open range [this->begin(level), this->end(level))
Precondition
level must be less than this->n_levels().

## ◆ active_cell_iterators_on_level()

 IteratorRange Triangulation< dim, spacedim >::active_cell_iterators_on_level ( const unsigned int level ) const
inherited

Return an iterator range that contains all active cells that make up the given level of this triangulation. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().

Parameters
 [in] level A given level in the refinement hierarchy of this triangulation.
Returns
The half open range [this->begin_active(level), this->end(level))
Precondition
level must be less than this->n_levels().

## ◆ begin_face()

 face_iterator Triangulation< dim, spacedim >::begin_face ( ) const
inherited

Iterator to the first used face.

## ◆ begin_active_face()

 active_face_iterator Triangulation< dim, spacedim >::begin_active_face ( ) const
inherited

Iterator to the first active face.

## ◆ end_face()

 face_iterator Triangulation< dim, spacedim >::end_face ( ) const
inherited

Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.

## ◆ active_face_iterators()

 IteratorRange Triangulation< dim, spacedim >::active_face_iterators ( ) const
inherited

Return an iterator range that contains all active faces that make up this triangulation. This function is the face version of Triangulation::active_cell_iterators(), and allows one to write code like, e.g.,

...
for (auto &face : triangulation.active_face_iterators())
face->set_manifold_id(42);
Returns
The half open range [this->begin_active_face(), this->end_face())

## ◆ begin_vertex()

 vertex_iterator Triangulation< dim, spacedim >::begin_vertex ( ) const
inherited

Iterator to the first used vertex. This function can only be used if dim is not one.

## ◆ begin_active_vertex()

 active_vertex_iterator Triangulation< dim, spacedim >::begin_active_vertex ( ) const
inherited

Iterator to the first active vertex. Because all vertices are active, begin_vertex() and begin_active_vertex() return the same vertex. This function can only be used if dim is not one.

## ◆ end_vertex()

 vertex_iterator Triangulation< dim, spacedim >::end_vertex ( ) const
inherited

Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states. This function can only be used if dim is not one.

## ◆ n_lines() [1/2]

 unsigned int Triangulation< dim, spacedim >::n_lines ( ) const
inherited

In the following, most functions are provided in two versions, with and without an argument describing the level. The versions with this argument are only applicable for objects describing the cells of the present triangulation. For example: in 2D n_lines(level) cannot be called, only n_lines(), as lines are faces in 2D and therefore have no level. Return the total number of used lines, active or not.

## ◆ n_lines() [2/2]

 unsigned int Triangulation< dim, spacedim >::n_lines ( const unsigned int level ) const
inherited

Return the total number of used lines, active or not on level level.

## ◆ n_active_lines() [1/2]

 unsigned int Triangulation< dim, spacedim >::n_active_lines ( ) const
inherited

Return the total number of active lines.

## ◆ n_active_lines() [2/2]

 unsigned int Triangulation< dim, spacedim >::n_active_lines ( const unsigned int level ) const
inherited

Return the total number of active lines, on level level.

 unsigned int Triangulation< dim, spacedim >::n_quads ( ) const
inherited

Return the total number of used quads, active or not.

 unsigned int Triangulation< dim, spacedim >::n_quads ( const unsigned int level ) const
inherited

Return the total number of used quads, active or not on level level.

 unsigned int Triangulation< 1, 1 >::n_quads ( ) const
inherited

Definition at line 14032 of file tria.cc.

 unsigned int Triangulation< 1, 1 >::n_quads ( const unsigned int ) const
inherited

Definition at line 14040 of file tria.cc.

 unsigned int Triangulation< 1, 2 >::n_quads ( ) const
inherited

Definition at line 14081 of file tria.cc.

 unsigned int Triangulation< 1, 2 >::n_quads ( const unsigned int ) const
inherited

Definition at line 14089 of file tria.cc.

 unsigned int Triangulation< 1, 3 >::n_quads ( ) const
inherited

Definition at line 14129 of file tria.cc.

 unsigned int Triangulation< 1, 3 >::n_quads ( const unsigned int ) const
inherited

Definition at line 14137 of file tria.cc.

 unsigned int Triangulation< dim, spacedim >::n_active_quads ( ) const
inherited

Return the total number of active quads, active or not.

 unsigned int Triangulation< dim, spacedim >::n_active_quads ( const unsigned int level ) const
inherited

Return the total number of active quads, active or not on level level.

 unsigned int Triangulation< 1, 1 >::n_active_quads ( const unsigned int ) const
inherited

Definition at line 14064 of file tria.cc.

 unsigned int Triangulation< 1, 1 >::n_active_quads ( ) const
inherited

Definition at line 14072 of file tria.cc.

 unsigned int Triangulation< 1, 2 >::n_active_quads ( const unsigned int ) const
inherited

Definition at line 14113 of file tria.cc.

 unsigned int Triangulation< 1, 2 >::n_active_quads ( ) const
inherited

Definition at line 14121 of file tria.cc.

 unsigned int Triangulation< 1, 3 >::n_active_quads ( const unsigned int ) const
inherited

Definition at line 14161 of file tria.cc.

 unsigned int Triangulation< 1, 3 >::n_active_quads ( ) const
inherited

Definition at line 14169 of file tria.cc.

## ◆ n_hexs() [1/4]

 unsigned int Triangulation< dim, spacedim >::n_hexs ( ) const
inherited

Return the total number of used hexahedra, active or not.

## ◆ n_hexs() [2/4]

 unsigned int Triangulation< dim, spacedim >::n_hexs ( const unsigned int level ) const
inherited

Return the total number of used hexahedra, active or not on level level.

## ◆ n_hexs() [3/4]

 unsigned int Triangulation< 3, 3 >::n_hexs ( ) const
inherited

Definition at line 14307 of file tria.cc.

## ◆ n_hexs() [4/4]

 unsigned int Triangulation< 3, 3 >::n_hexs ( const unsigned int level ) const
inherited

Definition at line 14316 of file tria.cc.

## ◆ n_active_hexs() [1/4]

 unsigned int Triangulation< dim, spacedim >::n_active_hexs ( ) const
inherited

Return the total number of active hexahedra, active or not.

## ◆ n_active_hexs() [2/4]

 unsigned int Triangulation< dim, spacedim >::n_active_hexs ( const unsigned int level ) const
inherited

Return the total number of active hexahedra, active or not on level level.

## ◆ n_active_hexs() [3/4]

 unsigned int Triangulation< 3, 3 >::n_active_hexs ( ) const
inherited

Definition at line 14336 of file tria.cc.

## ◆ n_active_hexs() [4/4]

 unsigned int Triangulation< 3, 3 >::n_active_hexs ( const unsigned int level ) const
inherited

Definition at line 14345 of file tria.cc.

## ◆ n_cells() [1/2]

 unsigned int Triangulation< dim, spacedim >::n_cells ( ) const
inherited

Return the total number of used cells, active or not. Maps to n_lines() in one space dimension and so on.

## ◆ n_cells() [2/2]

 unsigned int Triangulation< dim, spacedim >::n_cells ( const unsigned int level ) const
inherited

Return the total number of used cells, active or not, on level level. Maps to n_lines(level) in one space dimension and so on.

## ◆ n_active_cells() [1/2]

 unsigned int Triangulation< dim, spacedim >::n_active_cells ( ) const
inherited

Return the total number of active cells. Maps to n_active_lines() in one space dimension and so on.

## ◆ n_active_cells() [2/2]

 unsigned int Triangulation< dim, spacedim >::n_active_cells ( const unsigned int level ) const
inherited

Return the total number of active cells on level level. Maps to n_active_lines(level) in one space dimension and so on.

## ◆ n_global_active_cells()

 virtual types::global_cell_index Triangulation< dim, spacedim >::n_global_active_cells ( ) const
virtualinherited

Return the total number of active cells. For the current class, this is the same as n_active_cells(). However, the function may be overloaded in derived classes (e.g., in parallel::distributed::Triangulation) where it may return a value greater than the number of active cells reported by the triangulation object on the current processor.

Reimplemented in parallel::TriangulationBase< dim, spacedim >.

## ◆ n_global_coarse_cells()

 virtual types::coarse_cell_id Triangulation< dim, spacedim >::n_global_coarse_cells ( ) const
virtualinherited

Return the total number of coarse cells. If the coarse mesh is replicated on each process, this simply returns n_cells(0).

Reimplemented in parallel::TriangulationBase< dim, spacedim >.

## ◆ n_faces()

 unsigned int Triangulation< dim, spacedim >::n_faces ( ) const
inherited

Return the total number of used faces, active or not. In 2D, the result equals n_lines(), in 3D it equals n_quads(), while in 1D it equals the number of used vertices.

## ◆ n_active_faces()

 unsigned int Triangulation< dim, spacedim >::n_active_faces ( ) const
inherited

Return the total number of active faces. In 2D, the result equals n_active_lines(), in 3D it equals n_active_quads(), while in 1D it equals the number of used vertices.

## ◆ n_levels()

 unsigned int Triangulation< dim, spacedim >::n_levels ( ) const
inherited

Return the number of levels in this triangulation.

Note
Internally, triangulations store data in levels, and there may be more levels in this data structure than one may think – for example, imagine a triangulation that we just got by coarsening the highest level so that it was completely depopulated. That level is not removed, since it will most likely be repopulated soon by the next refinement process. As a consequence, if you happened to run through raw cell iterators (which you can't do as a user of this class, but can internally), then the number of objects in the levels hierarchy is larger than the level of the most refined cell plus one. On the other hand, since this is rarely what a user of this class cares about, the function really just returns the level of the most refined active cell plus one. (The plus one is because in a coarse, unrefined mesh, all cells have level zero – making the number of levels equal to one.)

## ◆ n_global_levels()

 virtual unsigned int Triangulation< dim, spacedim >::n_global_levels ( ) const
virtualinherited

Return the number of levels in use. This function is equivalent to n_levels() for a serial Triangulation, but gives the maximum of n_levels() over all processors for a parallel::distributed::Triangulation and therefore can be larger than n_levels().

Reimplemented in parallel::TriangulationBase< dim, spacedim >.

## ◆ has_hanging_nodes()

 virtual bool Triangulation< dim, spacedim >::has_hanging_nodes ( ) const
virtualinherited

Return true if the triangulation has hanging nodes.

The function is made virtual since the result can be interpreted in different ways, depending on whether the triangulation lives only on a single processor, or may be distributed as done in the parallel::distributed::Triangulation class (see there for a description of what the function is supposed to do in the parallel context).

## ◆ n_vertices()

 unsigned int Triangulation< dim, spacedim >::n_vertices ( ) const
inherited

Return the total number of vertices. Some of them may not be used, which usually happens upon coarsening of a triangulation when some vertices are discarded, but we do not want to renumber the remaining ones, leading to holes in the numbers of used vertices. You can get the number of used vertices using n_used_vertices function.

## ◆ get_vertices()

 const std::vector >& Triangulation< dim, spacedim >::get_vertices ( ) const
inherited

Return a constant reference to all the vertices present in this triangulation. Note that not necessarily all vertices in this array are actually used; for example, if you coarsen a mesh, then some vertices are deleted, but their positions in this array are unchanged as the indices of vertices are only allocated once. You can find out about which vertices are actually used by the function get_used_vertices().

## ◆ n_used_vertices()

 unsigned int Triangulation< dim, spacedim >::n_used_vertices ( ) const
inherited

Return the number of vertices that are presently in use, i.e. belong to at least one used element.

## ◆ vertex_used()

 bool Triangulation< dim, spacedim >::vertex_used ( const unsigned int index ) const
inherited

Return true if the vertex with this index is used.

## ◆ get_used_vertices()

 const std::vector& Triangulation< dim, spacedim >::get_used_vertices ( ) const
inherited

Return a constant reference to the array of bools indicating whether an entry in the vertex array is used or not.

 unsigned int Triangulation< dim, spacedim >::max_adjacent_cells ( ) const
inherited

Return the maximum number of cells meeting at a common vertex. Since this number is an invariant under refinement, only the cells on the coarsest level are considered. The operation is thus reasonably fast. The invariance is only true for sufficiently many cells in the coarsest triangulation (e.g. for a single cell one would be returned), so a minimum of four is returned in two dimensions, 8 in three dimensions, etc, which is how many cells meet if the triangulation is refined.

In one space dimension, two is returned.

 unsigned int Triangulation< 1, 1 >::max_adjacent_cells ( ) const
inherited

Definition at line 14374 of file tria.cc.

 unsigned int Triangulation< 1, 2 >::max_adjacent_cells ( ) const
inherited

Definition at line 14383 of file tria.cc.

 unsigned int Triangulation< 1, 3 >::max_adjacent_cells ( ) const
inherited

Definition at line 14391 of file tria.cc.

## ◆ locally_owned_subdomain()

 virtual types::subdomain_id Triangulation< dim, spacedim >::locally_owned_subdomain ( ) const
virtualinherited

This function always returns invalid_subdomain_id but is there for compatibility with the derived parallel::distributed::Triangulation class. For distributed parallel triangulations this function returns the subdomain id of those cells that are owned by the current processor.

Reimplemented in parallel::TriangulationBase< dim, spacedim >.

## ◆ get_triangulation() [1/2]

 Triangulation& Triangulation< dim, spacedim >::get_triangulation ( )
inherited

Return a reference to the current object.

This doesn't seem to be very useful but allows to write code that can access the underlying triangulation for anything that satisfies the MeshType concept (which may not only be a triangulation, but also a DoFHandler, for example).

## ◆ get_triangulation() [2/2]

 const Triangulation& Triangulation< dim, spacedim >::get_triangulation ( ) const
inherited

Return a reference to the current object. This is the const-version of the previous function.

## ◆ n_raw_lines() [1/2]

 unsigned int Triangulation< dim, spacedim >::n_raw_lines ( ) const
inherited

Total number of lines, used or unused.

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).

## ◆ n_raw_lines() [2/2]

 unsigned int Triangulation< dim, spacedim >::n_raw_lines ( const unsigned int level ) const
inherited

Number of lines, used or unused, on the given level.

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).

 unsigned int Triangulation< dim, spacedim >::n_raw_quads ( ) const
inherited

Total number of quads, used or unused.

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).

 unsigned int Triangulation< dim, spacedim >::n_raw_quads ( const unsigned int level ) const
inherited

Number of quads, used or unused, on the given level.

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).

 unsigned int Triangulation< 1, 1 >::n_raw_quads ( const unsigned int ) const
inherited

Definition at line 14048 of file tria.cc.

 unsigned int Triangulation< 1, 2 >::n_raw_quads ( const unsigned int ) const
inherited

Definition at line 14097 of file tria.cc.

 unsigned int Triangulation< 1, 3 >::n_raw_quads ( const unsigned int ) const
inherited

Definition at line 14145 of file tria.cc.

 unsigned int Triangulation< 2, 2 >::n_raw_quads ( const unsigned int level ) const
inherited

Definition at line 14197 of file tria.cc.

 unsigned int Triangulation< 2, 3 >::n_raw_quads ( const unsigned int level ) const
inherited

Definition at line 14207 of file tria.cc.

 unsigned int Triangulation< 3, 3 >::n_raw_quads ( const unsigned int ) const
inherited

Definition at line 14216 of file tria.cc.

 unsigned int Triangulation< 3, 3 >::n_raw_quads ( ) const
inherited

Definition at line 14236 of file tria.cc.

## ◆ n_raw_hexs() [1/5]

 unsigned int Triangulation< dim, spacedim >::n_raw_hexs ( const unsigned int level ) const
inherited

Number of hexs, used or unused, on the given level.

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).

## ◆ n_raw_hexs() [2/5]

 unsigned int Triangulation< 1, 1 >::n_raw_hexs ( const unsigned int ) const
inherited

Definition at line 14056 of file tria.cc.

## ◆ n_raw_hexs() [3/5]

 unsigned int Triangulation< 1, 2 >::n_raw_hexs ( const unsigned int ) const
inherited

Definition at line 14105 of file tria.cc.

## ◆ n_raw_hexs() [4/5]

 unsigned int Triangulation< 1, 3 >::n_raw_hexs ( const unsigned int ) const
inherited

Definition at line 14153 of file tria.cc.

## ◆ n_raw_hexs() [5/5]

 unsigned int Triangulation< 3, 3 >::n_raw_hexs ( const unsigned int level ) const
inherited

Definition at line 14327 of file tria.cc.

## ◆ n_raw_cells()

 unsigned int Triangulation< dim, spacedim >::n_raw_cells ( const unsigned int level ) const
inherited

Number of cells, used or unused, on the given level.

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).

## ◆ n_raw_faces()

 unsigned int Triangulation< dim, spacedim >::n_raw_faces ( ) const
inherited

Return the total number of faces, used or not. In 2d, the result equals n_raw_lines(), in 3d it equals n_raw_quads(), while in 1D it equals the number of vertices.

Note
This function really exports internal information about the triangulation. It shouldn't be used in applications. The function is only part of the public interface of this class because it is used in some of the other classes that build very closely on it (in particular, the DoFHandler class).

## ◆ save()

 void Triangulation< dim, spacedim >::save ( Archive & ar, const unsigned int version ) const
inherited

Write the data of this object to a stream for the purpose of serialization using the BOOST serialization library.

Note
This function does not save all member variables of the current triangulation. Rather, only certain kinds of information are stored. For more information see the general documentation of this class.

 void Triangulation< dim, spacedim >::load ( Archive & ar, const unsigned int version )
inherited

Read the data of this object from a stream for the purpose of serialization using the BOOST serialization library. Throw away the previous content.

Note
This function does not reset all member variables of the current triangulation to the ones of the triangulation that was previously stored to an archive. Rather, only certain kinds of information are loaded. For more information see the general documentation of this class.
This function calls the Triangulation::clear() function and consequently triggers the "clear" signal. After loading all data from the archive, it then triggers the "create" signal. For more information on signals, see the general documentation of this class.

 virtual void Triangulation< dim, spacedim >::add_periodicity ( const std::vector< GridTools::PeriodicFacePair< cell_iterator >> & )
virtualinherited

Declare the (coarse) face pairs given in the argument of this function as periodic. This way it is possible to obtain neighbors across periodic boundaries.

The vector can be filled by the function GridTools::collect_periodic_faces.

For more information on periodic boundary conditions see GridTools::collect_periodic_faces, DoFTools::make_periodicity_constraints and step-45.

Note
Before this function can be used the Triangulation has to be initialized and must not be refined.

## ◆ get_periodic_face_map()

 const std::map< std::pair, std::pair, std::bitset<3> > >& Triangulation< dim, spacedim >::get_periodic_face_map ( ) const
inherited

Return the periodic_face_map.

## ◆ get_reference_cells()

 const std::vector& Triangulation< dim, spacedim >::get_reference_cells ( ) const
inherited

Return vector filled with the used reference-cell types of this triangulation.

## ◆ all_reference_cells_are_hyper_cube()

 bool Triangulation< dim, spacedim >::all_reference_cells_are_hyper_cube ( ) const
inherited

Indicate if the triangulation only consists of hypercube-like cells, i.e., lines, quadrilaterals, or hexahedra.

## ◆ all_reference_cells_are_simplex()

 bool Triangulation< dim, spacedim >::all_reference_cells_are_simplex ( ) const
inherited

Indicate if the triangulation only consists of simplex-like cells, i.e., lines, triangles, or tetrahedra.

## ◆ is_mixed_mesh()

 bool Triangulation< dim, spacedim >::is_mixed_mesh ( ) const
inherited

Indicate if the triangulation consists of different cell types (mix of simplices, hypercubes, ...) or different face types, as in the case of pyramids or wedges..

## ◆ serialize()

 void Triangulation< dim, spacedim >::serialize ( Archive & archive, const unsigned int version )
inherited

Write and read the data of this object from a stream for the purpose of serialization. using the BOOST serialization library.

## ◆ ExcInvalidLevel()

 static ::ExceptionBase& Triangulation< dim, spacedim >::ExcInvalidLevel ( int arg1, int arg2 )
staticinherited

Exception

Note
The message that will be printed by this exception reads:
<< "You are requesting information from refinement level " << arg1 << " of a triangulation, but this triangulation only has " << arg2 << " refinement levels. The given level " << arg1 << " must be *less* than " << arg2 << '.'

## ◆ ExcTriangulationNotEmpty()

 static ::ExceptionBase& Triangulation< dim, spacedim >::ExcTriangulationNotEmpty ( int arg1, int arg2 )
staticinherited

The function raising this exception can only operate on an empty Triangulation, i.e., a Triangulation without grid cells.

Note
The message that will be printed by this exception reads:
<< "You are trying to perform an operation on a triangulation " << "that is only allowed if the triangulation is currently empty. " << "However, it currently stores " << arg1 << " vertices and has " << "cells on " << arg2 << " levels."

 static ::ExceptionBase& Triangulation< dim, spacedim >::ExcGridReadError ( )
staticinherited

Trying to re-read a grid, an error occurred.

## ◆ ExcFacesHaveNoLevel()

 static ::ExceptionBase& Triangulation< dim, spacedim >::ExcFacesHaveNoLevel ( )
staticinherited

Exception

## ◆ ExcEmptyLevel()

 static ::ExceptionBase& Triangulation< dim, spacedim >::ExcEmptyLevel ( int arg1 )
staticinherited

The triangulation level you accessed is empty.

Note
The message that will be printed by this exception reads:
<< "You tried to do something on level " << arg1 << ", but this level is empty."

## ◆ ExcNonOrientableTriangulation()

 static ::ExceptionBase& Triangulation< dim, spacedim >::ExcNonOrientableTriangulation ( )
staticinherited

Exception

## ◆ ExcBoundaryIdNotFound()

 static ::ExceptionBase& Triangulation< dim, spacedim >::ExcBoundaryIdNotFound ( types::boundary_id arg1 )
staticinherited

Exception

Note
The message that will be printed by this exception reads:
<< "The given boundary_id " << arg1 << " is not defined in this Triangulation!"

## ◆ ExcInconsistentCoarseningFlags()

 static ::ExceptionBase& Triangulation< dim, spacedim >::ExcInconsistentCoarseningFlags ( )
staticinherited

Exception

Note
The message that will be printed by this exception reads:
"A cell is flagged for coarsening, but either not all of its siblings " "are active or flagged for coarsening as well. Please clean up all " "coarsen flags on your triangulation via " "Triangulation::prepare_coarsening_and_refinement() beforehand!"

## ◆ write_bool_vector()

 static void Triangulation< dim, spacedim >::write_bool_vector ( const unsigned int magic_number1, const std::vector< bool > & v, const unsigned int magic_number2, std::ostream & out )
staticprotectedinherited

Write a bool vector to the given stream, writing a pre- and a postfix magic number. The vector is written in an almost binary format, i.e. the bool flags are packed but the data is written as ASCII text.

The flags are stored in a binary format: for each true, a 1 bit is stored, a 0 bit otherwise. The bits are stored as unsigned char, thus avoiding endianness. They are written to out in plain text, thus amounting to 3.6 bits in the output per bits in the input on the average. Other information (magic numbers and number of elements of the input vector) is stored as plain text as well. The format should therefore be interplatform compatible.

 static void Triangulation< dim, spacedim >::read_bool_vector ( const unsigned int magic_number1, std::vector< bool > & v, const unsigned int magic_number2, std::istream & in )
staticprotectedinherited

Re-read a vector of bools previously written by write_bool_vector and compare with the magic numbers.

## ◆ update_periodic_face_map()

 void Triangulation< dim, spacedim >::update_periodic_face_map ( )
protectedinherited

Recreate information about periodic neighbors from periodic_face_pairs_level_0.

## ◆ update_reference_cells()

 virtual void Triangulation< dim, spacedim >::update_reference_cells ( )
protectedvirtualinherited

Update the internal reference_cells vector.

Reimplemented in parallel::TriangulationBase< dim, spacedim >.

## ◆ begin_raw()

 raw_cell_iterator Triangulation< dim, spacedim >::begin_raw ( const unsigned int level = 0 ) const
privateinherited

Iterator to the first cell, used or not, on level level. If a level has no cells, a past-the-end iterator is returned.

## ◆ end_raw()

 raw_cell_iterator Triangulation< dim, spacedim >::end_raw ( const unsigned int level ) const
privateinherited

Return a raw iterator which is the first iterator not on level. If level is the last level, then this returns end().

## ◆ begin_raw_line()

 raw_line_iterator Triangulation< dim, spacedim >::begin_raw_line ( const unsigned int level = 0 ) const
privateinherited

Iterator to the first line, used or not, on level level. If a level has no lines, a past-the-end iterator is returned. If lines are no cells, i.e. for dim>1 no level argument must be given. The same applies for all the other functions above, of course.

## ◆ begin_line()

 line_iterator Triangulation< dim, spacedim >::begin_line ( const unsigned int level = 0 ) const
privateinherited

Iterator to the first used line on level level.

Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

## ◆ begin_active_line()

 active_line_iterator Triangulation< dim, spacedim >::begin_active_line ( const unsigned int level = 0 ) const
privateinherited

Iterator to the first active line on level level.

Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

## ◆ end_line()

 line_iterator Triangulation< dim, spacedim >::end_line ( ) const
privateinherited

Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.

 raw_quad_iterator Triangulation< dim, spacedim >::begin_raw_quad ( const unsigned int level = 0 ) const
privateinherited

Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for $$dim>2$$ no level argument must be given.

Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

 quad_iterator Triangulation< dim, spacedim >::begin_quad ( const unsigned int level = 0 ) const
privateinherited

Iterator to the first used quad on level level.

Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

 active_quad_iterator Triangulation< dim, spacedim >::begin_active_quad ( const unsigned int level = 0 ) const
privateinherited

Iterator to the first active quad on level level.

Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

privateinherited

Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.

## ◆ begin_raw_hex()

 raw_hex_iterator Triangulation< dim, spacedim >::begin_raw_hex ( const unsigned int level = 0 ) const
privateinherited

Iterator to the first hex, used or not, on level level. If a level has no hexes, a past-the-end iterator is returned.

Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

## ◆ begin_hex()

 hex_iterator Triangulation< dim, spacedim >::begin_hex ( const unsigned int level = 0 ) const
privateinherited

Iterator to the first used hex on level level.

Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

## ◆ begin_active_hex()

 active_hex_iterator Triangulation< dim, spacedim >::begin_active_hex ( const unsigned int level = 0 ) const
privateinherited

Iterator to the first active hex on level level.

Note
The given level argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level argument is accepted if it is less than what the n_global_levels() function returns. If the given level is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.

## ◆ end_hex()

 hex_iterator Triangulation< dim, spacedim >::end_hex ( ) const
privateinherited

Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.

## ◆ clear_despite_subscriptions()

 void Triangulation< dim, spacedim >::clear_despite_subscriptions ( )
privateinherited

The (public) function clear() will only work when the triangulation is not subscribed to by other users. The clear_despite_subscriptions() function now allows the triangulation being cleared even when there are subscriptions.

Make sure, you know what you do, when calling this function, as its use is reasonable in very rare cases, only. For example, when the subscriptions were for the initially empty Triangulation and the Triangulation object wants to release its memory before throwing an assertion due to input errors (e.g. in the create_triangulation() function).

## ◆ reset_policy()

 void Triangulation< dim, spacedim >::reset_policy ( )
privateinherited

Reset triangulation policy.

## ◆ reset_active_cell_indices()

 void Triangulation< dim, spacedim >::reset_active_cell_indices ( )
privateinherited

For all cells, set the active cell indices so that active cells know the how many-th active cell they are, and all other cells have an invalid value. This function is called after mesh creation, refinement, and serialization.

## ◆ reset_global_cell_indices()

 void Triangulation< dim, spacedim >::reset_global_cell_indices ( )
privateinherited

Reset global cell ids and global level cell ids.

## ◆ reset_cell_vertex_indices_cache()

 void Triangulation< dim, spacedim >::reset_cell_vertex_indices_cache ( )
privateinherited

Reset cache for the cells' vertex indices.

## ◆ execute_refinement()

 DistortedCellList Triangulation< dim, spacedim >::execute_refinement ( )
privateinherited

Refine all cells on all levels which were previously flagged for refinement.

Note, that this function uses the line->user_flags for dim=2,3 and the quad->user_flags for dim=3.

The function returns a list of cells that have produced children that satisfy the criteria of distorted cells if the check_for_distorted_cells flag was specified upon creation of this object, at

## ◆ execute_coarsening()

 void Triangulation< dim, spacedim >::execute_coarsening ( )
privateinherited

Coarsen all cells which were flagged for coarsening, or rather: delete all children of those cells of which all child cells are flagged for coarsening and several other constraints hold (see the general doc of this class).

## ◆ fix_coarsen_flags()

 void Triangulation< dim, spacedim >::fix_coarsen_flags ( )
privateinherited

Make sure that either all or none of the children of a cell are tagged for coarsening.

## ◆ coarse_cell_id_to_coarse_cell_index()

 virtual unsigned int Triangulation< dim, spacedim >::coarse_cell_id_to_coarse_cell_index ( const types::coarse_cell_id coarse_cell_id ) const
privatevirtualinherited

Translate the unique id of a coarse cell to its index. See the glossary entry on coarse cell IDs for more information.

Note
For serial and shared triangulation both id and index are the same. For distributed triangulations setting both might differ, since the id might correspond to a global id and the index to a local id.
Parameters
 coarse_cell_id Unique id of the coarse cell.
Returns
Index of the coarse cell within the current triangulation.

## ◆ coarse_cell_index_to_coarse_cell_id()

 virtual types::coarse_cell_id Triangulation< dim, spacedim >::coarse_cell_index_to_coarse_cell_id ( const unsigned int coarse_cell_index ) const
privatevirtualinherited

Translate the index of coarse cell to its unique id. See the glossary entry on coarse cell IDs for more information.

Note
See the note of the method coarse_cell_id_to_coarse_cell_index().
Parameters
 coarse_cell_index Index of the coarse cell.
Returns
Id of the coarse cell.

## ◆ subscribe()

 void Subscriptor::subscribe ( std::atomic< bool > *const validity, const std::string & identifier = "" ) const
inherited

Subscribes a user of the object by storing the pointer validity. The subscriber may be identified by text supplied as identifier.

Definition at line 136 of file subscriptor.cc.

## ◆ unsubscribe()

 void Subscriptor::unsubscribe ( std::atomic< bool > *const validity, const std::string & identifier = "" ) const
inherited

Unsubscribes a user from the object.

Note
The identifier and the validity pointer must be the same as the one supplied to subscribe().

Definition at line 156 of file subscriptor.cc.

## ◆ n_subscriptions()

 unsigned int Subscriptor::n_subscriptions ( ) const
inlineinherited

Return the present number of subscriptions to this object. This allows to use this class for reference counted lifetime determination where the last one to unsubscribe also deletes the object.

Definition at line 300 of file subscriptor.h.

## ◆ list_subscribers() [1/2]

template<typename StreamType >
 void Subscriptor::list_subscribers ( StreamType & stream ) const
inlineinherited

List the subscribers to the input stream.

Definition at line 317 of file subscriptor.h.

## ◆ list_subscribers() [2/2]

 void Subscriptor::list_subscribers ( ) const
inherited

List the subscribers to deallog.

Definition at line 204 of file subscriptor.cc.

## ◆ check_no_subscribers()

 void Subscriptor::check_no_subscribers ( ) const
privatenoexceptinherited

Check that there are no objects subscribing to this object. If this check passes then it is safe to destroy the current object. It this check fails then this function will either abort or print an error message to deallog (by using the AssertNothrow mechanism), but will not throw an exception.

Note
Since this function is just a consistency check it does nothing in release mode.
If this function is called when there is an uncaught exception then, rather than aborting, this function prints an error message to the standard error stream and returns.

Definition at line 53 of file subscriptor.cc.

## ◆ dimension

template<int dim, int spacedim>
 const unsigned int PersistentTriangulation< dim, spacedim >::dimension = dim
staticconstexpr

Make the dimension available in function templates.

Definition at line 114 of file persistent_tria.h.

## ◆ spacedimension

template<int dim, int spacedim>
 const unsigned int PersistentTriangulation< dim, spacedim >::spacedimension = spacedim
static

Definition at line 115 of file persistent_tria.h.

## ◆ coarse_grid

template<int dim, int spacedim = dim>
 SmartPointer, PersistentTriangulation > PersistentTriangulation< dim, spacedim >::coarse_grid
private

This grid shall be used as coarse grid.

Definition at line 269 of file persistent_tria.h.

## ◆ refine_flags

template<int dim, int spacedim = dim>
 std::vector > PersistentTriangulation< dim, spacedim >::refine_flags
private

Vectors holding the refinement and coarsening flags of the different sweeps on this time level. The vectors therefore hold the history of the grid.

Definition at line 276 of file persistent_tria.h.

## ◆ coarsen_flags

template<int dim, int spacedim = dim>
 std::vector > PersistentTriangulation< dim, spacedim >::coarsen_flags
private

Definition at line 281 of file persistent_tria.h.

## ◆ space_dimension

 constexpr unsigned int Triangulation< dim, spacedim >::space_dimension
staticconstexprinherited

Make the space-dimension available in function templates.

Definition at line 1560 of file tria.h.

## ◆ signals

 Signals Triangulation< dim, spacedim >::signals
mutableinherited

Signals for the various actions that a triangulation can do to itself.

Definition at line 2477 of file tria.h.

## ◆ smooth_grid

 MeshSmoothing Triangulation< dim, spacedim >::smooth_grid
protectedinherited

Definition at line 3729 of file tria.h.

## ◆ reference_cells

 std::vector Triangulation< dim, spacedim >::reference_cells
protectedinherited

Vector caching all reference-cell types of the given triangulation (also in the distributed case).

Definition at line 3735 of file tria.h.

## ◆ policy

 std::unique_ptr< ::internal::TriangulationImplementation::Policy > Triangulation< dim, spacedim >::policy
privateinherited

Policy with the Triangulation-specific tasks related to creation, refinement, and coarsening.

Definition at line 3787 of file tria.h.

## ◆ periodic_face_pairs_level_0

 std::vector > Triangulation< dim, spacedim >::periodic_face_pairs_level_0
privateinherited

If add_periodicity() is called, this variable stores the given periodic face pairs on level 0 for later access during the identification of ghost cells for the multigrid hierarchy and for setting up the periodic_face_map.

Definition at line 3796 of file tria.h.

## ◆ periodic_face_map

 std::map, std::pair, std::bitset<3> > > Triangulation< dim, spacedim >::periodic_face_map
privateinherited

If add_periodicity() is called, this variable stores the active periodic face pairs.

Definition at line 3804 of file tria.h.

## ◆ levels

 std::vector< std::unique_ptr<::internal::TriangulationImplementation::TriaLevel> > Triangulation< dim, spacedim >::levels
privateinherited

Array of pointers pointing to the objects storing the cell data on the different levels.

Definition at line 4182 of file tria.h.

## ◆ faces

 std::unique_ptr<::internal::TriangulationImplementation::TriaFaces> Triangulation< dim, spacedim >::faces
privateinherited

Pointer to the faces of the triangulation. In 1d this contains nothing, in 2D it contains data concerning lines and in 3D quads and lines. All of these have no level and are therefore treated separately.

Definition at line 4190 of file tria.h.

## ◆ vertices

 std::vector > Triangulation< dim, spacedim >::vertices
privateinherited

Array of the vertices of this triangulation.

Definition at line 4196 of file tria.h.

## ◆ vertices_used

 std::vector Triangulation< dim, spacedim >::vertices_used
privateinherited

Array storing a bit-pattern which vertices are used.

Definition at line 4201 of file tria.h.

## ◆ manifolds

 std::map > > Triangulation< dim, spacedim >::manifolds
privateinherited

Collection of manifold objects. We store only objects, which are not of type FlatManifold.

Definition at line 4208 of file tria.h.

## ◆ anisotropic_refinement

 bool Triangulation< dim, spacedim >::anisotropic_refinement
privateinherited

Flag indicating whether anisotropic refinement took place.

Definition at line 4213 of file tria.h.

## ◆ check_for_distorted_cells

 const bool Triangulation< dim, spacedim >::check_for_distorted_cells
privateinherited

A flag that determines whether we are to check for distorted cells upon creation and refinement of a mesh.

Definition at line 4220 of file tria.h.

## ◆ number_cache

 ::internal::TriangulationImplementation::NumberCache Triangulation< dim, spacedim >::number_cache
privateinherited

Cache to hold the numbers of lines, quads, hexes, etc. These numbers are set at the end of the refinement and coarsening functions and enable faster access later on. In the old days, whenever one wanted to access one of these numbers, one had to perform a loop over all lines, e.g., and count the elements until we hit the end iterator. This is time consuming and since access to the number of lines etc is a rather frequent operation, this was not an optimal solution.

Definition at line 4231 of file tria.h.

## ◆ vertex_to_boundary_id_map_1d

 std::unique_ptr > Triangulation< dim, spacedim >::vertex_to_boundary_id_map_1d
privateinherited

A map that relates the number of a boundary vertex to the boundary indicator. This field is only used in 1d. We have this field because we store boundary indicator information with faces in 2d and higher where we have space in the structures that store data for faces, but in 1d there is no such space for faces.

The field is declared as a pointer for a rather mundane reason: all other fields of this class that can be modified by the TriaAccessor hierarchy are pointers, and so these accessor classes store a const pointer to the triangulation. We could no longer do so for TriaAccessor<0,1,spacedim> if this field (that can be modified by TriaAccessor::set_boundary_id) were not a pointer.

Definition at line 4248 of file tria.h.

## ◆ vertex_to_manifold_id_map_1d

 std::unique_ptr > Triangulation< dim, spacedim >::vertex_to_manifold_id_map_1d
privateinherited

A map that relates the number of a boundary vertex to the manifold indicator. This field is only used in 1d. We have this field because we store manifold indicator information with faces in 2d and higher where we have space in the structures that store data for faces, but in 1d there is no such space for faces.

Note
Manifold objects are pretty useless for points since they are neither refined nor are their interiors mapped. We nevertheless allow storing manifold ids for points to be consistent in dimension-independent programs.

The field is declared as a pointer for a rather mundane reason: all other fields of this class that can be modified by the TriaAccessor hierarchy are pointers, and so these accessor classes store a const pointer to the triangulation. We could no longer do so for TriaAccessor<0,1,spacedim> if this field (that can be modified by TriaAccessor::set_manifold_id) were not a pointer.

Definition at line 4271 of file tria.h.

## ◆ counter

 std::atomic Subscriptor::counter
mutableprivateinherited

Store the number of objects which subscribed to this object. Initially, this number is zero, and upon destruction it shall be zero again (i.e. all objects which subscribed should have unsubscribed again).

The creator (and owner) of an object is counted in the map below if HE manages to supply identification.

We use the mutable keyword in order to allow subscription to constant objects also.

This counter may be read from and written to concurrently in multithreaded code: hence we use the std::atomic class template.

Definition at line 219 of file subscriptor.h.

## ◆ counter_map

 std::map Subscriptor::counter_map
mutableprivateinherited

In this map, we count subscriptions for each different identification string supplied to subscribe().

Definition at line 225 of file subscriptor.h.

## ◆ validity_pointers

 std::vector *> Subscriptor::validity_pointers
mutableprivateinherited

In this vector, we store pointers to the validity bool in the SmartPointer objects that subscribe to this class.

Definition at line 241 of file subscriptor.h.

## ◆ object_info

 const std::type_info* Subscriptor::object_info
mutableprivateinherited

Pointer to the typeinfo object of this object, from which we can later deduce the class name. Since this information on the derived class is neither available in the destructor, nor in the constructor, we obtain it in between and store it here.

Definition at line 249 of file subscriptor.h.

## ◆ mutex

 std::mutex Subscriptor::mutex
staticprivateinherited

A mutex used to ensure data consistency when printing out the list of subscribers.

Definition at line 271 of file subscriptor.h.

The documentation for this class was generated from the following files: