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

Inheritance diagram for PersistentTriangulation< dim, spacedim >:

[legend]

Public Types
enum	MeshSmoothing { none = 0x0 , limit_level_difference_at_vertices = 0x1 , eliminate_unrefined_islands = 0x2 , patch_level_1 = 0x4 , coarsest_level_1 = 0x8 , allow_anisotropic_smoothing = 0x10 , eliminate_refined_inner_islands = 0x100 , eliminate_refined_boundary_islands = 0x200 , do_not_produce_unrefined_islands = 0x400 , smoothing_on_refinement , smoothing_on_coarsening , maximum_smoothing = 0xffff ^ allow_anisotropic_smoothing }

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

using	level_cell_iterator = cell_iterator

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

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

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

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

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

using	line_iterator = typename IteratorSelector::line_iterator

using	active_line_iterator = typename IteratorSelector::active_line_iterator

using	quad_iterator = typename IteratorSelector::quad_iterator

using	active_quad_iterator = typename IteratorSelector::active_quad_iterator

using	hex_iterator = typename IteratorSelector::hex_iterator

using	active_hex_iterator = typename IteratorSelector::active_hex_iterator

using	CellStatus = ::CellStatus

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

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

virtual	~PersistentTriangulation () override=default

virtual void	execute_coarsening_and_refinement () override

void	restore ()

void	restore (const unsigned int step_no)

unsigned int	n_refinement_steps () const

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

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

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

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

virtual void	read_flags (std::istream &in)

virtual void	clear_flags ()

virtual std::size_t	memory_consumption () const override

virtual void	clear ()

virtual MPI_Comm	get_mpi_communicator () const

MPI_Comm	get_communicator () const

virtual std::weak_ptr< const Utilities::MPI::Partitioner >	global_active_cell_index_partitioner () const

virtual std::weak_ptr< const Utilities::MPI::Partitioner >	global_level_cell_index_partitioner (const unsigned int level) const

virtual void	set_mesh_smoothing (const MeshSmoothing mesh_smoothing)

virtual const MeshSmoothing &	get_mesh_smoothing () const

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

void	reset_manifold (const types::manifold_id manifold_number)

void	reset_all_manifolds ()

void	set_all_manifold_ids (const types::manifold_id number)

void	set_all_manifold_ids_on_boundary (const types::manifold_id number)

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

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

virtual std::vector< types::boundary_id >	get_boundary_ids () const

virtual std::vector< types::manifold_id >	get_manifold_ids () const

void	flip_all_direction_flags ()

bool	prepare_coarsening_and_refinement ()

bool	prepare_coarsening_and_refinement ()

bool	prepare_coarsening_and_refinement ()

unsigned int	n_quads () const

unsigned int	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

template<class Archive >
void	save (Archive &ar, const unsigned int version) const

virtual void	save (const std::string &file_basename) const

template<class Archive >
void	load (Archive &ar, const unsigned int version)

virtual void	load (const std::string &file_basename)

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

template<class Archive >
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)

virtual bool	prepare_coarsening_and_refinement ()

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

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

