Reference documentation for deal.II version 9.6.0
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Loading...
Searching...
No Matches
parallel::fullydistributed::Triangulation< dim, spacedim > Class Template Reference

#include <deal.II/distributed/fully_distributed_tria.h>

Inheritance diagram for parallel::fullydistributed::Triangulation< dim, spacedim >:

Public Types

using cell_iterator
 
using active_cell_iterator
 
enum  MeshSmoothing
 
using level_cell_iterator
 
using face_iterator
 
using active_face_iterator
 
using vertex_iterator
 
using active_vertex_iterator
 
using line_iterator
 
using active_line_iterator
 
using quad_iterator
 
using active_quad_iterator
 
using hex_iterator
 
using active_hex_iterator
 
using CellStatus
 

Public Member Functions

 Triangulation (const MPI_Comm mpi_communicator)
 
virtual ~Triangulation ()=default
 
void create_triangulation (const TriangulationDescription::Description< dim, spacedim > &construction_data) override
 
virtual void create_triangulation (const std::vector< Point< spacedim > > &vertices, const std::vector<::CellData< dim > > &cells, const SubCellData &subcelldata) override
 
void copy_triangulation (const ::Triangulation< dim, spacedim > &other_tria) override
 
void set_partitioner (const std::function< void(::Triangulation< dim, spacedim > &, const unsigned int)> &partitioner, const TriangulationDescription::Settings &settings)
 
void set_partitioner (const RepartitioningPolicyTools::Base< dim, spacedim > &partitioner, const TriangulationDescription::Settings &settings)
 
void repartition ()
 
virtual void execute_coarsening_and_refinement () override
 
virtual bool prepare_coarsening_and_refinement () override
 
virtual std::size_t memory_consumption () const override
 
virtual bool is_multilevel_hierarchy_constructed () const override
 
virtual void save (const std::string &filename) const override
 
virtual void load (const std::string &filename) override
 
virtual void load (const std::string &filename, const bool autopartition) override
 
virtual bool has_hanging_nodes () const override
 
void load (Archive &ar, const unsigned int version)
 
virtual MPI_Comm get_communicator () const override
 
virtual void copy_triangulation (const Triangulation< dim, spacedim > &other_tria)
 
unsigned int n_locally_owned_active_cells () const
 
virtual types::global_cell_index n_global_active_cells () const override
 
virtual unsigned int n_global_levels () const override
 
types::subdomain_id locally_owned_subdomain () const override
 
const std::set< types::subdomain_id > & ghost_owners () const
 
const std::set< types::subdomain_id > & level_ghost_owners () const
 
std::weak_ptr< const Utilities::MPI::Partitionerglobal_active_cell_index_partitioner () const override
 
std::weak_ptr< const Utilities::MPI::Partitionerglobal_level_cell_index_partitioner (const unsigned int level) const override
 
virtual std::vector< types::boundary_idget_boundary_ids () const override
 
virtual std::vector< types::manifold_idget_manifold_ids () const override
 
void communicate_locally_moved_vertices (const std::vector< bool > &vertex_locally_moved)
 
virtual types::coarse_cell_id n_global_coarse_cells () const override
 
virtual void clear () override
 
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 void create_triangulation (const std::vector< Point< spacedim > > &vertices, const std::vector< CellData< dim > > &cells, const SubCellData &subcelldata)
 
void flip_all_direction_flags ()
 
unsigned int n_quads () const
 
unsigned int n_quads (const unsigned int) const
 
unsigned int n_quads () const
 
unsigned int n_quads (const unsigned int) const
 
unsigned int n_quads () 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 n_active_quads (const unsigned int) const
 
unsigned int n_active_quads () const
 
unsigned int n_active_quads (const unsigned int) const
 
unsigned int n_active_quads () 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 max_adjacent_cells () const
 
unsigned int max_adjacent_cells () const
 
unsigned int max_adjacent_cells () 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_quads () 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
 
void save (Archive &ar, const unsigned int version) const
 
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 >, unsigned char > > & 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)
 
Mesh refinement
void set_all_refine_flags ()
 
void refine_global (const unsigned int times=1)
 
void coarsen_global (const unsigned int times=1)
 
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 (std::istream &in)
 
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 (std::istream &out)
 
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 (std::istream &in)
 
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 (std::istream &in)
 
void load_user_flags_line (const std::vector< bool > &v)
 
void clear_user_flags_quad ()
 
void save_user_flags_quad (std::ostream &out) const
 
void save_user_flags_quad (std::vector< bool > &v) const
 
void load_user_flags_quad (std::istream &in)
 
void load_user_flags_quad (const std::vector< bool > &v)
 
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 (std::istream &in)
 
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 load_user_indices_quad (const std::vector< unsigned int > &v)
 
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 load_user_pointers_quad (const std::vector< void * > &v)
 
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
 
bool contains_cell (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
 
Information about the triangulation
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 n_quads (const unsigned int level) const
 
unsigned int n_active_quads () 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
 
unsigned int n_faces () const
 
unsigned int n_active_faces () const
 
unsigned int n_levels () 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
 
unsigned int max_adjacent_cells () 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 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
 
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 ::ExceptionBaseExcInUse (int arg1, std::string arg2, std::string arg3)
 
static ::ExceptionBaseExcNoSubscriber (std::string arg1, std::string arg2)
 
Exceptions
static ::ExceptionBaseExcInvalidLevel (int arg1, int arg2)
 
static ::ExceptionBaseExcTriangulationNotEmpty (int arg1, int arg2)
 
static ::ExceptionBaseExcGridReadError ()
 
static ::ExceptionBaseExcFacesHaveNoLevel ()
 
static ::ExceptionBaseExcEmptyLevel (int arg1)
 
static ::ExceptionBaseExcBoundaryIdNotFound (types::boundary_id arg1)
 
static ::ExceptionBaseExcInconsistentCoarseningFlags ()
 

Public Attributes

Keeping up with what happens to a triangulation
Signals signals
 

Static Public Attributes

static constexpr unsigned int dimension
 
static constexpr unsigned int space_dimension
 
static constexpr auto CELL_PERSIST
 
static constexpr auto CELL_REFINE
 
static constexpr auto CELL_COARSEN
 
static constexpr auto CELL_INVALID
 

Protected Member Functions

void update_reference_cells () override
 
void reset_global_cell_indices ()
 
void update_periodic_face_map ()
 

Static Protected Member Functions

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)
 

Protected Attributes

const MPI_Comm mpi_communicator
 
types::subdomain_id my_subdomain
 
types::subdomain_id n_subdomains
 
NumberCache number_cache
 
MeshSmoothing smooth_grid
 
std::vector< ReferenceCellreference_cells
 

Private Types

using IteratorSelector
 
using raw_cell_iterator
 
using raw_face_iterator
 
using raw_vertex_iterator
 
using raw_line_iterator
 
using raw_quad_iterator
 
using raw_hex_iterator
 
using map_value_type = decltype(counter_map)::value_type
 
using map_iterator = decltype(counter_map)::iterator
 