void	load_refine_flags (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_iterator >	cell_iterators () const

IteratorRange< active_cell_iterator >	active_cell_iterators () const

IteratorRange< cell_iterator >	cell_iterators_on_level (const unsigned int level) const

IteratorRange< active_cell_iterator >	active_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_iterator >	active_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

virtual types::global_cell_index	n_global_active_cells () const

virtual types::coarse_cell_id	n_global_coarse_cells () const

unsigned int	n_faces () const

unsigned int	n_active_faces () const

unsigned int	n_levels () const

virtual unsigned int	n_global_levels () const

virtual bool	has_hanging_nodes () const

unsigned int	n_vertices () const

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

unsigned int	n_used_vertices () const

bool	vertex_used (const unsigned int index) const

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

unsigned int	max_adjacent_cells () const

virtual types::subdomain_id	locally_owned_subdomain () const

Triangulation< dim, spacedim > &	get_triangulation ()

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

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

unsigned int	n_raw_lines (const unsigned int level) const

unsigned int	n_raw_quads () const

unsigned int	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

Querying the observer pointers an object has.
unsigned int	n_subscriptions () const

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

void	list_subscribers () const

Static Public Member Functions
static ::ExceptionBase &	ExcTriaNotEmpty ()

static ::ExceptionBase &	ExcFlagsNotCleared ()

static ::ExceptionBase &	ExcInUse (int arg1, std::string arg2, std::string arg3)

static ::ExceptionBase &	ExcNoSubscriber (std::string arg1, std::string arg2)

Exceptions
static ::ExceptionBase &	ExcInvalidLevel (int arg1, int arg2)

static ::ExceptionBase &	ExcTriangulationNotEmpty (int arg1, int arg2)

static ::ExceptionBase &	ExcGridReadError ()

static ::ExceptionBase &	ExcFacesHaveNoLevel ()

static ::ExceptionBase &	ExcEmptyLevel (int arg1)

static ::ExceptionBase &	ExcBoundaryIdNotFound (types::boundary_id arg1)

static ::ExceptionBase &	ExcInconsistentCoarseningFlags ()

Public Attributes
Keeping up with what happens to a triangulation
Signals	signals

Static Public Attributes
static constexpr unsigned int	dimension = dim

static const unsigned int	spacedimension = spacedim

static constexpr unsigned int	space_dimension = spacedim

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_periodic_face_map ()

virtual void	update_reference_cells ()

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
MeshSmoothing	smooth_grid

std::vector< ReferenceCell >	reference_cells

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

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

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

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

using	raw_line_iterator = typename IteratorSelector::raw_line_iterator

using	raw_quad_iterator = typename IteratorSelector::raw_quad_iterator

using	raw_hex_iterator = typename IteratorSelector::raw_hex_iterator

using	map_value_type = decltype(counter_map)::value_type

using	map_iterator = decltype(counter_map)::iterator

Private Member Functions
void	clear_despite_subscriptions ()

void	reset_policy ()

void	reset_active_cell_indices ()

void	reset_global_cell_indices ()

void	reset_cell_vertex_indices_cache ()

DistortedCellList	execute_refinement ()

void	execute_coarsening ()

void	fix_coarsen_flags ()

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

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

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

EnableObserverPointer functionality
Classes derived from EnableObserverPointer provide a facility to subscribe to this object. This is mostly used by the ObserverPointer 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

void	check_no_subscribers () const noexcept

Private Attributes
ObserverPointer< const Triangulation< dim, spacedim >, PersistentTriangulation< dim, spacedim > >	coarse_grid

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

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

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::TriaFaces >	faces

std::vector< Point< spacedim > >	vertices

std::vector< bool >	vertices_used

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

bool	anisotropic_refinement

const bool	check_for_distorted_cells

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

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

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

std::atomic< unsigned int >	counter

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

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

const std::type_info *	object_info

Static Private Attributes
static std::mutex	mutex

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)

internal::CellAttachedData< dim, spacedim >	cell_attached_data

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)

void	update_cell_relations ()

void	pack_data_serial ()

void	unpack_data_serial ()

Detailed Description

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

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

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

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

Usage

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

Basically, usage looks like this:

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

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

Definition at line 107 of file persistent_tria.h.

Member Typedef Documentation

◆ IteratorSelector

template<int dim, int spacedim = dim>

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

privateinherited

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

Definition at line 1329 of file tria.h.

◆ level_cell_iterator

template<int dim, int spacedim = dim>

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

inherited

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

Definition at line 1562 of file tria.h.

◆ CellStatus

template<int dim, int spacedim = dim>

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

◆ raw_cell_iterator

template<int dim, int spacedim = dim>

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

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

◆ raw_face_iterator

template<int dim, int spacedim = dim>

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

privateinherited

Definition at line 4121 of file tria.h.

◆ raw_vertex_iterator

template<int dim, int spacedim = dim>

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

privateinherited

Definition at line 4123 of file tria.h.

◆ raw_line_iterator

template<int dim, int spacedim = dim>

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

privateinherited

Definition at line 4125 of file tria.h.

◆ raw_quad_iterator

template<int dim, int spacedim = dim>

using Triangulation< dim, spacedim >::raw_quad_iterator = typename IteratorSelector::raw_quad_iterator

privateinherited

Definition at line 4126 of file tria.h.

◆ raw_hex_iterator

template<int dim, int spacedim = dim>

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

privateinherited

Definition at line 4127 of file tria.h.

◆ map_value_type

using EnableObserverPointer::map_value_type = decltype(counter_map)::value_type

privateinherited

The data type used in counter_map.

Definition at line 223 of file enable_observer_pointer.h.

◆ map_iterator

using EnableObserverPointer::map_iterator = decltype(counter_map)::iterator

privateinherited

The iterator type used in counter_map.

Definition at line 228 of file enable_observer_pointer.h.

Member Enumeration Documentation

◆ MeshSmoothing

template<int dim, int spacedim = dim>

enum Triangulation::MeshSmoothing

inherited

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

Enumerator
none	No mesh smoothing at all, except that meshes have to remain one-irregular.
limit_level_difference_at_vertices	It can be shown, that degradation of approximation occurs if the triangulation contains vertices which are member of cells with levels differing by more than one. One such example is the following: It would seem that in two space dimensions, the maximum jump in levels between cells sharing a common vertex is two (as in the example above). However, this is not true if more than four cells meet at a vertex. It is not uncommon that a coarse (initial) mesh contains vertices at which six or even eight cells meet, when small features of the domain have to be resolved even on the coarsest mesh. In that case, the maximum difference in levels is three or four, respectively. The problem gets even worse in three space dimensions. Looking at an interpolation of the second derivative of the finite element solution (assuming bilinear finite elements), one sees that the numerical solution is almost totally wrong, compared with the true second derivative. Indeed, on regular meshes, there exist sharp estimations that the H²-error is only of order one, so we should not be surprised; however, the numerical solution may show a value for the second derivative which may be a factor of ten away from the true value. These problems are located on the small cell adjacent to the center vertex, where cells of non-subsequent levels meet, as well as on the upper and right neighbor of this cell (but with a less degree of deviation from the true value). If the smoothing indicator given to the constructor contains the bit for limit_level_difference_at_vertices, situations as the above one are eliminated by also marking the upper right cell for refinement. In case of anisotropic refinement, the level of a cell is not linked to the refinement of a cell as directly as in case of isotropic refinement. Furthermore, a cell can be strongly refined in one direction and not or at least much less refined in another. Therefore, it is very difficult to decide, which cases should be excluded from the refinement process. As a consequence, when using anisotropic refinement, the limit_level_difference_at_vertices flag must not be set. On the other hand, the implementation of multigrid methods in deal.II requires that this bit be set.
eliminate_unrefined_islands	Single cells which are not refined and are surrounded by cells which are refined usually also lead to a sharp decline in approximation properties locally. The reason is that the nodes on the faces between unrefined and refined cells are not real degrees of freedom but carry constraints. The patch without additional degrees of freedom is thus significantly larger then the unrefined cell itself. If in the parameter passed to the constructor the bit for eliminate_unrefined_islands is set, all cells which are not flagged for refinement but which are surrounded by more refined cells than unrefined cells are flagged for refinement. Cells which are not yet refined but flagged for that are accounted for the number of refined neighbors. Cells on the boundary are not accounted for at all. An unrefined island is, by this definition also a cell which (in 2d) is surrounded by three refined cells and one unrefined one, or one surrounded by two refined cells, one unrefined one and is at the boundary on one side. It is thus not a true island, as the name of the flag may indicate. However, no better name came to mind to the author by now.
patch_level_1	A triangulation of patch level 1 consists of patches, i.e. of cells that are refined once. This flag ensures that a mesh of patch level 1 is still of patch level 1 after coarsening and refinement. It is, however, the user's responsibility to ensure that the mesh is of patch level 1 before calling Triangulation::execute_coarsening_and_refinement() the first time. The easiest way to achieve this is by calling global_refine(1) straight after creation of the triangulation. It follows that if at least one of the children of a cell is or will be refined than all children need to be refined. If the patch_level_1 flag is set, than the flags eliminate_unrefined_islands, eliminate_refined_inner_islands and eliminate_refined_boundary_islands will be ignored as they will be fulfilled automatically.
coarsest_level_1	Each coarse grid cell is refined at least once, i.e., the triangulation might have active cells on level 1 but not on level 0. This flag ensures that a mesh which has coarsest_level_1 has still coarsest_level_1 after coarsening and refinement. It is, however, the user's responsibility to ensure that the mesh has coarsest_level_1 before calling execute_coarsening_and_refinement the first time. The easiest way to achieve this is by calling global_refine(1) straight after creation of the triangulation. It follows that active cells on level 1 may not be coarsened. The main use of this flag is to ensure that each cell has at least one neighbor in each coordinate direction (i.e. each cell has at least a left or right, and at least an upper or lower neighbor in 2d). This is a necessary precondition for some algorithms that compute finite differences between cells. The DerivativeApproximation class is one of these algorithms that require that a triangulation is coarsest_level_1 unless all cells already have at least one neighbor in each coordinate direction on the coarsest level.
allow_anisotropic_smoothing	This flag is not included in `maximum_smoothing`. The flag is concerned with the following case: consider the case that an unrefined and a refined cell share a common face and that one of the children of the refined cell along the common face is flagged for further refinement. In that case, the resulting mesh would have more than one hanging node along one or more of the edges of the triangulation, a situation that is not allowed. Consequently, in order to perform the refinement, the coarser of the two original cells is also going to be refined. However, in many cases it is sufficient to refine the coarser of the two original cells in an anisotropic way to avoid the case of multiple hanging vertices on a single edge. Doing only the minimal anisotropic refinement can save cells and degrees of freedom. By specifying this flag, the library can produce these anisotropic refinements. The flag is not included by default since it may lead to anisotropically refined meshes even though no cell has ever been refined anisotropically explicitly by a user command. This surprising fact may lead to programs that do the wrong thing since they are not written for the additional cases that can happen with anisotropic meshes, see the discussion in the introduction to step-30.
eliminate_refined_inner_islands	This algorithm seeks for isolated cells which are refined or flagged for refinement. This definition is unlike that for eliminate_unrefined_islands, which would mean that an island is defined as a cell which is refined but more of its neighbors are not refined than are refined. For example, in 2d, a cell's refinement would be reverted if at most one of its neighbors is also refined (or refined but flagged for coarsening). The reason for the change in definition of an island is, that this option would be a bit dangerous, since if you consider a chain of refined cells (e.g. along a kink in the solution), the cells at the two ends would be coarsened, after which the next outermost cells would need to be coarsened. Therefore, only one loop of flagging cells like this could be done to avoid eating up the whole chain of refined cells (‘chain reaction’...). This algorithm also takes into account cells which are not actually refined but are flagged for refinement. If necessary, it takes away the refinement flag. Actually there are two versions of this flag, eliminate_refined_inner_islands and eliminate_refined_boundary_islands. The first eliminates islands defined by the definition above which are in the interior of the domain, while the second eliminates only those islands if the cell is at the boundary. The reason for this split of flags is that one often wants to eliminate such islands in the interior while those at the boundary may well be wanted, for example if one refines the mesh according to a criterion associated with a boundary integral or if one has rough boundary data.
eliminate_refined_boundary_islands	The result of this flag is very similar to eliminate_refined_inner_islands. See the documentation there.
do_not_produce_unrefined_islands	This flag prevents the occurrence of unrefined islands. In more detail: It prohibits the coarsening of a cell if 'most of the neighbors' will be refined after the step.
smoothing_on_refinement	This flag sums up all smoothing algorithms which may be performed upon refinement by flagging some more cells for refinement.
smoothing_on_coarsening	This flag sums up all smoothing algorithms which may be performed upon coarsening by flagging some more cells for coarsening.
maximum_smoothing	This flag includes all the above ones (therefore combines all smoothing algorithms implemented), with the exception of anisotropic smoothing.