Private Member Functions

virtual unsigned int coarse_cell_id_to_coarse_cell_index (const types::coarse_cell_id coarse_cell_id) const override
 
virtual types::coarse_cell_id coarse_cell_index_to_coarse_cell_id (const unsigned int coarse_cell_index) const override
 
void update_cell_relations ()
 
virtual void update_number_cache () override
 
void clear_despite_subscriptions ()
 
void reset_policy ()
 
void reset_active_cell_indices ()
 
void reset_cell_vertex_indices_cache ()
 
DistortedCellList execute_refinement ()
 
void execute_coarsening ()
 
void fix_coarsen_flags ()
 
void check_no_subscribers () const noexcept
 
Cell iterator functions for internal use
raw_cell_iterator begin_raw (const unsigned int level=0) const
 
raw_cell_iterator end_raw (const unsigned int level) const
 
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
raw_quad_iterator begin_raw_quad (const unsigned int level=0) const
 
quad_iterator begin_quad (const unsigned int level=0) const
 
active_quad_iterator begin_active_quad (const unsigned int level=0) const
 
quad_iterator end_quad () const
 
Hex iterator functions for internal use
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
 

Private Attributes

TriangulationDescription::Settings settings
 
std::function< void(::Triangulation< dim, spacedim > &, const unsigned int)> partitioner
 
SmartPointer< const RepartitioningPolicyTools::Base< dim, spacedim > > partitioner_distributed
 
std::vector< std::pair< types::coarse_cell_id, unsigned int > > coarse_cell_id_to_coarse_cell_index_vector
 
std::vector< types::coarse_cell_idcoarse_cell_index_to_coarse_cell_id_vector
 
bool currently_processing_create_triangulation_for_internal_usage
 
bool currently_processing_prepare_coarsening_and_refinement_for_internal_usage
 
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 >, unsigned char > > periodic_face_map
 
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
 
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
 
std::atomic< unsigned intcounter
 
std::map< std::string, unsigned intcounter_map
 
std::vector< std::atomic< bool > * > validity_pointers
 
const std::type_info * object_info
 

Static Private Attributes

static std::mutex mutex
 

Serialization facilities.

unsigned int register_data_attach (const std::function< std::vector< char >(const cell_iterator &, const ::CellStatus)> &pack_callback, const bool returns_variable_size_data)
 
void notify_ready_to_unpack (const unsigned int handle, const std::function< void(const cell_iterator &, const ::CellStatus, const boost::iterator_range< std::vector< char >::const_iterator > &)> &unpack_callback)
 
std::vector< typename internal::CellAttachedDataSerializer< dim, spacedim >::cell_relation_t > local_cell_relations
 
internal::CellAttachedDataSerializer< dim, spacedim > data_serializer
 
void save_attached_data (const unsigned int global_first_cell, const unsigned int global_num_cells, const std::string &file_basename) const
 
void load_attached_data (const unsigned int global_first_cell, const unsigned int global_num_cells, const unsigned int local_num_cells, const std::string &file_basename, const unsigned int n_attached_deserialize_fixed, const unsigned int n_attached_deserialize_variable)
 
internal::CellAttachedData< dim, spacedim > cell_attached_data
 

Detailed Description

template<int dim, int spacedim = dim>
class parallel::fullydistributed::Triangulation< dim, spacedim >

A distributed triangulation with a distributed coarse grid.

The motivation for parallel::fullydistributed::Triangulation has its origins in the following observations about complex geometries and/or about given meshes created by an external mesh generator. We regard complex geometries as geometries that can be meshed only with a non-negligible number of coarse cells (>10,000):

  • storing the coarse-grid information on every process is too expensive from a memory point of view (as done by parallel::distributed::Triangulation). Normally, a process only needs a small section of the global triangulation, i.e., a small section of the coarse grid such that a partitioning of the coarse grid is indeed essential. The cells stored on each process consist of the locally owned cells and the ghost cells.
  • the distribution of the active cells - on the finest level - among all processes by simply partitioning a space-filling curve might not lead to an optimal result for triangulations that originate from large coarse grids: e.g. partitions that belong to the same process might be discontinuous, leading to increased communication (within a node and beyond). Graph-based partitioning algorithms might be a sound alternative to the space filling curve used by parallel::distributed::Triangulation.

To be able to construct a fully partitioned triangulation that distributes the coarse grid and gives flexibility regarding partitioning, the following ingredients are required:

  • a locally relevant coarse-grid triangulation (vertices, cell definition; including a layer of ghost cells)
  • a mapping of the locally relevant coarse-grid triangulation into the global coarse-grid triangulation
  • information about which cell should be refined as well as information regarding the subdomain_id, the level_subdomain_id, manifold_id, and boundary_id of each cell.

The ingredients listed above are bundled in the struct TriangulationDescription::Description. The user has to fill this data structure - in a pre-processing step - before actually creating the triangulation. Predefined functions to create TriangulationDescription::Description can be found in the namespace TriangulationDescription::Utilities.

Once the TriangulationDescription::Description construction_data has been constructed, the triangulation tria can be created by calling tria.create_triangulation(construction_data);.

Note
This triangulation supports: 1D/2d/3d, hanging nodes, geometric multigrid, and periodicity.
You can create a triangulation with hanging nodes and multigrid levels with create_triangulation(). However, once it has been created, it cannot be altered anymore, i.e. you cannot coarsen or refine afterwards.
Currently only simple periodicity conditions (i.e. without offsets and rotation matrices - see also the documentation of GridTools::collect_periodic_faces()) are supported.
This class, function, or variable is a template, and it can only be instantiated if the following condition is true: If your compiler supports the C++20 standard, then this constraint will be enforced by a C++20 requires clause.

Definition at line 110 of file fully_distributed_tria.h.

Member Typedef Documentation

◆ cell_iterator

template<int dim, int spacedim = dim>
using parallel::fullydistributed::Triangulation< dim, spacedim >::cell_iterator
Initial value:
typename ::Triangulation<dim, spacedim>::cell_iterator

Definition at line 114 of file fully_distributed_tria.h.

◆ active_cell_iterator

template<int dim, int spacedim = dim>
using parallel::fullydistributed::Triangulation< dim, spacedim >::active_cell_iterator
Initial value:
typename ::Triangulation<dim, spacedim>::active_cell_iterator

Definition at line 117 of file fully_distributed_tria.h.

◆ IteratorSelector

using Triangulation< dim, spacedim >::IteratorSelector
privateinherited

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

Definition at line 1329 of file tria.h.

◆ level_cell_iterator

using Triangulation< dim, spacedim >::level_cell_iterator
inherited

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

Definition at line 1562 of file tria.h.

◆ face_iterator

using Triangulation< dim, spacedim >::face_iterator
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 topic.

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 1595 of file tria.h.

◆ active_face_iterator

using Triangulation< dim, spacedim >::active_face_iterator
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 1608 of file tria.h.

◆ vertex_iterator

using Triangulation< dim, spacedim >::vertex_iterator
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 topic.

Definition at line 1619 of file tria.h.