Definition at line 1337 of file tria.h.

Constructor & Destructor Documentation

◆ PersistentTriangulation() [1/2]

template<int dim, int spacedim>

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

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

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

Definition at line 33 of file persistent_tria.cc.

◆ PersistentTriangulation() [2/2]

template<int dim, int spacedim>

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

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

Definition at line 41 of file persistent_tria.cc.

◆ ~PersistentTriangulation()

template<int dim, int spacedim = dim>

virtual PersistentTriangulation< dim, spacedim >::~PersistentTriangulation ( )

overridevirtualdefault

Destructor.

Member Function Documentation

◆ execute_coarsening_and_refinement()

template<int dim, int spacedim>

void PersistentTriangulation< dim, spacedim >::execute_coarsening_and_refinement ( )

overridevirtual

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

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 58 of file persistent_tria.cc.

◆ restore() [1/2]

template<int dim, int spacedim>

void PersistentTriangulation< dim, spacedim >::restore ( )

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

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

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

Definition at line 77 of file persistent_tria.cc.

◆ restore() [2/2]

template<int dim, int spacedim>

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

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

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

Definition at line 89 of file persistent_tria.cc.

◆ n_refinement_steps()

template<int dim, int spacedim>

unsigned int PersistentTriangulation< dim, spacedim >::n_refinement_steps ( ) const

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

Definition at line 115 of file persistent_tria.cc.

◆ copy_triangulation()

template<int dim, int spacedim>

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

overridevirtual

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

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

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 124 of file persistent_tria.cc.

◆ create_triangulation() [1/2]

template<int dim, int spacedim>

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

overridevirtual

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

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 137 of file persistent_tria.cc.

◆ create_triangulation() [2/2]

template<int dim, int spacedim>

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

overridevirtual

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

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

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

For conditions when this function can generate a valid triangulation, see the documentation of this class, and the GridIn and 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.; Not implemented yet.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 149 of file persistent_tria.cc.

◆ write_flags()

template<int dim, int spacedim>

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

virtual

Write all refine and coarsen flags to the ostream out.

Definition at line 161 of file persistent_tria.cc.

◆ read_flags()

template<int dim, int spacedim>

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

virtual

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

Definition at line 190 of file persistent_tria.cc.

◆ clear_flags()

template<int dim, int spacedim>

void PersistentTriangulation< dim, spacedim >::clear_flags ( )

virtual

Clear all flags. Retains the same coarse grid.

Definition at line 227 of file persistent_tria.cc.

◆ memory_consumption()

template<int dim, int spacedim>