◆ active_vertex_iterator

using Triangulation< dim, spacedim >::active_vertex_iterator
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 topic.

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 1633 of file tria.h.

◆ line_iterator

using Triangulation< dim, spacedim >::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 1643 of file tria.h.

◆ active_line_iterator

using Triangulation< dim, spacedim >::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 1658 of file tria.h.

◆ quad_iterator

using Triangulation< dim, spacedim >::quad_iterator
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 1667 of file tria.h.

◆ active_quad_iterator

using Triangulation< dim, spacedim >::active_quad_iterator
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 1682 of file tria.h.

◆ hex_iterator

using Triangulation< dim, spacedim >::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 1691 of file tria.h.

◆ active_hex_iterator

using Triangulation< dim, spacedim >::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 1702 of file tria.h.

◆ CellStatus

using Triangulation< dim, spacedim >::CellStatus
inherited

The elements of this enum are used to inform functions how a specific cell is going to change. This is used in the course of transferring data from one mesh to a refined or coarsened version of the mesh, for example. Note that this may me different than the refine_flag() and coarsen_flag() set on a cell, for example in parallel calculations, because of refinement constraints that an individual machine does not see.

Deprecated
This is an alias for backward compatibility. Use CellStatus directly.

Definition at line 2228 of file tria.h.

◆ raw_cell_iterator

using Triangulation< dim, spacedim >::raw_cell_iterator
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 4091 of file tria.h.

◆ raw_face_iterator

using Triangulation< dim, spacedim >::raw_face_iterator
privateinherited

Definition at line 4092 of file tria.h.

◆ raw_vertex_iterator

using Triangulation< dim, spacedim >::raw_vertex_iterator
privateinherited

Definition at line 4094 of file tria.h.

◆ raw_line_iterator

using Triangulation< dim, spacedim >::raw_line_iterator
privateinherited

Definition at line 4096 of file tria.h.

◆ raw_quad_iterator

using Triangulation< dim, spacedim >::raw_quad_iterator
privateinherited

Definition at line 4097 of file tria.h.

◆ raw_hex_iterator

using Triangulation< dim, spacedim >::raw_hex_iterator
privateinherited

Definition at line 4098 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 229 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 234 of file subscriptor.h.

Member Enumeration Documentation

◆ MeshSmoothing

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

Definition at line 1337 of file tria.h.

Constructor & Destructor Documentation

◆ Triangulation()

template<int dim, int spacedim>
Triangulation< dim, spacedim >::Triangulation ( const MPI_Comm mpi_communicator)
explicit

Constructor.

Parameters
mpi_communicatorThe MPI communicator to be used for the triangulation.

Definition at line 47 of file fully_distributed_tria.cc.

◆ ~Triangulation()

template<int dim, int spacedim = dim>
virtual parallel::fullydistributed::Triangulation< dim, spacedim >::~Triangulation ( )
virtualdefault

Destructor.

Reimplemented from Triangulation< dim, spacedim >.

Member Function Documentation

◆ create_triangulation() [1/3]

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

Create a triangulation from the provided TriangulationDescription::Description.

Note
Don't forget to attach the manifolds with set_manifold() before calling this function if manifolds are needed.
The namespace TriangulationDescription::Utilities contains functions to create TriangulationDescription::Description.
Parameters
construction_dataThe data needed for this process.
Note
This is the function to be used instead of Triangulation::create_triangulation() for some of the other triangulations of deal.II.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 63 of file fully_distributed_tria.cc.

◆ create_triangulation() [2/3]

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::create_triangulation ( const std::vector< Point< spacedim > > & vertices,
const std::vector<::CellData< dim > > & cells,
const SubCellData & subcelldata )
overridevirtual
Note
This function is not implemented for this class and throws an assertion. Instead, use the other create_triangulation() function to create the triangulation.

Definition at line 220 of file fully_distributed_tria.cc.

◆ copy_triangulation() [1/2]

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

Implementation of the same function as in the base class.

Parameters
other_triaThe triangulation to be copied. It can be a serial Triangulation or a parallel::distributed::Triangulation. Both can have been refined already.
Note
This function uses the partitioner registered with set_partitioner().

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

Definition at line 249 of file fully_distributed_tria.cc.

◆ set_partitioner() [1/2]

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::set_partitioner ( const std::function< void(::Triangulation< dim, spacedim > &, const unsigned int)> & partitioner,
const TriangulationDescription::Settings & settings )

Register a partitioner, which is used within the method copy_triangulation.

Parameters
partitionerA partitioning function, which takes as input argument a reference to the triangulation to be partitioned and the number of partitions to be created. The function needs to set subdomain ids for each active cell of the given triangulation, with values between zero (inclusive) and the second argument to the function (exclusive).
settingsSee the description of the Settings enumerator.
Note
As a default, GridTools::partition_triangulation_zorder() is used as partitioner and data structures on multigrid levels are not set up.

Definition at line 298 of file fully_distributed_tria.cc.

◆ set_partitioner() [2/2]

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::set_partitioner ( const RepartitioningPolicyTools::Base< dim, spacedim > & partitioner,
const TriangulationDescription::Settings & settings )

Register a partitioner, which is used within the method repartition().

Definition at line 311 of file fully_distributed_tria.cc.

◆ repartition()

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::repartition ( )

Execute repartitioning and use the partitioner attached by the method set_partitioner();

Definition at line 323 of file fully_distributed_tria.cc.

◆ execute_coarsening_and_refinement()

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::execute_coarsening_and_refinement ( )
overridevirtual

Coarsen and refine the mesh according to refinement and coarsening flags set.

Note
Not implemented yet.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 351 of file fully_distributed_tria.cc.

◆ prepare_coarsening_and_refinement()

template<int dim, int spacedim>
bool Triangulation< dim, spacedim >::prepare_coarsening_and_refinement ( )
overridevirtual

Override the implementation of prepare_coarsening_and_refinement from the base class.

Note
Not implemented yet.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 360 of file fully_distributed_tria.cc.

◆ memory_consumption()

template<int dim, int spacedim>
std::size_t Triangulation< dim, spacedim >::memory_consumption ( ) const
overridevirtual

Return the local memory consumption in bytes.

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

Definition at line 374 of file fully_distributed_tria.cc.

◆ is_multilevel_hierarchy_constructed()

template<int dim, int spacedim>
bool Triangulation< dim, spacedim >::is_multilevel_hierarchy_constructed ( ) const
overridevirtual

Return if multilevel hierarchy is supported and has been constructed.

Implements parallel::TriangulationBase< dim, spacedim >.

Definition at line 390 of file fully_distributed_tria.cc.

◆ save() [1/2]

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::save ( const std::string & filename) const
overridevirtual

Save the triangulation into the given file. This file needs to be reachable from all nodes in the computation on a shared network file system. See the SolutionTransfer class on how to store solution vectors into this file. Additional cell-based data can be saved using register_data_attach().

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 456 of file fully_distributed_tria.cc.

◆ load() [1/3]

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load ( const std::string & filename)
overridevirtual

Load the triangulation saved with save() back in. The mesh must be empty before calling this function.

You need to load with the same number of MPI processes that you saved with, hence autopartition is disabled.

Cell-based data that was saved with register_data_attach() can be read in with notify_ready_to_unpack() after calling load().

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 595 of file fully_distributed_tria.cc.

◆ load() [2/3]

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::load ( const std::string & filename,
const bool autopartition )
overridevirtual

Load the triangulation saved with save() back in. The mesh must be empty before calling this function.

You need to load with the same number of MPI processes that you saved with, hence autopartition is disabled.

Cell-based data that was saved with register_data_attach() can be read in with notify_ready_to_unpack() after calling load().

Deprecated
The autopartition parameter has been removed.

Implements parallel::DistributedTriangulationBase< dim, dim >.

Definition at line 741 of file fully_distributed_tria.cc.

◆ coarse_cell_id_to_coarse_cell_index()

template<int dim, int spacedim>
unsigned int Triangulation< dim, spacedim >::coarse_cell_id_to_coarse_cell_index ( const types::coarse_cell_id coarse_cell_id) const
overrideprivatevirtual

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. If a cell does not exist locally, the returned value is numbers::invalid_unsigned_int.
Parameters
coarse_cell_idUnique id of the coarse cell.
Returns
Index of the coarse cell within the current triangulation.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 402 of file fully_distributed_tria.cc.

◆ coarse_cell_index_to_coarse_cell_id()

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

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_indexIndex of the coarse cell.
Returns
Id of the coarse cell.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 424 of file fully_distributed_tria.cc.

◆ update_cell_relations()

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::update_cell_relations ( )
private

Go through all active cells that are locally owned and record how they will change in the private member vector local_cell_relations.

As no adaptive mesh refinement is supported at the moment for this class, all cells will be flagged with CellStatus::cell_will_persist. These relations will currently only be used for serialization.

The stored vector will have a size equal to the number of locally owned active cells and will be ordered by the occurrence of those cells.

Definition at line 440 of file fully_distributed_tria.cc.

◆ update_number_cache()

template<int dim, int spacedim>
void Triangulation< dim, spacedim >::update_number_cache ( )
overrideprivatevirtual

Update the number_cache variable after mesh creation or refinement.

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

Definition at line 752 of file fully_distributed_tria.cc.

◆ has_hanging_nodes()

bool parallel::DistributedTriangulationBase< dim, spacedim >::has_hanging_nodes ( ) const
overridevirtualinherited

Return true if the triangulation has hanging nodes.

In the context of parallel distributed triangulations, every processor stores only that part of the triangulation it owns locally. However, it also stores coarser levels, and to guarantee the 2:1 relationship between cells, this may mean that there are hanging nodes between cells that are not locally owned or ghost cells (i.e., between ghost cells and artificial cells, or between artificial and artificial cells; see the glossary). One is not typically interested in this case, so the function returns whether there are hanging nodes between any two cells of the "global" mesh, i.e., the union of locally owned cells on all processors.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 489 of file tria_base.cc.

◆ load() [3/3]

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.

◆ get_communicator()

MPI_Comm parallel::TriangulationBase< dim, spacedim >::get_communicator ( ) const
overridevirtualinherited

Return MPI communicator used by this triangulation.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 100 of file tria_base.cc.

◆ copy_triangulation() [2/2]

virtual void Triangulation< dim, spacedim >::copy_triangulation ( const Triangulation< dim, spacedim > & other_tria)
virtualinherited

Copy other_tria to this triangulation. This operation is not cheap, so you should be careful with using this. We do not implement this function as a copy constructor, since it makes it easier to maintain collections of triangulations if you can assign them values later on.

This triangulation must be empty beforehand.

The function is made virtual since some derived classes might want to disable or extend the functionality of this function.

Note
Calling this function triggers the 'copy' signal on other_tria, i.e. the triangulation being copied from. It also triggers the 'create' signal of the current triangulation. See the section on signals in the general documentation for more information.
The list of connections to signals is not copied from the old to the new triangulation since these connections were established to monitor how the old triangulation changes, not how any triangulation it may be copied to changes.

◆ n_locally_owned_active_cells()

unsigned int parallel::TriangulationBase< dim, spacedim >::n_locally_owned_active_cells ( ) const
inherited

Return the number of active cells in the triangulation that are locally owned, i.e. that have a subdomain_id equal to locally_owned_subdomain(). Note that there may be more active cells in the triangulation stored on the present processor, such as for example ghost cells, or cells further away from the locally owned block of cells but that are needed to ensure that the triangulation that stores this processor's set of active cells still remains balanced with respect to the 2:1 size ratio of adjacent cells.

As a consequence of the remark above, the result of this function is always smaller or equal to the result of the function with the same name in the Triangulation base class, which includes the active ghost and artificial cells (see also GlossArtificialCell and GlossGhostCell).

Definition at line 139 of file tria_base.cc.

◆ n_global_active_cells()

types::global_cell_index parallel::TriangulationBase< dim, spacedim >::n_global_active_cells ( ) const
overridevirtualinherited

Return the sum over all processors of the number of active cells owned by each processor. This equals the overall number of active cells in the triangulation.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 147 of file tria_base.cc.

◆ n_global_levels()

unsigned int parallel::TriangulationBase< dim, spacedim >::n_global_levels ( ) const
overridevirtualinherited

Return the global maximum level. This may be bigger than the number Triangulation::n_levels() (a function in this class's base class) returns if the current processor only stores cells in parts of the domain that are not very refined, but if other processors store cells in more deeply refined parts of the domain.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 164 of file tria_base.cc.

◆ locally_owned_subdomain()

types::subdomain_id parallel::TriangulationBase< dim, spacedim >::locally_owned_subdomain ( ) const
overridevirtualinherited

Return the subdomain id of those cells that are owned by the current processor. All cells in the triangulation that do not have this subdomain id are either owned by another processor or have children that only exist on other processors.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 173 of file tria_base.cc.

◆ ghost_owners()

const std::set< types::subdomain_id > & parallel::TriangulationBase< dim, spacedim >::ghost_owners ( ) const
inherited

Return a set of MPI ranks of the processors that have at least one ghost cell adjacent to the cells of the local processor. In other words, this is the set of subdomain_id() for all ghost cells.

The returned sets are symmetric, that is if i is contained in the list of processor j, then j will also be contained in the list of processor i.

Definition at line 185 of file tria_base.cc.

◆ level_ghost_owners()

const std::set< types::subdomain_id > & parallel::TriangulationBase< dim, spacedim >::level_ghost_owners ( ) const
inherited

Return a set of MPI ranks of the processors that have at least one level ghost cell adjacent to our cells used in geometric multigrid. In other words, this is the set of level_subdomain_id() for all level ghost cells.

The returned sets are symmetric, that is if i is contained in the list of processor j, then j will also be contained in the list of processor i.

Note
The level ghost owners can only be determined if the multigrid ownership has been assigned (by setting the construct_multigrid_hierarchy flag at construction time), otherwise the returned set will be empty.

Definition at line 203 of file tria_base.cc.

◆ global_active_cell_index_partitioner()

std::weak_ptr< const Utilities::MPI::Partitioner > parallel::TriangulationBase< dim, spacedim >::global_active_cell_index_partitioner ( ) const
overridevirtualinherited

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 from Triangulation< dim, spacedim >.

Definition at line 206 of file tria_base.cc.

◆ global_level_cell_index_partitioner()

std::weak_ptr< const Utilities::MPI::Partitioner > parallel::TriangulationBase< dim, spacedim >::global_level_cell_index_partitioner ( const unsigned int level) const
overridevirtualinherited

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 from Triangulation< dim, spacedim >.

Definition at line 209 of file tria_base.cc.

◆ get_boundary_ids()

std::vector< types::boundary_id > parallel::TriangulationBase< dim, spacedim >::get_boundary_ids ( ) const
overridevirtualinherited

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).