std::size_t PersistentTriangulation< dim, spacedim >::memory_consumption ( ) const

overridevirtual

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

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 237 of file persistent_tria.cc.

◆ clear()

template<int dim, int spacedim = dim>

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

virtualinherited

Reset this triangulation into 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 in parallel::distributed::Triangulation< dim, spacedim >, parallel::TriangulationBase< dim, spacedim >, parallel::TriangulationBase< dim, dim >, and parallel::TriangulationBase< dim, spacedim >.

◆ get_mpi_communicator()

template<int dim, int spacedim = dim>

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

virtualinherited

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

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

◆ get_communicator()

template<int dim, int spacedim = dim>

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

inherited

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

Deprecated:: Use get_mpi_communicator() instead.

◆ global_active_cell_index_partitioner()

template<int dim, int spacedim = dim>

virtual std::weak_ptr< const Utilities::MPI::Partitioner > Triangulation< dim, spacedim >::global_active_cell_index_partitioner ( ) const

virtualinherited

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

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

◆ global_level_cell_index_partitioner()

template<int dim, int spacedim = dim>

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

virtualinherited

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

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

◆ set_mesh_smoothing()

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

virtualinherited

Return the mesh smoothing requirements that are obeyed.

◆ get_boundary_ids()

template<int dim, int spacedim = dim>

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

virtualinherited

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

See also: Glossary entry on boundary indicators

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

◆ flip_all_direction_flags()

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

inherited

Coarsen all cells the given number of times.

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

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

◆ prepare_coarsening_and_refinement() [1/4]

template<int dim, int spacedim = dim>

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

virtualinherited

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

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

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

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

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

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

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

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

◆ prepare_coarsening_and_refinement() [2/4]

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

inherited

Definition at line 16612 of file tria.cc.

◆ prepare_coarsening_and_refinement() [3/4]

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

inherited

Definition at line 16630 of file tria.cc.

◆ prepare_coarsening_and_refinement() [4/4]

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

inherited

Definition at line 16648 of file tria.cc.

◆ save_refine_flags() [1/2]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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

inherited

Read the information stored by save_refine_flags.

◆ load_refine_flags() [2/2]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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

inherited

Analogue to save_refine_flags.

◆ save_coarsen_flags() [2/2]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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

inherited

Analogue to load_refine_flags.

◆ load_coarsen_flags() [2/2]

template<int dim, int spacedim = dim>

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

inherited

Analogue to load_refine_flags.

◆ get_anisotropic_refinement_flag()

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

inherited

Clear all user flags. See also GlossUserFlags.

◆ save_user_flags() [1/2]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

inherited

Clear all user flags on lines. See also GlossUserFlags.

◆ save_user_flags_line() [1/2]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

inherited

Clear all user flags on quads. See also GlossUserFlags.

◆ save_user_flags_quad() [1/2]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

inherited

Clear all user flags on quads. See also GlossUserFlags.

◆ save_user_flags_hex() [1/2]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

inherited

Return an iterator pointing to the last used cell.

◆ last_active()

template<int dim, int spacedim = dim>

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

inherited

Return an iterator pointing to the last active cell.

◆ create_cell_iterator()

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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.

◆ begin_face()

template<int dim, int spacedim = dim>

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

inherited

Iterator to the first used face.

◆ begin_active_face()

template<int dim, int spacedim = dim>

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

inherited

Iterator to the first active face.

◆ end_face()

template<int dim, int spacedim = dim>

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.

◆ begin_vertex()

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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

inherited

Return the total number of active lines.

◆ n_active_lines() [2/2]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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

inherited

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

◆ n_quads() [2/8]

template<int dim, int spacedim = dim>

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 15164 of file tria.cc.

◆ n_quads() [4/8]

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

inherited

Definition at line 15172 of file tria.cc.

◆ n_quads() [5/8]

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

inherited

Definition at line 15213 of file tria.cc.

◆ n_quads() [6/8]

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

inherited

Definition at line 15221 of file tria.cc.

◆ n_quads() [7/8]

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

inherited

Definition at line 15261 of file tria.cc.

◆ n_quads() [8/8]

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

inherited

Definition at line 15269 of file tria.cc.

◆ n_active_quads() [1/8]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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 15196 of file tria.cc.

◆ n_active_quads() [4/8]

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

inherited

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

◆ n_active_quads() [6/8]

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

inherited

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

◆ n_active_quads() [8/8]

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

inherited

Definition at line 15301 of file tria.cc.

◆ n_hexs() [1/4]

template<int dim, int spacedim = dim>

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

inherited

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

◆ n_hexs() [2/4]

template<int dim, int spacedim = dim>

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 15443 of file tria.cc.

◆ n_hexs() [4/4]

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