See also
Glossary entry on boundary indicators
Note
This function involves a global communication gathering all current IDs from all processes.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 226 of file tria_base.cc.

◆ get_manifold_ids()

std::vector< types::manifold_id > parallel::TriangulationBase< dim, spacedim >::get_manifold_ids ( ) const
overridevirtualinherited

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).

See also
Glossary entry on manifold indicators
Note
This function involves a global communication gathering all current IDs from all processes.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 244 of file tria_base.cc.

◆ communicate_locally_moved_vertices()

void parallel::TriangulationBase< dim, spacedim >::communicate_locally_moved_vertices ( const std::vector< bool > & vertex_locally_moved)
inherited

When vertices have been moved locally, for example using code like

cell->vertex(0) = new_location;

then this function can be used to update the location of vertices between MPI processes.

All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor \(i\) move those vertices that are adjacent to cells whose owners include processor \(i\) but no other processor \(j\) with \(j<i\); in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.

Note
It only makes sense to move vertices that are either located on locally owned cells or on cells in the ghost layer. This is because you can be sure that these vertices indeed exist on the finest mesh aggregated over all processors, whereas vertices on artificial cells but not at least in the ghost layer may or may not exist on the globally finest mesh. Consequently, the vertex_locally_moved argument may not contain vertices that aren't at least on ghost cells.
This function moves vertices in such a way that on every processor, the vertices of every locally owned and ghost cell is consistent with the corresponding location of these cells on other processors. On the other hand, the locations of artificial cells will in general be wrong since artificial cells may or may not exist on other processors and consequently it is not possible to determine their location in any way. This is not usually a problem since one never does anything on artificial cells. However, it may lead to problems if the mesh with moved vertices is refined in a later step. If that's what you want to do, the right way to do it is to save the offset applied to every vertex, call this function, and before refining or coarsening the mesh apply the opposite offset and call this function again.
Parameters
vertex_locally_movedA bitmap indicating which vertices have been moved. The size of this array must be equal to Triangulation::n_vertices() and must be a subset of those vertices flagged by GridTools::get_locally_owned_vertices().
See also
This function is used, for example, in GridTools::distort_random().

Definition at line 299 of file tria_base.cc.

◆ n_global_coarse_cells()

types::coarse_cell_id parallel::TriangulationBase< dim, spacedim >::n_global_coarse_cells ( ) const
overridevirtualinherited

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

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 303 of file tria_base.cc.

◆ clear()

void parallel::TriangulationBase< dim, spacedim >::clear ( )
overridevirtualinherited

Reset this triangulation to an empty 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.

Reimplemented from Triangulation< dim, spacedim >.

Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< dim, dim >, and parallel::distributed::Triangulation< dim, spacedim >.

Definition at line 312 of file tria_base.cc.

◆ update_reference_cells()

void parallel::TriangulationBase< dim, spacedim >::update_reference_cells ( )
overrideprotectedvirtualinherited

Update the internal reference_cells vector.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 398 of file tria_base.cc.

◆ reset_global_cell_indices()

void parallel::TriangulationBase< dim, spacedim >::reset_global_cell_indices ( )
protectedinherited

Reset global active cell indices and global level cell indices.

Definition at line 404 of file tria_base.cc.

◆ 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.

◆ 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.

See also
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().

Note
Geometric objects with the manifold ID manifold_number will still have the same ID after calling this function so that the function get_manifold_ids() will still return the same set of IDs.
See also
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().

Note
Geometric objects not having numbers::flat_manifold_id as manifold ID will after calling this function still have the same IDs. Their IDs are not replaced by numbers::flat_manifold_id so that the function get_manifold_ids() will still return the same set of IDs.
See also
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.

See also
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.

See also
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.

See also
Glossary entry on manifold indicators

◆ get_manifold()

const Manifold< dim, spacedim > & 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.
See also
Glossary entry on manifold indicators

◆ create_triangulation() [3/3]

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

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 GridTools::consistently_order_cells() function.

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.

Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< dim, dim >, parallel::distributed::Triangulation< dim, spacedim >, parallel::shared::Triangulation< dim, spacedim >, and parallel::shared::Triangulation< dim, dim >.

◆ flip_all_direction_flags()

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

Revert or flip the direction flags of a triangulation with dim==spacedim-1, see GlossDirectionFlag.

This function throws an exception if dim==spacedim or if dim<spacedim-1.

◆ 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.

◆ 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.

◆ load_refine_flags() [1/2]

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

Read the information stored by save_refine_flags.

◆ load_refine_flags() [2/2]

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.

◆ load_coarsen_flags() [1/2]

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

Analogue to load_refine_flags.

◆ load_coarsen_flags() [2/2]

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

Clear all user flags. See also GlossUserFlags.

◆ 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.

◆ load_user_flags() [1/2]

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

Read the information stored by save_user_flags. See also GlossUserFlags.

◆ load_user_flags() [2/2]

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

Clear all user flags on lines. See also GlossUserFlags.

◆ save_user_flags_line() [1/2]

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

Save the user flags on lines. See also GlossUserFlags.

◆ 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.

◆ load_user_flags_line() [1/2]

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

Load the user flags located on lines. See also GlossUserFlags.

◆ load_user_flags_line() [2/2]

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

Load the user flags located on lines. See also GlossUserFlags.

◆ clear_user_flags_quad()

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

Clear all user flags on quads. See also GlossUserFlags.

◆ save_user_flags_quad() [1/2]

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

Save the user flags on quads. See also GlossUserFlags.

◆ save_user_flags_quad() [2/2]

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.

◆ load_user_flags_quad() [1/2]

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

Load the user flags located on quads. See also GlossUserFlags.

◆ load_user_flags_quad() [2/2]

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

Load the user flags located on quads. See also GlossUserFlags.

◆ clear_user_flags_hex()

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

Clear all user flags on quads. See also GlossUserFlags.

◆ save_user_flags_hex() [1/2]

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

Save the user flags on hexs. See also GlossUserFlags.

◆ 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.

◆ load_user_flags_hex() [1/2]

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

Load the user flags located on hexs. See also GlossUserFlags.

◆ load_user_flags_hex() [2/2]

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

Load the user flags located on hexs. See also GlossUserFlags.

◆ 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.

◆ load_user_indices()

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

Read the information stored by save_user_indices(). See also GlossUserData.

◆ 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.

◆ load_user_pointers()

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

Read the information stored by save_user_pointers(). See also GlossUserData.

◆ 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.

◆ load_user_indices_line()

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

Load the user indices located on lines. See also GlossUserData.

◆ save_user_indices_quad()

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

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

◆ load_user_indices_quad()

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

Load the user indices located on quads. See also GlossUserData.

◆ 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.

◆ load_user_indices_hex()

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

Load the user indices located on hexs. See also GlossUserData.

◆ 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.

◆ load_user_pointers_line()

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

Load the user pointers located on lines. See also GlossUserData.

◆ save_user_pointers_quad()

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

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

◆ load_user_pointers_quad()

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

Load the user pointers located on quads. See also GlossUserData.

◆ 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.

◆ load_user_pointers_hex()

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

Load the user pointers located on hexs. See also GlossUserData.

◆ 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!=tria.end_active(level);
++cell)
{
...
}
unsigned int level
Definition grid_out.cc:4626

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.

Note
See the documentation of contains_cell() about which CellId objects are valid.

◆ contains_cell()

bool Triangulation< dim, spacedim >::contains_cell ( const CellId & cell_id) const
inherited

Check if the triangulation contains a cell with the id cell_id. If the given argument corresponds to a valid cell in this triangulation, this operation will always return true 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 return true for locally relevant cells, but may return false for artificial cells that are less refined on the current processor.

◆ cell_iterators()

IteratorRange< cell_iterator > 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< active_cell_iterator > 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):

...
endc = triangulation.end();
for (; cell!=endc; ++cell)
cell->set_user_flag();
cell_iterator end() const
active_cell_iterator begin_active(const unsigned int level=0) const
typename ::Triangulation< dim, spacedim >::active_cell_iterator active_cell_iterator
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();
IteratorRange< active_cell_iterator > active_cell_iterators() const
Returns
The half open range [this->begin_active(), this->end())

◆ cell_iterators_on_level()

IteratorRange< cell_iterator > 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]levelA 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< active_cell_iterator > 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]levelA 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< active_face_iterator > 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.,

...
face->set_manifold_id(42);
IteratorRange< active_face_iterator > active_face_iterators() const
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.

◆ n_quads() [1/8]

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

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

◆ n_quads() [2/8]

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.

◆ n_quads() [3/8]

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

Definition at line 15173 of file tria.cc.

◆ n_quads() [4/8]

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

Definition at line 15181 of file tria.cc.

◆ n_quads() [5/8]

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

Definition at line 15222 of file tria.cc.

◆ n_quads() [6/8]

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

Definition at line 15230 of file tria.cc.

◆ n_quads() [7/8]

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

Definition at line 15270 of file tria.cc.

◆ n_quads() [8/8]

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

Definition at line 15278 of file tria.cc.

◆ n_active_quads() [1/8]

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

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

◆ n_active_quads() [2/8]

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.

◆ n_active_quads() [3/8]

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

Definition at line 15205 of file tria.cc.

◆ n_active_quads() [4/8]

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

Definition at line 15213 of file tria.cc.

◆ n_active_quads() [5/8]

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

Definition at line 15254 of file tria.cc.

◆ n_active_quads() [6/8]

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

Definition at line 15262 of file tria.cc.

◆ n_active_quads() [7/8]

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

Definition at line 15302 of file tria.cc.

◆ n_active_quads() [8/8]

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

Definition at line 15310 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 15452 of file tria.cc.

◆ n_hexs() [4/4]

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

Definition at line 15461 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 15481 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 15490 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_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_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< Point< spacedim > > & 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< bool > & 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.

◆ max_adjacent_cells() [1/4]

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.

◆ max_adjacent_cells() [2/4]

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

Definition at line 15519 of file tria.cc.

◆ max_adjacent_cells() [3/4]

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

Definition at line 15528 of file tria.cc.

◆ max_adjacent_cells() [4/4]

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

Definition at line 15536 of file tria.cc.

◆ get_triangulation() [1/2]

Triangulation< dim, spacedim > & 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< dim, spacedim > & 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).

◆ n_raw_quads() [1/9]

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).

◆ n_raw_quads() [2/9]

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).

◆ n_raw_quads() [3/9]

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

Definition at line 15189 of file tria.cc.

◆ n_raw_quads() [4/9]

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

Definition at line 15238 of file tria.cc.

◆ n_raw_quads() [5/9]

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

Definition at line 15286 of file tria.cc.

◆ n_raw_quads() [6/9]

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

Definition at line 15339 of file tria.cc.

◆ n_raw_quads() [7/9]

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

Definition at line 15349 of file tria.cc.

◆ n_raw_quads() [8/9]

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

Definition at line 15358 of file tria.cc.

◆ n_raw_quads() [9/9]

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

Definition at line 15378 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 15197 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 15246 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 15294 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 15472 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() [2/2]

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.

◆ add_periodicity()

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< cell_iterator, unsigned int >, std::pair< std::pair< cell_iterator, unsigned int >, unsigned char > > & Triangulation< dim, spacedim >::get_periodic_face_map ( ) const
inherited

Return the periodic_face_map.

◆ get_reference_cells()

const std::vector< ReferenceCell > & 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.

This function is used in step-83.

◆ register_data_attach()

unsigned int Triangulation< dim, spacedim >::register_data_attach ( const std::function< std::vector< char >(const cell_iterator &, const ::CellStatus)> & pack_callback,
const bool returns_variable_size_data )
inherited

Register a function that can be used to attach data of fixed size to cells. This is useful for two purposes: (i) Upon refinement and coarsening of a triangulation (e.g. in parallel::distributed::Triangulation::execute_coarsening_and_refinement()), one needs to be able to store one or more data vectors per cell that characterizes the solution values on the cell so that this data can then be transferred to the new owning processor of the cell (or its parent/children) when the mesh is re-partitioned; (ii) when serializing a computation to a file, it is necessary to attach data to cells so that it can be saved (e.g. in parallel::distributed::Triangulation::save()) along with the cell's other information and, if necessary, later be reloaded from disk with a different subdivision of cells among the processors.

The way this function works is that it allows any number of interest parties to register their intent to attach data to cells. One example of classes that do this is parallel::distributed::SolutionTransfer where each parallel::distributed::SolutionTransfer object that works on the current Triangulation object then needs to register its intent. Each of these parties registers a callback function (the first argument here, pack_callback) that will be called whenever the triangulation's execute_coarsening_and_refinement() or save() functions are called.

The current function then returns an integer handle that corresponds to the number of data set that the callback provided here will attach. While this number could be given a precise meaning, this is not important: You will never actually have to do anything with this number except return it to the notify_ready_to_unpack() function. In other words, each interested party (i.e., the caller of the current function) needs to store their respective returned handle for later use when unpacking data in the callback provided to notify_ready_to_unpack().