inherited

Definition at line 15452 of file tria.cc.

◆ n_active_hexs() [1/4]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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 15472 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 15481 of file tria.cc.

◆ n_cells() [1/2]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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

inherited

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

◆ n_global_active_cells()

template<int dim, int spacedim = dim>

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

virtualinherited

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

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

◆ n_global_coarse_cells()

template<int dim, int spacedim = dim>

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

virtualinherited

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

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

◆ n_faces()

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

inherited

Return the number of levels in this triangulation.

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

◆ n_global_levels()

template<int dim, int spacedim = dim>

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

virtualinherited

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

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

◆ has_hanging_nodes()

template<int dim, int spacedim = dim>

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

virtualinherited

Return true if the triangulation has hanging nodes.

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

Reimplemented in parallel::DistributedTriangulationBase< dim, spacedim >, parallel::DistributedTriangulationBase< 1, spacedim >, and parallel::DistributedTriangulationBase< dim, dim >.

◆ n_vertices()

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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 15510 of file tria.cc.

◆ max_adjacent_cells() [3/4]

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

inherited

Definition at line 15519 of file tria.cc.

◆ max_adjacent_cells() [4/4]

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

inherited

Definition at line 15527 of file tria.cc.

◆ locally_owned_subdomain()

template<int dim, int spacedim = dim>

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

virtualinherited

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

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

◆ get_triangulation() [1/2]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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]

template<int dim, int spacedim = dim>

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 15180 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 15229 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 15277 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 15330 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 15340 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 15349 of file tria.cc.

◆ n_raw_quads() [9/9]

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

inherited

Definition at line 15369 of file tria.cc.

◆ n_raw_hexs() [1/5]

template<int dim, int spacedim = dim>

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 15188 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 15237 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 15285 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 15463 of file tria.cc.

◆ n_raw_cells()

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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() [1/2]

template<int dim, int spacedim = dim>

template<class Archive >

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.

◆ save() [2/2]

template<int dim, int spacedim = dim>

virtual void Triangulation< dim, spacedim >::save ( const std::string & file_basename ) const

virtualinherited

Save the mesh and associated information into a number of files that all use the provided basename as a starting prefix, plus some suffixes that indicate the specific use of that file.

Save the triangulation into the given file. Internally, this function calls the save function which uses BOOST archives.

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

◆ load() [1/2]

template<int dim, int spacedim = dim>

template<class Archive >

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.

◆ load() [2/2]

template<int dim, int spacedim = dim>

virtual void Triangulation< dim, spacedim >::load ( const std::string & file_basename )

virtualinherited

Load the triangulation saved with save() back in.

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

◆ add_periodicity()

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

template<class Archive >

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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.

◆ update_cell_relations()

template<int dim, int spacedim = dim>

void Triangulation< dim, spacedim >::update_cell_relations ( )

protectedinherited

A function to record the CellStatus of currently active cells. This information is mandatory to transfer data between meshes during adaptation or serialization, e.g., using SolutionTransfer.

Relations will be stored in the private member local_cell_relations. For an extensive description of CellStatus, see the documentation for the member function register_data_attach().

◆ pack_data_serial()

template<int dim, int spacedim = dim>

void Triangulation< dim, spacedim >::pack_data_serial ( )

protectedinherited

Function to pack data for SolutionTransfer::prepare_for_coarsening_and_refinement() in the case of a serial triangulation.

◆ unpack_data_serial()

template<int dim, int spacedim = dim>

void Triangulation< dim, spacedim >::unpack_data_serial ( )

protectedinherited

Function to unpack data for SolutionTransfer::interpolate() in the case of a serial triangulation.

◆ write_bool_vector()

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

protectedinherited

Recreate information about periodic neighbors from periodic_face_pairs_level_0.

◆ update_reference_cells()

template<int dim, int spacedim = dim>

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

protectedvirtualinherited

Update the internal reference_cells vector.

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

◆ begin_raw()

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

privateinherited

Reset triangulation policy.

◆ reset_active_cell_indices()

template<int dim, int spacedim = dim>

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

privateinherited

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

◆ reset_global_cell_indices()

template<int dim, int spacedim = dim>

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

privateinherited

Reset global cell ids and global level cell ids.

◆ reset_cell_vertex_indices_cache()

template<int dim, int spacedim = dim>

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

privateinherited

Reset cache for the cells' vertex indices.

◆ execute_refinement()

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

template<int dim, int spacedim = dim>

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

privateinherited

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

◆ coarse_cell_id_to_coarse_cell_index()

template<int dim, int spacedim = dim>

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

privatevirtualinherited

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

Note: For serial and shared triangulation both id and index are the same. For distributed triangulations setting both might differ, since the id might correspond to a global id and the index to a local id. If a cell does not exist locally, the returned value is numbers::invalid_unsigned_int.

Parameters

coarse_cell_id Unique id of the coarse cell.

Returns: Index of the coarse cell within the current triangulation.

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

◆ coarse_cell_index_to_coarse_cell_id()

template<int dim, int spacedim = dim>

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

privatevirtualinherited

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

Note: See the note of the method coarse_cell_id_to_coarse_cell_index().

Parameters

coarse_cell_index Index of the coarse cell.

Returns: Id of the coarse cell.

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

◆ n_subscriptions()

unsigned int EnableObserverPointer::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 339 of file enable_observer_pointer.h.

◆ list_subscribers() [1/2]

template<typename StreamType >

void EnableObserverPointer::list_subscribers ( StreamType & stream ) const

inlineinherited

List the subscribers to the input stream.

Definition at line 356 of file enable_observer_pointer.h.

◆ list_subscribers() [2/2]

void EnableObserverPointer::list_subscribers ( ) const

inherited

List the subscribers to deallog.

Definition at line 199 of file enable_observer_pointer.cc.

◆ subscribe()

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

privateinherited

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

Definition at line 131 of file enable_observer_pointer.cc.

◆ unsubscribe()

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

privateinherited

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 151 of file enable_observer_pointer.cc.

◆ check_no_subscribers()

void EnableObserverPointer::check_no_subscribers ( ) const

privatenoexceptinherited

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

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

Definition at line 53 of file enable_observer_pointer.cc.

Member Data Documentation

◆ dimension

template<int dim, int spacedim>

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

staticconstexpr

Make the dimension available in function templates.

Definition at line 113 of file persistent_tria.h.

◆ spacedimension

template<int dim, int spacedim>

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

static

Definition at line 114 of file persistent_tria.h.

◆ coarse_grid

template<int dim, int spacedim = dim>

ObserverPointer<const Triangulation<dim, spacedim>, PersistentTriangulation<dim, spacedim> > PersistentTriangulation< dim, spacedim >::coarse_grid

private

This grid shall be used as coarse grid.

Definition at line 255 of file persistent_tria.h.

◆ refine_flags

template<int dim, int spacedim = dim>

std::vector<std::vector<bool> > PersistentTriangulation< dim, spacedim >::refine_flags

private

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

Definition at line 262 of file persistent_tria.h.

◆ coarsen_flags

template<int dim, int spacedim = dim>

std::vector<std::vector<bool> > PersistentTriangulation< dim, spacedim >::coarsen_flags

private

refine_flags

Definition at line 267 of file persistent_tria.h.

◆ space_dimension

template<int dim, int spacedim = dim>

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

staticconstexprinherited

Make the space-dimension available in function templates.

Definition at line 1748 of file tria.h.

◆ CELL_PERSIST

template<int dim, int spacedim = dim>

constexpr auto Triangulation< dim, spacedim >::CELL_PERSIST

staticconstexprinherited

Initial value:

=

::CellStatus::cell_will_persist

CellStatus::cell_will_persist

@ cell_will_persist

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

Definition at line 2247 of file tria.h.

◆ CELL_REFINE

template<int dim, int spacedim = dim>

constexpr auto Triangulation< dim, spacedim >::CELL_REFINE

staticconstexprinherited

Initial value:

=

::CellStatus::cell_will_be_refined

CellStatus::cell_will_be_refined

@ cell_will_be_refined

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

Definition at line 2254 of file tria.h.

◆ CELL_COARSEN

template<int dim, int spacedim = dim>

constexpr auto Triangulation< dim, spacedim >::CELL_COARSEN

staticconstexprinherited

Initial value:

=

::CellStatus::children_will_be_coarsened

CellStatus::children_will_be_coarsened

@ children_will_be_coarsened

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

Definition at line 2261 of file tria.h.

◆ CELL_INVALID

template<int dim, int spacedim = dim>

constexpr auto Triangulation< dim, spacedim >::CELL_INVALID

staticconstexprinherited

Initial value:

=

::CellStatus::cell_invalid

CellStatus::cell_invalid

@ cell_invalid

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

Definition at line 2268 of file tria.h.

◆ signals

template<int dim, int spacedim = dim>

Signals Triangulation< dim, spacedim >::signals

mutableinherited

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

Definition at line 2526 of file tria.h.

◆ cell_attached_data

template<int dim, int spacedim = dim>

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

inherited

Definition at line 3877 of file tria.h.

◆ local_cell_relations

template<int dim, int spacedim = dim>

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

◆ data_serializer

template<int dim, int spacedim = dim>

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

protectedinherited

Definition at line 3945 of file tria.h.

◆ smooth_grid