Whenever pack_callback is then called by execute_coarsening_and_refinement() or load() on a given cell, it receives a number of arguments. In particular, the first argument passed to the callback indicates the cell for which it is supposed to attach data. This is always an active cell.

The second, CellStatus, argument provided to the callback function will tell you if the given cell will be coarsened, refined, or will persist as is. (This status may be different than the refinement or coarsening flags set on that cell, to accommodate things such as the "one hanging node per edge" rule.). These flags need to be read in context with the p4est quadrant they belong to, as their relations are gathered in local_cell_relations.

Specifically, the values for this argument mean the following:

  • CellStatus::cell_will_persist: The cell won't be refined/coarsened, but might be moved to a different processor. If this is the case, the callback will want to pack up the data on this cell into an array and store it at the provided address for later unpacking wherever this cell may land.
  • CellStatus::cell_will_be_refined: This cell will be refined into 4 or 8 cells (in 2d and 3d, respectively). However, because these children don't exist yet, you cannot access them at the time when the callback is called. Thus, in local_cell_relations, the corresponding p4est quadrants of the children cells are linked to the deal.II cell which is going to be refined. To be specific, only the very first child is marked with CellStatus::cell_will_be_refined, whereas the others will be marked with CellStatus::cell_invalid, which indicates that these cells will be ignored by default during the packing or unpacking process. This ensures that data is only transferred once onto or from the parent cell. If the callback is called with CellStatus::cell_will_be_refined, the callback will want to pack up the data on this cell into an array and store it at the provided address for later unpacking in a way so that it can then be transferred to the children of the cell that will then be available. In other words, if the data the callback will want to pack up corresponds to a finite element field, then the prolongation from parent to (new) children will have to happen during unpacking.
  • CellStatus::children_will_be_coarsened: The children of this cell will be coarsened into the given cell. These children still exist, so if this is the value given to the callback as second argument, the callback will want to transfer data from the children to the current parent cell and pack it up so that it can later be unpacked again on a cell that then no longer has any children (and may also be located on a different processor). In other words, if the data the callback will want to pack up corresponds to a finite element field, then it will need to do the restriction from children to parent at this point.
  • CellStatus::cell_invalid: See CellStatus::cell_will_be_refined.
Note
If this function is used for serialization of data using save() and load(), then the cell status argument with which the callback is called will always be CellStatus::cell_will_persist.

The callback function is expected to return a memory chunk of the format std::vector<char>, representing the packed data on a certain cell.

The second parameter returns_variable_size_data indicates whether the returned size of the memory region from the callback function varies by cell (=true) or stays constant on each one throughout the whole domain (=false).

Note
The purpose of this function is to register intent to attach data for a single, subsequent call to execute_coarsening_and_refinement() and notify_ready_to_unpack(), save(), load(). Consequently, notify_ready_to_unpack(), save(), and load() all forget the registered callbacks once these callbacks have been called, and you will have to re-register them with a triangulation if you want them to be active for another call to these functions.

◆ notify_ready_to_unpack()

void Triangulation< dim, spacedim >::notify_ready_to_unpack ( const unsigned int handle,
const std::function< void(const cell_iterator &, const ::CellStatus, const boost::iterator_range< std::vector< char >::const_iterator > &)> & unpack_callback )
inherited

This function is the opposite of register_data_attach(). It is called after the execute_coarsening_and_refinement() or save()/load() functions are done when classes and functions that have previously attached data to a triangulation for either transfer to other processors, across mesh refinement, or serialization of data to a file are ready to receive that data back. The important part about this process is that the triangulation cannot do this right away from the end of execute_coarsening_and_refinement() or load() via a previously attached callback function (as the register_data_attach() function does) because the classes that eventually want the data back may need to do some setup between the point in time where the mesh has been recreated and when the data can actually be received. An example is the parallel::distributed::SolutionTransfer class that can really only receive the data once not only the mesh is completely available again on the current processor, but only after a DoFHandler has been reinitialized and distributed degrees of freedom. In other words, there is typically a significant amount of set up that needs to happen in user space before the classes that can receive data attached to cell are ready to actually do so. When they are, they use the current function to tell the triangulation object that now is the time when they are ready by calling the current function.

The supplied callback function is then called for each newly locally owned cell. The first argument to the callback is an iterator that designates the cell; the second argument indicates the status of the cell in question; and the third argument localizes a memory area by two iterators that contains the data that was previously saved from the callback provided to register_data_attach().

The CellStatus will indicate if the cell was refined, coarsened, or persisted unchanged. The cell_iterator argument to the callback will then either be an active, locally owned cell (if the cell was not refined), or the immediate parent if it was refined during execute_coarsening_and_refinement(). Therefore, contrary to during register_data_attach(), you can now access the children if the status is CellStatus::cell_will_be_refined but no longer for callbacks with status CellStatus::children_will_be_coarsened.

The first argument to this function, handle, corresponds to the return value of register_data_attach(). (The precise meaning of what the numeric value of this handle is supposed to represent is neither important, nor should you try to use it for anything other than transmit information between a call to register_data_attach() to the corresponding call to notify_ready_to_unpack().)

◆ save_attached_data()

void Triangulation< dim, spacedim >::save_attached_data ( const unsigned int global_first_cell,
const unsigned int global_num_cells,
const std::string & file_basename ) const
protectedinherited

Save additional cell-attached data from files all starting with the base name given as last argument. The first arguments are used to determine the offsets where to write buffers to.

Called by save.

◆ load_attached_data()

void Triangulation< dim, spacedim >::load_attached_data ( const unsigned int global_first_cell,
const unsigned int global_num_cells,
const unsigned int local_num_cells,
const std::string & file_basename,
const unsigned int n_attached_deserialize_fixed,
const unsigned int n_attached_deserialize_variable )
protectedinherited

Load additional cell-attached data files all starting with the base name given as fourth argument, if any was saved. The first arguments are used to determine the offsets where to read buffers from.

Called by load.

◆ 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."

◆ ExcGridReadError()

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."

◆ ExcBoundaryIdNotFound()

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

Exception

Requested boundary_id not found

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.

◆ read_bool_vector()

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.

◆ 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.

◆ begin_raw_quad()

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.

◆ begin_quad()

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.

◆ begin_active_quad()

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.

◆ end_quad()

quad_iterator Triangulation< dim, spacedim >::end_quad ( ) const
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_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.

◆ 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 135 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 155 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 203 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 52 of file subscriptor.cc.

Member Data Documentation

◆ settings

template<int dim, int spacedim = dim>
TriangulationDescription::Settings parallel::fullydistributed::Triangulation< dim, spacedim >::settings
private

store the Settings.

Definition at line 306 of file fully_distributed_tria.h.

◆ partitioner

template<int dim, int spacedim = dim>
std::function<void(::Triangulation<dim, spacedim> &, const unsigned int)> parallel::fullydistributed::Triangulation< dim, spacedim >::partitioner
private

Partitioner used in copy_triangulation().

Definition at line 313 of file fully_distributed_tria.h.

◆ partitioner_distributed