template<int dim, int spacedim = dim>

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

◆ reference_cells

template<int dim, int spacedim = dim>

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

◆ policy

template<int dim, int spacedim = dim>

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

◆ periodic_face_pairs_level_0

template<int dim, int spacedim = dim>

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

◆ periodic_face_map

template<int dim, int spacedim = dim>

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

◆ levels

template<int dim, int spacedim = dim>

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

◆ faces

template<int dim, int spacedim = dim>

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

◆ vertices

template<int dim, int spacedim = dim>

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

privateinherited

Array of the vertices of this triangulation.

Definition at line 4496 of file tria.h.

◆ vertices_used

template<int dim, int spacedim = dim>

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

privateinherited

Array storing a bit-pattern which vertices are used.

Definition at line 4501 of file tria.h.

◆ manifolds

template<int dim, int spacedim = dim>

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

privateinherited

Collection of Manifold objects.

Definition at line 4507 of file tria.h.

◆ anisotropic_refinement

template<int dim, int spacedim = dim>

bool Triangulation< dim, spacedim >::anisotropic_refinement

privateinherited

Flag indicating whether anisotropic refinement took place.

Definition at line 4512 of file tria.h.

◆ check_for_distorted_cells

template<int dim, int spacedim = dim>

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

◆ number_cache

template<int dim, int spacedim = dim>

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

privateinherited

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

Definition at line 4530 of file tria.h.

◆ vertex_to_boundary_id_map_1d

template<int dim, int spacedim = dim>

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

◆ vertex_to_manifold_id_map_1d

template<int dim, int spacedim = dim>

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

◆ counter

std::atomic<unsigned int> EnableObserverPointer::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 212 of file enable_observer_pointer.h.

◆ counter_map

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

mutableprivateinherited

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

Definition at line 218 of file enable_observer_pointer.h.

◆ validity_pointers

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

mutableprivateinherited

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

Definition at line 234 of file enable_observer_pointer.h.

◆ object_info

const std::type_info* EnableObserverPointer::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 242 of file enable_observer_pointer.h.

◆ mutex

std::mutex EnableObserverPointer::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 249 of file enable_observer_pointer.h.

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

include/deal.II/grid/persistent_tria.h
source/grid/persistent_tria.cc

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Serialization facilities.

Detailed Description

Usage

Member Typedef Documentation

◆ IteratorSelector

◆ level_cell_iterator

◆ CellStatus

◆ raw_cell_iterator

◆ raw_face_iterator

◆ raw_vertex_iterator

◆ raw_line_iterator

◆ raw_quad_iterator

◆ raw_hex_iterator

◆ map_value_type

◆ map_iterator

Member Enumeration Documentation

◆ MeshSmoothing

Constructor & Destructor Documentation

◆ PersistentTriangulation() [1/2]

◆ PersistentTriangulation() [2/2]

◆ ~PersistentTriangulation()

Member Function Documentation

◆ execute_coarsening_and_refinement()

◆ restore() [1/2]

◆ restore() [2/2]

◆ n_refinement_steps()

◆ copy_triangulation()

◆ create_triangulation() [1/2]

◆ create_triangulation() [2/2]

◆ write_flags()

◆ read_flags()

◆ clear_flags()

◆ memory_consumption()

◆ clear()

◆ get_mpi_communicator()

◆ get_communicator()

◆ global_active_cell_index_partitioner()

◆ global_level_cell_index_partitioner()

◆ set_mesh_smoothing()

◆ get_mesh_smoothing()

◆ get_boundary_ids()

◆ flip_all_direction_flags()

◆ set_all_refine_flags()

◆ refine_global()

◆ coarsen_global()

◆ prepare_coarsening_and_refinement() [1/4]

◆ prepare_coarsening_and_refinement() [2/4]

◆ prepare_coarsening_and_refinement() [3/4]

◆ prepare_coarsening_and_refinement() [4/4]

◆ save_refine_flags() [1/2]

◆ save_refine_flags() [2/2]

◆ load_refine_flags() [1/2]

◆ load_refine_flags() [2/2]

◆ save_coarsen_flags() [1/2]

◆ save_coarsen_flags() [2/2]

◆ load_coarsen_flags() [1/2]

◆ load_coarsen_flags() [2/2]

◆ get_anisotropic_refinement_flag()

◆ clear_user_flags()

◆ save_user_flags() [1/2]

◆ save_user_flags() [2/2]

◆ load_user_flags() [1/2]

◆ load_user_flags() [2/2]

◆ clear_user_flags_line()

◆ save_user_flags_line() [1/2]

◆ save_user_flags_line() [2/2]

◆ load_user_flags_line() [1/2]

◆ load_user_flags_line() [2/2]