template<int dim, int spacedim = dim>
SmartPointer<const RepartitioningPolicyTools::Base<dim, spacedim> > parallel::fullydistributed::Triangulation< dim, spacedim >::partitioner_distributed
private

Partitioner used during repartition().

Definition at line 319 of file fully_distributed_tria.h.

◆ coarse_cell_id_to_coarse_cell_index_vector

template<int dim, int spacedim = dim>
std::vector<std::pair<types::coarse_cell_id, unsigned int> > parallel::fullydistributed::Triangulation< dim, spacedim >::coarse_cell_id_to_coarse_cell_index_vector
private

Sorted list of pairs of coarse-cell ids and their indices.

Definition at line 325 of file fully_distributed_tria.h.

◆ coarse_cell_index_to_coarse_cell_id_vector

template<int dim, int spacedim = dim>
std::vector<types::coarse_cell_id> parallel::fullydistributed::Triangulation< dim, spacedim >::coarse_cell_index_to_coarse_cell_id_vector
private

List of the coarse-cell id for each coarse cell (stored at cell->index()).

Definition at line 332 of file fully_distributed_tria.h.

◆ currently_processing_create_triangulation_for_internal_usage

template<int dim, int spacedim = dim>
bool parallel::fullydistributed::Triangulation< dim, spacedim >::currently_processing_create_triangulation_for_internal_usage
private

Boolean indicating that the function create_triangulation() was called for internal usage.

Definition at line 338 of file fully_distributed_tria.h.

◆ currently_processing_prepare_coarsening_and_refinement_for_internal_usage

template<int dim, int spacedim = dim>
bool parallel::fullydistributed::Triangulation< dim, spacedim >::currently_processing_prepare_coarsening_and_refinement_for_internal_usage
private

Boolean indicating that the function prepare_coarsening_and_refinement() was called for internal usage.

Definition at line 345 of file fully_distributed_tria.h.

◆ mpi_communicator

const MPI_Comm parallel::TriangulationBase< dim, spacedim >::mpi_communicator
protectedinherited

MPI communicator to be used for the triangulation. We create a unique communicator for this class, which is a duplicate of the one passed to the constructor.

Definition at line 320 of file tria_base.h.

◆ my_subdomain

types::subdomain_id parallel::TriangulationBase< dim, spacedim >::my_subdomain
protectedinherited

The subdomain id to be used for the current processor. This is the MPI rank.

Definition at line 326 of file tria_base.h.

◆ n_subdomains

types::subdomain_id parallel::TriangulationBase< dim, spacedim >::n_subdomains
protectedinherited

The total number of subdomains (or the size of the MPI communicator).

Definition at line 331 of file tria_base.h.

◆ number_cache

NumberCache parallel::TriangulationBase< dim, spacedim >::number_cache
protectedinherited

Definition at line 389 of file tria_base.h.

◆ dimension

unsigned int Triangulation< dim, spacedim >::dimension
staticconstexprinherited

Make the dimension available in function templates.

Definition at line 1743 of file tria.h.

◆ space_dimension

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

Make the space-dimension available in function templates.

Definition at line 1748 of file tria.h.

◆ CELL_PERSIST

auto Triangulation< dim, spacedim >::CELL_PERSIST
staticconstexprinherited
Deprecated
This is an alias for backward compatibility. Use CellStatus directly.

Definition at line 2234 of file tria.h.

◆ CELL_REFINE

auto Triangulation< dim, spacedim >::CELL_REFINE
staticconstexprinherited
Deprecated
This is an alias for backward compatibility. Use CellStatus directly.

Definition at line 2241 of file tria.h.

◆ CELL_COARSEN

auto Triangulation< dim, spacedim >::CELL_COARSEN
staticconstexprinherited
Deprecated
This is an alias for backward compatibility. Use CellStatus directly.

Definition at line 2248 of file tria.h.

◆ CELL_INVALID

auto Triangulation< dim, spacedim >::CELL_INVALID
staticconstexprinherited
Deprecated
This is an alias for backward compatibility. Use CellStatus directly.

Definition at line 2255 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 2513 of file tria.h.

◆ cell_attached_data

internal::CellAttachedData<dim, spacedim> Triangulation< dim, spacedim >::cell_attached_data
inherited

Definition at line 3864 of file tria.h.

◆ local_cell_relations

std::vector<typename internal::CellAttachedDataSerializer<dim, spacedim>:: cell_relation_t> Triangulation< dim, spacedim >::local_cell_relations
protectedinherited

Vector of pairs, each containing a deal.II cell iterator and its respective CellStatus. To update its contents, use the update_cell_relations() member function.

Definition at line 3914 of file tria.h.

◆ data_serializer

internal::CellAttachedDataSerializer<dim, spacedim> Triangulation< dim, spacedim >::data_serializer
protectedinherited

Definition at line 3916 of file tria.h.

◆ smooth_grid

MeshSmoothing Triangulation< dim, spacedim >::smooth_grid
protectedinherited

Do some smoothing in the process of refining the triangulation. See the general doc of this class for more information about this.

Definition at line 4006 of file tria.h.

◆ reference_cells

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

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

Definition at line 4012 of file tria.h.

◆ policy

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

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

Definition at line 4064 of file tria.h.

◆ periodic_face_pairs_level_0

std::vector<GridTools::PeriodicFacePair<cell_iterator> > 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 4073 of file tria.h.

◆ periodic_face_map

std::map<std::pair<cell_iterator, unsigned int>, std::pair<std::pair<cell_iterator, unsigned int>, unsigned char> > Triangulation< dim, spacedim >::periodic_face_map
privateinherited

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

Definition at line 4081 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 4453 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 4461 of file tria.h.

◆ vertices

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

Array of the vertices of this triangulation.

Definition at line 4467 of file tria.h.

◆ vertices_used

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

Array storing a bit-pattern which vertices are used.

Definition at line 4472 of file tria.h.

◆ manifolds

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

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

Definition at line 4479 of file tria.h.

◆ anisotropic_refinement

bool Triangulation< dim, spacedim >::anisotropic_refinement
privateinherited

Flag indicating whether anisotropic refinement took place.

Definition at line 4484 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 4491 of file tria.h.

◆ vertex_to_boundary_id_map_1d

std::unique_ptr<std::map<unsigned int, types::boundary_id> > 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 4519 of file tria.h.

◆ vertex_to_manifold_id_map_1d

std::unique_ptr<std::map<unsigned int, types::manifold_id> > 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 4542 of file tria.h.

◆ counter

std::atomic<unsigned int> 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 218 of file subscriptor.h.

◆ counter_map

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

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

Definition at line 224 of file subscriptor.h.

◆ validity_pointers

std::vector<std::atomic<bool> *> 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 240 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 248 of file subscriptor.h.

◆ mutex

std::mutex Subscriptor::mutex
staticprivateinherited

A mutex used to ensure data consistency when accessing the mutable members of this class. This lock is used in the subscribe() and unsubscribe() functions, as well as in list_subscribers().

Definition at line 271 of file subscriptor.h.


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