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

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

Public Types
enum	Settings { default_setting = 0x0 , mesh_reconstruction_after_repartitioning = 0x1 , construct_multigrid_hierarchy = 0x2 , no_automatic_repartitioning = 0x4 }

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

using	active_cell_iterator = typename ::Triangulation< dim, spacedim >::active_cell_iterator

using	CellStatus = typename ::Triangulation< dim, spacedim >::CellStatus

enum	MeshSmoothing

using	level_cell_iterator = cell_iterator

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

Public Member Functions
	Triangulation (const MPI_Comm &mpi_communicator, const typename ::Triangulation< dim, spacedim >::MeshSmoothing smooth_grid=(::Triangulation< dim, spacedim >::none), const Settings settings=default_setting)

virtual	~Triangulation () override

virtual void	clear () override

bool	is_multilevel_hierarchy_constructed () const override

void	execute_transfer (const typename ::internal::p4est::types< dim >::forest parallel_forest, const typename ::internal::p4est::types< dim >::gloidx previous_global_first_quadrant)

virtual void	copy_triangulation (const ::Triangulation< dim, spacedim > &other_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	execute_coarsening_and_refinement () override

virtual bool	prepare_coarsening_and_refinement () override

void	repartition ()

virtual bool	has_hanging_nodes () const override

virtual std::size_t	memory_consumption () const override

virtual std::size_t	memory_consumption_p4est () const

void	write_mesh_vtk (const std::string &file_basename) const

unsigned int	get_checksum () const

virtual void	save (const std::string &filename) const override

virtual void	load (const std::string &filename, const bool autopartition=true) override

void	load (const typename ::internal::p4est::types< dim >::forest *forest)

const std::vector< types::global_dof_index > &	get_p4est_tree_to_coarse_cell_permutation () const

const std::vector< types::global_dof_index > &	get_coarse_cell_to_p4est_tree_permutation () const

const ::internal::p4est::types< dim >::forest *	get_p4est () const

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

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)

virtual MPI_Comm	get_communicator () const override

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

unsigned int	n_locally_owned_active_cells () const

virtual types::global_cell_index	n_global_active_cells () const override

virtual unsigned int	n_global_levels () const override

types::subdomain_id	locally_owned_subdomain () const override

const std::set< types::subdomain_id > &	ghost_owners () const

const std::set< types::subdomain_id > &	level_ghost_owners () const

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

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

virtual std::map< unsigned int, std::set<::types::subdomain_id > >	compute_vertices_with_ghost_neighbors () const

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

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

void	communicate_locally_moved_vertices (const std::vector< bool > &vertex_locally_moved)

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 void	create_triangulation_compatibility (const std::vector< Point< spacedim > > &vertices, const std::vector< CellData< dim > > &cells, const SubCellData &subcelldata)

void	flip_all_direction_flags ()

unsigned int	n_quads () const

unsigned int	n_quads (const unsigned int) const

unsigned int	n_quads () const

unsigned int	n_quads (const unsigned int) const

unsigned int	n_quads () const

unsigned int	n_quads (const unsigned int) const

unsigned int	n_active_quads (const unsigned int) const

unsigned int	n_active_quads () const

unsigned int	n_active_quads (const unsigned int) const

unsigned int	n_active_quads () const

unsigned int	n_active_quads (const unsigned int) const

unsigned int	n_active_quads () const

unsigned int	n_hexs () const

unsigned int	n_hexs (const unsigned int level) const

unsigned int	n_active_hexs () const

unsigned int	n_active_hexs (const unsigned int level) const

unsigned int	max_adjacent_cells () const

unsigned int	max_adjacent_cells () const

unsigned int	max_adjacent_cells () const

unsigned int	n_raw_quads (const unsigned int) const

unsigned int	n_raw_quads (const unsigned int) const

unsigned int	n_raw_quads (const unsigned int) const

unsigned int	n_raw_quads (const unsigned int level) const

unsigned int	n_raw_quads (const unsigned int level) const

unsigned int	n_raw_quads (const unsigned int) const

unsigned int	n_raw_quads () const

unsigned int	n_raw_hexs (const unsigned int) const

unsigned int	n_raw_hexs (const unsigned int) const

unsigned int	n_raw_hexs (const unsigned int) const

unsigned int	n_raw_hexs (const unsigned int level) const

Internal information about the number of objects
void	save (Archive &ar, const unsigned int version) const

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

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

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

const std::map< std::pair< cell_iterator, unsigned int >, std::pair< std::pair< cell_iterator, unsigned int >, std::bitset< 3 > > > &	get_periodic_face_map () const

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

bool	all_reference_cells_are_hyper_cube () const

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

Mesh refinement
void	set_all_refine_flags ()

void	refine_global (const unsigned int times=1)

void	coarsen_global (const unsigned int times=1)

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

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

void	load_refine_flags (std::istream &in)

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

void	save_coarsen_flags (std::ostream &out) const

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

void	load_coarsen_flags (std::istream &out)

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

bool	get_anisotropic_refinement_flag () const

User data
void	clear_user_flags ()

void	save_user_flags (std::ostream &out) const

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

void	load_user_flags (std::istream &in)

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

void	clear_user_flags_line ()

void	save_user_flags_line (std::ostream &out) const

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

void	load_user_flags_line (std::istream &in)

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

void	clear_user_flags_quad ()

void	save_user_flags_quad (std::ostream &out) const

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

void	load_user_flags_quad (std::istream &in)

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

void	clear_user_flags_hex ()

void	save_user_flags_hex (std::ostream &out) const

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

void	load_user_flags_hex (std::istream &in)

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

void	clear_user_data ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

active_cell_iterator	begin_active (const unsigned int level=0) const

cell_iterator	end () const

cell_iterator	end (const unsigned int level) const

active_cell_iterator	end_active (const unsigned int level) const

cell_iterator	last () const

active_cell_iterator	last_active () const

cell_iterator	create_cell_iterator (const CellId &cell_id) const

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

unsigned int	n_faces () const

unsigned int	n_active_faces () const

unsigned int	n_levels () const

unsigned int	n_vertices () const

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

unsigned int	n_used_vertices () const

bool	vertex_used (const unsigned int index) const

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

unsigned int	max_adjacent_cells () const

Triangulation< dim, spacedim > &	get_triangulation ()

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

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

Static Public Attributes
static const unsigned int	dimension

static const unsigned int	space_dimension

Protected Types
using	cell_relation_t = typename std::pair< cell_iterator, CellStatus >

Protected Member Functions
void	save_attached_data (const unsigned int global_first_cell, const unsigned int global_num_cells, const std::string &filename) 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 &filename, const unsigned int n_attached_deserialize_fixed, const unsigned int n_attached_deserialize_variable)

virtual void	update_number_cache ()

void	update_reference_cells () override

void	reset_global_cell_indices ()

Protected Attributes
std::vector< cell_relation_t >	local_cell_relations

CellAttachedData	cell_attached_data

DataTransfer	data_transfer

const MPI_Comm	mpi_communicator

types::subdomain_id	my_subdomain

types::subdomain_id	n_subdomains

NumberCache	number_cache

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

Private Member Functions
virtual void	update_cell_relations () override

typename::internal::p4est::types< dim >::tree *	init_tree (const int dealii_coarse_cell_index) const

void	setup_coarse_cell_to_p4est_tree_permutation ()

void	copy_new_triangulation_to_p4est (std::integral_constant< int, 2 >)

void	copy_new_triangulation_to_p4est (std::integral_constant< int, 3 >)

void	copy_local_forest_to_triangulation ()

std::vector< unsigned int >	get_cell_weights () const

std::vector< bool >	mark_locally_active_vertices_on_level (const int level) const

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

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

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

Private Attributes
Settings	settings

bool	triangulation_has_content

typename::internal::p4est::types< dim >::connectivity *	connectivity

typename::internal::p4est::types< dim >::forest *	parallel_forest

typename::internal::p4est::types< dim >::ghost *	parallel_ghost

std::vector< types::global_dof_index >	coarse_cell_to_p4est_tree_permutation

std::vector< types::global_dof_index >	p4est_tree_to_coarse_cell_permutation

Friends
template<int , int , class >
class	::FETools::internal::ExtrapolateImplementation

template<int , int >
class	TemporarilyMatchRefineFlags

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

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

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

MeshSmoothing	smooth_grid

std::vector< ReferenceCell >	reference_cells

void	update_periodic_face_map ()

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

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

static ::ExceptionBase &	ExcInconsistentCoarseningFlags ()

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)

Hex iterator functions for internal use
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 > > >	manifold

bool	anisotropic_refinement

const bool	check_for_distorted_cells

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

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

raw_hex_iterator	begin_raw_hex (const unsigned int level=0) const

hex_iterator	begin_hex (const unsigned int level=0) const

active_hex_iterator	begin_active_hex (const unsigned int level=0) const

hex_iterator	end_hex () const

void	clear_despite_subscriptions ()

void	reset_policy ()

void	reset_active_cell_indices ()

void	reset_cell_vertex_indices_cache ()

DistortedCellList	execute_refinement ()

void	execute_coarsening ()

void	fix_coarsen_flags ()

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

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

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

unsigned int	n_subscriptions () const

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

void	list_subscribers () const

void	check_no_subscribers () const noexcept

using	map_value_type = decltype(counter_map)::value_type

using	map_iterator = decltype(counter_map)::iterator

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

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

static std::mutex	mutex

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

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

Detailed Description

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

This class acts like the Triangulation class, but it distributes the mesh across a number of different processors when using MPI. The class's interface does not add a lot to the Triangulation class but there are a number of difficult algorithms under the hood that ensure we always have a load-balanced, fully distributed mesh. Use of this class is explained in step-40, step-32, the Parallel computing with multiple processors using distributed memory documentation module, as well as the distributed_paper. See there for more information. This class satisfies the MeshType concept.

Note: This class does not support anisotropic refinement, because it relies on the p4est library that does not support this. Attempts to refine cells anisotropically will result in errors.; There is currently no support for distributing 1d triangulations.

Interaction with boundary description

Refining and coarsening a distributed triangulation is a complicated process because cells may have to be migrated from one processor to another. On a single processor, materializing that part of the global mesh that we want to store here from what we have stored before therefore may involve several cycles of refining and coarsening the locally stored set of cells until we have finally gotten from the previous to the next triangulation. This process is described in more detail in the distributed_paper. Unfortunately, in this process, some information can get lost relating to flags that are set by user code and that are inherited from mother to child cell but that are not moved along with a cell if that cell is migrated from one processor to another.

An example are boundary indicators. Assume, for example, that you start with a single cell that is refined once globally, yielding four children. If you have four processors, each one owns one cell. Assume now that processor 1 sets the boundary indicators of the external boundaries of the cell it owns to 42. Since processor 0 does not own this cell, it doesn't set the boundary indicators of its ghost cell copy of this cell. Now, assume we do several mesh refinement cycles and end up with a configuration where this processor suddenly finds itself as the owner of this cell. If boundary indicator 42 means that we need to integrate Neumann boundary conditions along this boundary, then processor 0 will forget to do so because it has never set the boundary indicator along this cell's boundary to 42.

The way to avoid this dilemma is to make sure that things like setting boundary indicators or material ids is done immediately every time a parallel triangulation is refined. This is not necessary for sequential triangulations because, there, these flags are inherited from mother to child cell and remain with a cell even if it is refined and the children are later coarsened again, but this does not hold for distributed triangulations. It is made even more difficult by the fact that in the process of refining a parallel distributed triangulation, the triangulation may call Triangulation::execute_coarsening_and_refinement multiple times and this function needs to know about boundaries. In other words, it is not enough to just set boundary indicators on newly created faces only after calling distributed::parallel::TriangulationBase::execute_coarsening_and_refinement: it actually has to happen while that function is still running.

The way to do this is by writing a function that sets boundary indicators and that will be called by the Triangulation class. The triangulation does not provide a pointer to itself to the function being called, nor any other information, so the trick is to get this information into the function. C++ provides a nice mechanism for this that is best explained using an example:

#include <functional>
 
template <int dim>
void set_boundary_ids (
  parallel::distributed::Triangulation<dim> &triangulation)
{
  ... set boundary indicators on the triangulation object ...
}
 
template <int dim>
void
MyClass<dim>::create_coarse_mesh (
  parallel::distributed::Triangulation<dim> &coarse_grid) const
{
  ... create the coarse mesh ...
 
  coarse_grid.signals.post_refinement.connect(
    [&coarse_grid](){
      set_boundary_ids<dim>(coarse_grid);
    });
}

The object passed as argument to connect is an object that can be called like a function with no arguments. It does so by wrapping a function that does, in fact, take an argument but this one argument is stored as a reference to the coarse grid triangulation when the lambda function is created. After each refinement step, the triangulation will then call the object so created which will in turn call set_boundary_ids<dim> with the reference to the coarse grid as argument.

This approach can be generalized. In the example above, we have used a global function that will be called. However, sometimes it is necessary that this function is in fact a member function of the class that generates the mesh, for example because it needs to access run-time parameters. This can be achieved as follows: assuming the set_boundary_ids() function has been declared as a (non- static, but possibly private) member function of the MyClass class, then the following will work:

#include <functional>
 
template <int dim>
void
MyClass<dim>::set_boundary_ids (
  parallel::distributed::Triangulation<dim> &triangulation) const
{
  ... set boundary indicators on the triangulation object ...
}
 
template <int dim>
void
MyClass<dim>::create_coarse_mesh (
  parallel::distributed::Triangulation<dim> &coarse_grid) const
{
  ... create the coarse mesh ...
 
  coarse_grid.signals.post_refinement.connect(
    [this, &coarse_grid]()
    {
      this->set_boundary_ids(coarse_grid);
    });
}

The lambda function above again is an object that can be called like a global function with no arguments, and this object in turn calls the current object's member function set_boundary_ids with a reference to the triangulation to work on. Note that because the create_coarse_mesh function is declared as const, it is necessary that the set_boundary_ids function is also declared const.

Note:For reasons that have to do with the way the parallel::distributed::Triangulation is implemented, functions that have been attached to the post-refinement signal of the triangulation are called more than once, sometimes several times, every time the triangulation is actually refined.

Definition at line 249 of file tria.h.

Member Typedef Documentation

◆ CellStatus

template<int dim, int spacedim = dim>

using parallel::distributed::Triangulation< dim, spacedim >::CellStatus = typename ::Triangulation<dim, spacedim>::CellStatus

Definition at line 294 of file tria.h.

◆ cell_relation_t

using parallel::DistributedTriangulationBase< dim, spacedim >::cell_relation_t = typename std::pair<cell_iterator, CellStatus>

protectedinherited

Auxiliary data structure for assigning a CellStatus to a deal.II cell iterator. For an extensive description of the former, see the documentation for the member function register_data_attach().

Definition at line 708 of file tria_base.h.

◆ IteratorSelector

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

◆ level_cell_iterator

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

inherited

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

Definition at line 1367 of file tria.h.

◆ face_iterator

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

inherited

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

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

Definition at line 1400 of file tria.h.

◆ active_face_iterator

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

inherited

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

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

Definition at line 1413 of file tria.h.

◆ vertex_iterator

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

inherited

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

Definition at line 1424 of file tria.h.

◆ active_vertex_iterator

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

inherited

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

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

Definition at line 1438 of file tria.h.

◆ line_iterator

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

inherited

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

Definition at line 1448 of file tria.h.

◆ active_line_iterator

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

inherited

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

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

Definition at line 1463 of file tria.h.

◆ quad_iterator

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

inherited

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

Definition at line 1472 of file tria.h.

◆ active_quad_iterator

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

inherited

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

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

Definition at line 1487 of file tria.h.

◆ hex_iterator

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

inherited

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

Definition at line 1496 of file tria.h.

◆ active_hex_iterator

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

inherited

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

Definition at line 1507 of file tria.h.

◆ raw_cell_iterator

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

◆ raw_face_iterator

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

privateinherited

Definition at line 3616 of file tria.h.

◆ raw_vertex_iterator

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

privateinherited

Definition at line 3618 of file tria.h.

◆ raw_line_iterator

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

privateinherited

Definition at line 3620 of file tria.h.

◆ raw_quad_iterator

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

privateinherited

Definition at line 3621 of file tria.h.

◆ raw_hex_iterator

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

privateinherited

Definition at line 3622 of file tria.h.

Member Enumeration Documentation

◆ Settings

template<int dim, int spacedim = dim>

enum parallel::distributed::Triangulation::Settings

Configuration flags for distributed Triangulations to be set in the constructor. Settings can be combined using bitwise OR.

Enumerator
default_setting	Default settings, other options are disabled.
mesh_reconstruction_after_repartitioning	If set, the deal.II mesh will be reconstructed from the coarse mesh every time a repartitioning in p4est happens. This can be a bit more expensive, but guarantees the same memory layout and therefore cell ordering in the deal.II mesh. As assembly is done in the deal.II cell ordering, this flag is required to get reproducible behavior after snapshot/resume.
construct_multigrid_hierarchy	This flags needs to be set to use the geometric multigrid functionality. This option requires additional computation and communication.
no_automatic_repartitioning	Setting this flag will disable automatic repartitioning of the cells after a refinement cycle. It can be executed manually by calling repartition().

Definition at line 301 of file tria.h.

◆ MeshSmoothing

enum Triangulation::MeshSmoothing

inherited

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

Definition at line 1142 of file tria.h.

Constructor & Destructor Documentation

◆ Triangulation()

template<int dim, int spacedim>

Triangulation< dim, spacedim >::Triangulation	(	const MPI_Comm &	mpi_communicator,
		const typename ::Triangulation< dim, spacedim >::MeshSmoothing	smooth_grid = `(::Triangulation<dim, spacedim>::none)`,
		const Settings	settings = `default_setting`
	)

explicit

Constructor.

Parameters

mpi_communicator	The MPI communicator to be used for the triangulation.
smooth_grid	Degree and kind of mesh smoothing to be applied to the mesh. See the Triangulation class for a description of the kinds of smoothing operations that can be applied.
settings	See the description of the Settings enumerator. Providing `construct_multigrid_hierarchy` enforces `Triangulation::limit_level_difference_at_vertices` for smooth_grid.

Note: This class does not currently support the check_for_distorted_cells argument provided by the base class.; While it is possible to pass all of the mesh smoothing flags listed in the base class to objects of this type, it is not always possible to honor all of these smoothing options if they would require knowledge of refinement/coarsening flags on cells not locally owned by this processor. As a consequence, for some of these flags, the ultimate number of cells of the parallel triangulation may depend on the number of processors into which it is partitioned. On the other hand, if no smoothing flags are passed, if you always mark the same cells of the mesh, you will always get the exact same refined mesh independent of the number of processors into which the triangulation is partitioned.

Definition at line 1113 of file tria.cc.

◆ ~Triangulation()

template<int dim, int spacedim>

Triangulation< dim, spacedim >::~Triangulation

overridevirtual

Destructor.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 1141 of file tria.cc.

Member Function Documentation

◆ clear()

template<int dim, int spacedim>

void Triangulation< dim, spacedim >::clear

overridevirtual

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

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

Reimplemented from parallel::DistributedTriangulationBase< dim, dim >.

Definition at line 1228 of file tria.cc.

◆ is_multilevel_hierarchy_constructed()

template<int dim, int spacedim>

bool Triangulation< dim, spacedim >::is_multilevel_hierarchy_constructed

overridevirtual

Return if multilevel hierarchy is supported and has been constructed.

Implements parallel::TriangulationBase< dim, spacedim >.

Definition at line 1264 of file tria.cc.

◆ execute_transfer()

template<int dim, int spacedim>

void Triangulation< dim, spacedim >::execute_transfer	(	const typename ::internal::p4est::types< dim >::forest *	parallel_forest,
		const typename ::internal::p4est::types< dim >::gloidx *	previous_global_first_quadrant
	)

Transfer data across forests.

Besides the actual parallel_forest, which has been already refined and repartitioned, this function also needs information about its previous state, i.e. the locally owned intervals in p4est's sc_array of each processor. This information needs to be memcopyied out of the old p4est object and has to be provided via the parameter previous_global_first_quadrant.

Data has to be previously packed with DistributedTriangulationBase::DataTransfer::pack_data().

Definition at line 1274 of file tria.cc.

◆ copy_triangulation() [1/2]

template<int dim, int spacedim>

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

overridevirtual

Implementation of the same function as in the base class.

Note: This function can be used to copy a serial Triangulation to a parallel::distributed::Triangulation but only if the serial Triangulation has never been refined.

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

Definition at line 3250 of file tria.cc.

◆ create_triangulation() [1/2]

template<int dim, int spacedim>

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

overridevirtual

Create a triangulation as documented in the base class.

This function also sets up the various data structures necessary to distribute a mesh across a number of processors. This will be necessary once the mesh is being refined, though we will always keep the entire coarse mesh that is generated by this function on all processors.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 1162 of file tria.cc.

◆ create_triangulation() [2/2]

template<int dim, int spacedim>

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

overridevirtual

Create a triangulation as documented in the base class.

This function also sets up the various data structures necessary to distribute a mesh across a number of processors. This will be necessary once the mesh is being refined, though we will always keep the entire coarse mesh that is generated by this function on all processors.

Note: Not implemented yet.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 1215 of file tria.cc.

◆ execute_coarsening_and_refinement()

template<int dim, int spacedim>

void Triangulation< dim, spacedim >::execute_coarsening_and_refinement

overridevirtual

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

Since the current processor only has control over those cells it owns (i.e. the ones for which cell->subdomain_id() == this->locally_owned_subdomain()), refinement and coarsening flags are only respected for those locally owned cells. Flags may be set on other cells as well (and may often, in fact, if you call Triangulation::prepare_coarsening_and_refinement()) but will be largely ignored: the decision to refine the global mesh will only be affected by flags set on locally owned cells.

Note: This function by default partitions the mesh in such a way that the number of cells on all processors is roughly equal. If you want to set weights for partitioning, e.g. because some cells are more expensive to compute than others, you can use the signal cell_weight as documented in the Triangulation class. This function will check whether a function is connected to the signal and if so use it. If you prefer to repartition the mesh yourself at user-defined intervals only, you can create your triangulation object by passing the parallel::distributed::Triangulation::no_automatic_repartitioning flag to the constructor, which ensures that calling the current function only refines and coarsens the triangulation, but doesn't partition it. You can then call the repartition() function manually. The usage of the cell_weights signal is identical in both cases, if a function is connected to the signal it will be used to balance the calculated weights, otherwise the number of cells is balanced.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 2583 of file tria.cc.

◆ prepare_coarsening_and_refinement()

template<int dim, int spacedim>

bool Triangulation< dim, spacedim >::prepare_coarsening_and_refinement

overridevirtual

Override the implementation of prepare_coarsening_and_refinement from the base class. This is necessary if periodic boundaries are enabled and the level difference over vertices over the periodic boundary must not be more than 2:1.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 2203 of file tria.cc.

◆ repartition()

template<int dim, int spacedim>

void Triangulation< dim, spacedim >::repartition

Manually repartition the active cells between processors. Normally this repartitioning will happen automatically when calling execute_coarsening_and_refinement() (or refine_global()) unless the no_automatic_repartitioning is set in the constructor. Setting the flag and then calling repartition() gives the same result.

If you want to transfer data (using SolutionTransfer or manually with register_data_attach() and notify_ready_to_unpack()), you need to set it up twice: once when calling execute_coarsening_and_refinement(), which will handle coarsening and refinement but obviously won't ship any data between processors, and a second time when calling repartition(). Here, no coarsening and refinement will be done but information will be packed and shipped to different processors. In other words, you probably want to treat a call to repartition() in the same way as execute_coarsening_and_refinement() with respect to dealing with data movement (SolutionTransfer, etc.).

Note: If no function is connected to the cell_weight signal described in the Triangulation class, this function will balance the number of cells on each processor. If one or more functions are connected, it will calculate the sum of the weights and balance the weights across processors. The only requirement on the weights is that every cell's weight is positive and that the sum over all weights on all processors can be formed using a 64-bit integer. Beyond that, it is your choice how you want to interpret the weights. A common approach is to consider the weights proportional to the cost of doing computations on a cell, e.g., by summing the time for assembly and solving. In practice, determining this cost is of course not trivial since we don't solve on isolated cells, but on the entire mesh. In such cases, one could, for example, choose the weight equal to the number of unknowns per cell (in the context of hp-finite element methods), or using a heuristic that estimates the cost on each cell depending on whether, for example, one has to run some expensive algorithm on some cells but not others (such as forming boundary integrals during the assembly only on cells that are actually at the boundary, or computing expensive nonlinear terms only on some cells but not others, e.g., in the elasto-plastic problem in step-42).

Definition at line 2839 of file tria.cc.

◆ has_hanging_nodes()

template<int dim, int spacedim>

bool Triangulation< dim, spacedim >::has_hanging_nodes

overridevirtual

Return true if the triangulation has hanging nodes.

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

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 1368 of file tria.cc.

◆ memory_consumption()

template<int dim, int spacedim>

std::size_t Triangulation< dim, spacedim >::memory_consumption

overridevirtual

Return the local memory consumption in bytes.

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

Definition at line 3210 of file tria.cc.

◆ memory_consumption_p4est()

template<int dim, int spacedim>

std::size_t Triangulation< dim, spacedim >::memory_consumption_p4est

virtual

Return the local memory consumption contained in the p4est data structures alone. This is already contained in memory_consumption() but made available separately for debugging purposes.

Definition at line 3238 of file tria.cc.

◆ write_mesh_vtk()

template<int dim, int spacedim>

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

A collective operation that produces a sequence of output files with the given file base name that contain the mesh in VTK format.

More than anything else, this function is useful for debugging the interface between deal.II and p4est.

Definition at line 1412 of file tria.cc.

◆ get_checksum()

template<int dim, int spacedim>

unsigned int Triangulation< dim, spacedim >::get_checksum

Produce a check sum of the triangulation. This is a collective operation and is mostly useful for debugging purposes.

Definition at line 1667 of file tria.cc.

◆ save() [1/2]

template<int dim, int spacedim>

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

overridevirtual

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

Implements parallel::DistributedTriangulationBase< dim, dim >.

Definition at line 1425 of file tria.cc.

◆ load() [1/3]

template<int dim, int spacedim>

void Triangulation< dim, spacedim >::load	(	const std::string &	filename,
		const bool	autopartition = `true`
	)

overridevirtual

Load the refinement information saved with save() back in. The mesh must contain the same coarse mesh that was used in save() before calling this function.

You do not need to load with the same number of MPI processes that you saved with. Rather, if a mesh is loaded with a different number of MPI processes than used at the time of saving, the mesh is repartitioned appropriately. Cell-based data that was saved with DistributedTriangulationBase::DataTransfer::register_data_attach() can be read in with DistributedTriangulationBase::DataTransfer::notify_ready_to_unpack() after calling load().

If you use p4est version > 0.3.4.2 the autopartition flag tells p4est to ignore the partitioning that the triangulation had when it was saved and make it uniform upon loading. If autopartition is set to false, the triangulation is only repartitioned if needed (i.e. if a different number of MPI processes is encountered).

Implements parallel::DistributedTriangulationBase< dim, dim >.

Definition at line 1480 of file tria.cc.

◆ load() [2/3]

template<int dim, int spacedim>

void Triangulation< dim, spacedim >::load ( const typename ::internal::p4est::types< dim >::forest * forest )

Load the refinement information from a given parallel forest. This forest might be obtained from the function call to parallel::distributed::Triangulation::get_p4est().

Definition at line 1614 of file tria.cc.

◆ get_p4est_tree_to_coarse_cell_permutation()

template<int dim, int spacedim>

const std::vector< types::global_dof_index > & Triangulation< dim, spacedim >::get_p4est_tree_to_coarse_cell_permutation

Return a permutation vector for the order the coarse cells are handed off to p4est. For example the value of the \(i\)th element in this vector is the index of the deal.II coarse cell (counting from begin(0)) that corresponds to the \(i\)th tree managed by p4est.

Definition at line 2940 of file tria.cc.

◆ get_coarse_cell_to_p4est_tree_permutation()

template<int dim, int spacedim>

const std::vector< types::global_dof_index > & Triangulation< dim, spacedim >::get_coarse_cell_to_p4est_tree_permutation

Return a permutation vector for the mapping from the coarse deal cells to the p4est trees. This is the inverse of get_p4est_tree_to_coarse_cell_permutation.

Definition at line 2950 of file tria.cc.

◆ get_p4est()

template<int dim, int spacedim>

const ::internal::p4est::types< dim >::forest * Triangulation< dim, spacedim >::get_p4est

This returns a pointer to the internally stored p4est object (of type p4est_t or p8est_t depending on dim).

Warning: If you modify the p4est object, internal data structures can become inconsistent.

Definition at line 1679 of file tria.cc.

◆ add_periodicity() [1/2]

template<int dim, int spacedim>

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

overridevirtual

In addition to the action in the base class Triangulation, this function joins faces in the p4est forest for periodic boundary conditions. As a result, each pair of faces will differ by at most one refinement level and ghost neighbors will be available across these faces.

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. Calling this function more than once is possible, but not recommended: The function destroys and rebuilds the p4est forest each time it is called.

Definition at line 3048 of file tria.cc.

◆ update_cell_relations()

template<int dim, int spacedim>

void Triangulation< dim, spacedim >::update_cell_relations

overrideprivatevirtual

Go through all p4est trees and record the relations between locally owned p4est quadrants and active deal.II cells in the private member vector local_cell_relations.

The vector contains an active cell iterator for every locally owned p4est quadrant, as well as a CellStatus flag to describe their relation.

The stored vector will be ordered by the occurrence of quadrants in the corresponding local sc_array of the parallel_forest. p4est requires this specific ordering for its transfer functions. Therefore, the size of this vector will be equal to the number of locally owned quadrants in the parallel_forest object.

These relations will be established for example in the mesh refinement process: after adapting the parallel_forest, but before applying these changes to this triangulation, we will record how cells will change in the refinement process. With this information, we can prepare all buffers for data transfer accordingly.

Implements parallel::DistributedTriangulationBase< dim, dim >.

Definition at line 3336 of file tria.cc.

◆ init_tree()

template<int dim, int spacedim>

typename::internal::p4est::types< dim >::tree * Triangulation< dim, spacedim >::init_tree ( const int dealii_coarse_cell_index ) const

private

Return a pointer to the p4est tree that belongs to the given dealii_coarse_cell_index()

Definition at line 1690 of file tria.cc.

◆ setup_coarse_cell_to_p4est_tree_permutation()

template<int dim, int spacedim>

void Triangulation< dim, spacedim >::setup_coarse_cell_to_p4est_tree_permutation

private

The function that computes the permutation between the two data storage schemes.

Definition at line 1395 of file tria.cc.

◆ copy_new_triangulation_to_p4est() [1/2]

template<int dim, int spacedim = dim>

void parallel::distributed::Triangulation< dim, spacedim >::copy_new_triangulation_to_p4est ( std::integral_constant< int, 2 > )

private

Take the contents of a newly created triangulation we are attached to and copy it to p4est data structures.

This function exists in 2d and 3d variants.

◆ copy_new_triangulation_to_p4est() [2/2]

template<int dim, int spacedim = dim>

void parallel::distributed::Triangulation< dim, spacedim >::copy_new_triangulation_to_p4est ( std::integral_constant< int, 3 > )

private

◆ copy_local_forest_to_triangulation()

template<int dim, int spacedim>

void Triangulation< dim, spacedim >::copy_local_forest_to_triangulation

private

Copy the local part of the refined forest from p4est into the attached triangulation.

Definition at line 2245 of file tria.cc.

◆ get_cell_weights()

template<int dim, int spacedim>

std::vector< unsigned int > Triangulation< dim, spacedim >::get_cell_weights

private

Internal function notifying all registered slots to provide their weights before repartitioning occurs. Called from execute_coarsening_and_refinement() and repartition().

Returns: A vector of unsigned integers representing the weight or computational load of every cell after the refinement/coarsening/ repartition cycle. Note that the number of entries does not need to be equal to either n_active_cells() or n_locally_owned_active_cells(), because the triangulation is not updated yet. The weights are sorted in the order that p4est will encounter them while iterating over them.

Definition at line 3369 of file tria.cc.

◆ mark_locally_active_vertices_on_level()

template<int dim, int spacedim>

std::vector< bool > Triangulation< dim, spacedim >::mark_locally_active_vertices_on_level ( const int level ) const

private

This method returns a bit vector of length tria.n_vertices() indicating the locally active vertices on a level, i.e., the vertices touched by the locally owned level cells for use in geometric multigrid (possibly including the vertices due to periodic boundary conditions) are marked by true.

Used by DoFHandler::Policy::ParallelDistributed.

ensure that if one of the two vertices on a periodic face is marked as active (i.e., belonging to an owned level cell), also the other one is active

Definition at line 2960 of file tria.cc.

◆ coarse_cell_id_to_coarse_cell_index()

template<int dim, int spacedim>

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

overrideprivatevirtual

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

Note: For serial and shared triangulation both id and index are the same. For distributed triangulations setting both might differ, since the id might correspond to a global id and the index to a local id.

Parameters

coarse_cell_id Unique id of the coarse cell.

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

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 3028 of file tria.cc.

◆ coarse_cell_index_to_coarse_cell_id()

template<int dim, int spacedim>

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

overrideprivatevirtual

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

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

Parameters

coarse_cell_index Index of the coarse cell.

Returns: Id of the coarse cell.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 3038 of file tria.cc.

◆ save() [2/2]

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

inherited

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

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

◆ load() [3/3]

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

inherited

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

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

◆ register_data_attach()

unsigned int parallel::DistributedTriangulationBase< 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:

CELL_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.
CELL_REFINE: 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 CELL_REFINE, whereas the others will be marked with 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 CELL_REFINE, 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.
CELL_COARSEN: 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.
CELL_INVALID: See CELL_REFINE.

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

Definition at line 601 of file tria_base.cc.

◆ notify_ready_to_unpack()

void parallel::DistributedTriangulationBase< 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 CELL_REFINE but no longer for callbacks with status CELL_COARSEN.

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

Definition at line 655 of file tria_base.cc.

◆ save_attached_data()

void parallel::DistributedTriangulationBase< dim, spacedim >::save_attached_data	(	const unsigned int	global_first_cell,
		const unsigned int	global_num_cells,
		const std::string &	filename
	)		const

protectedinherited

Save additional cell-attached data into the given file. The first arguments are used to determine the offsets where to write buffers to.

Called by save.

Definition at line 671 of file tria_base.cc.

◆ load_attached_data()

void parallel::DistributedTriangulationBase< 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 &	filename,
		const unsigned int	n_attached_deserialize_fixed,
		const unsigned int	n_attached_deserialize_variable
	)

protectedinherited

Load additional cell-attached data from the given file, if any was saved. The first arguments are used to determine the offsets where to read buffers from.

Called by load.

Definition at line 683 of file tria_base.cc.

◆ get_communicator()

MPI_Comm parallel::TriangulationBase< dim, spacedim >::get_communicator

overridevirtualinherited

Return MPI communicator used by this triangulation.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 99 of file tria_base.cc.

◆ copy_triangulation() [2/2]

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

virtualinherited

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

Keep in mind that this function also copies the pointer to the boundary descriptor previously set by the set_manifold function. You must therefore also guarantee that the Manifold objects describing the boundary have a lifetime at least as long as the copied triangulation.

This triangulation must be empty beforehand.

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

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

◆ n_locally_owned_active_cells()

unsigned int parallel::TriangulationBase< dim, spacedim >::n_locally_owned_active_cells

inherited

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

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

Definition at line 138 of file tria_base.cc.

◆ n_global_active_cells()

types::global_cell_index parallel::TriangulationBase< dim, spacedim >::n_global_active_cells

overridevirtualinherited

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

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 146 of file tria_base.cc.

◆ n_global_levels()

unsigned int parallel::TriangulationBase< dim, spacedim >::n_global_levels

overridevirtualinherited

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

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 163 of file tria_base.cc.

◆ locally_owned_subdomain()

types::subdomain_id parallel::TriangulationBase< dim, spacedim >::locally_owned_subdomain

overridevirtualinherited

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

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 172 of file tria_base.cc.

◆ ghost_owners()

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

inherited

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

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

Definition at line 184 of file tria_base.cc.

◆ level_ghost_owners()

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

inherited

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

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

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

Definition at line 202 of file tria_base.cc.

◆ global_active_cell_index_partitioner()

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

inherited

Return partitioner for the global indices of the cells on the active level of the triangulation.

Definition at line 209 of file tria_base.cc.

◆ global_level_cell_index_partitioner()

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

inherited

Return partitioner for the global indices of the cells on the given level of the triangulation.

Definition at line 216 of file tria_base.cc.

◆ compute_vertices_with_ghost_neighbors()

std::map< unsigned int, std::set<::types::subdomain_id > > parallel::TriangulationBase< dim, spacedim >::compute_vertices_with_ghost_neighbors

virtualinherited

Return a map that, for each vertex, lists all the processors whose subdomains are adjacent to that vertex.

Deprecated:: Use GridTools::compute_vertices_with_ghost_neighbors() instead of parallel::TriangulationBase::compute_vertices_with_ghost_neighbors().

Definition at line 228 of file tria_base.cc.

◆ get_boundary_ids()

std::vector< types::boundary_id > parallel::TriangulationBase< dim, spacedim >::get_boundary_ids

overridevirtualinherited

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

See also: Glossary entry on boundary indicators

Note: This function involves a global communication gathering all current IDs from all processes.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 237 of file tria_base.cc.

◆ get_manifold_ids()

std::vector< types::manifold_id > parallel::TriangulationBase< dim, spacedim >::get_manifold_ids

overridevirtualinherited

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

See also: Glossary entry on manifold indicators

Note: This function involves a global communication gathering all current IDs from all processes.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 246 of file tria_base.cc.

◆ communicate_locally_moved_vertices()

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

inherited

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

cell->vertex(0) = new_location;

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

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

Note: It only makes sense to move vertices that are either located on locally owned cells or on cells in the ghost layer. This is because you can be sure that these vertices indeed exist on the finest mesh aggregated over all processors, whereas vertices on artificial cells but not at least in the ghost layer may or may not exist on the globally finest mesh. Consequently, the vertex_locally_moved argument may not contain vertices that aren't at least on ghost cells.; This function moves vertices in such a way that on every processor, the vertices of every locally owned and ghost cell is consistent with the corresponding location of these cells on other processors. On the other hand, the locations of artificial cells will in general be wrong since artificial cells may or may not exist on other processors and consequently it is not possible to determine their location in any way. This is not usually a problem since one never does anything on artificial cells. However, it may lead to problems if the mesh with moved vertices is refined in a later step. If that's what you want to do, the right way to do it is to save the offset applied to every vertex, call this function, and before refining or coarsening the mesh apply the opposite offset and call this function again.

Parameters

vertex_locally_moved A bitmap indicating which vertices have been moved. The size of this array must be equal to Triangulation::n_vertices() and must be a subset of those vertices flagged by GridTools::get_locally_owned_vertices().

See also: This function is used, for example, in GridTools::distort_random().

Definition at line 301 of file tria_base.cc.

◆ update_number_cache()

void parallel::TriangulationBase< dim, spacedim >::update_number_cache

protectedvirtualinherited

Update the number_cache variable after mesh creation or refinement.

Definition at line 376 of file tria_base.cc.

◆ update_reference_cells()

void parallel::TriangulationBase< dim, spacedim >::update_reference_cells

overrideprotectedvirtualinherited

Update the internal reference_cells vector.

Reimplemented from Triangulation< dim, spacedim >.

Definition at line 382 of file tria_base.cc.

◆ reset_global_cell_indices()

void parallel::TriangulationBase< dim, spacedim >::reset_global_cell_indices

protectedinherited

Reset global active cell indices and global level cell indices.

Definition at line 388 of file tria_base.cc.

◆ set_mesh_smoothing()

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

virtualinherited

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

◆ get_mesh_smoothing()

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

virtualinherited

Return the mesh smoothing requirements that are obeyed.

◆ set_manifold()

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

inherited

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

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

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

See also: Glossary entry on manifold indicators

◆ reset_manifold()

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

inherited

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

See also: Glossary entry on manifold indicators

◆ reset_all_manifolds()

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

inherited

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

See also: Glossary entry on manifold indicators

◆ set_all_manifold_ids()

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

inherited

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

See also: Glossary entry on manifold indicators

◆ set_all_manifold_ids_on_boundary() [1/2]

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

inherited

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

See also: Glossary entry on manifold indicators

◆ set_all_manifold_ids_on_boundary() [2/2]

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

inherited

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

See also: Glossary entry on manifold indicators

◆ get_manifold()

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

inherited

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

Note: If no manifold could be found, the default flat manifold is returned.

See also: Glossary entry on manifold indicators

◆ create_triangulation_compatibility()

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

virtualinherited

For backward compatibility, only. This function takes the cell data in the ordering as requested by deal.II versions up to 5.2, converts it to the new (lexicographic) ordering and calls create_triangulation().

Note: This function internally calls create_triangulation and therefore can throw the same exception as the other function.

◆ flip_all_direction_flags()

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

inherited

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

This function throws an exception if dim equals spacedim.

◆ set_all_refine_flags()

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

inherited

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

◆ refine_global()

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

inherited

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

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

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

◆ coarsen_global()

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

inherited

Coarsen all cells the given number of times.

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

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

◆ save_refine_flags() [1/2]

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

inherited

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

◆ save_refine_flags() [2/2]

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

inherited

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

◆ load_refine_flags() [1/2]

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

inherited

Read the information stored by save_refine_flags.

◆ load_refine_flags() [2/2]

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

inherited

Read the information stored by save_refine_flags.

◆ save_coarsen_flags() [1/2]

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

inherited

Analogue to save_refine_flags.

◆ save_coarsen_flags() [2/2]

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

inherited

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

◆ load_coarsen_flags() [1/2]

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

inherited

Analogue to load_refine_flags.

◆ load_coarsen_flags() [2/2]

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

inherited

Analogue to load_refine_flags.

◆ get_anisotropic_refinement_flag()

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

inherited

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

◆ clear_user_flags()

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

inherited

Clear all user flags. See also GlossUserFlags.

◆ save_user_flags() [1/2]

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

inherited

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

◆ save_user_flags() [2/2]

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

inherited

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

◆ load_user_flags() [1/2]

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

inherited

Read the information stored by save_user_flags. See also GlossUserFlags.

◆ load_user_flags() [2/2]

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

inherited

Read the information stored by save_user_flags. See also GlossUserFlags.

◆ clear_user_flags_line()

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

inherited

Clear all user flags on lines. See also GlossUserFlags.

◆ save_user_flags_line() [1/2]

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

inherited

Save the user flags on lines. See also GlossUserFlags.

◆ save_user_flags_line() [2/2]

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

inherited

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

◆ load_user_flags_line() [1/2]

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

inherited

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

◆ load_user_flags_line() [2/2]

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

inherited

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

◆ clear_user_flags_quad()

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

inherited

Clear all user flags on quads. See also GlossUserFlags.

◆ save_user_flags_quad() [1/2]

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

inherited

Save the user flags on quads. See also GlossUserFlags.

◆ save_user_flags_quad() [2/2]

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

inherited

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

◆ load_user_flags_quad() [1/2]

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

inherited

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

◆ load_user_flags_quad() [2/2]

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

inherited

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

◆ clear_user_flags_hex()

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

inherited

Clear all user flags on quads. See also GlossUserFlags.

◆ save_user_flags_hex() [1/2]

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

inherited

Save the user flags on hexs. See also GlossUserFlags.

◆ save_user_flags_hex() [2/2]

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

inherited

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

◆ load_user_flags_hex() [1/2]

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

inherited

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

◆ load_user_flags_hex() [2/2]

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

inherited

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

◆ clear_user_data()

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

inherited

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

◆ save_user_indices()

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

inherited

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

◆ load_user_indices()

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

inherited

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

◆ save_user_pointers()

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

inherited

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

◆ load_user_pointers()

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

inherited

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

◆ save_user_indices_line()

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

inherited

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

◆ load_user_indices_line()

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

inherited

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

◆ save_user_indices_quad()

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

inherited

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

◆ load_user_indices_quad()

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

inherited

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

◆ save_user_indices_hex()

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

inherited

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

◆ load_user_indices_hex()

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

inherited

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

◆ save_user_pointers_line()

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

inherited

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

◆ load_user_pointers_line()

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

inherited

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

◆ save_user_pointers_quad()

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

inherited

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

◆ load_user_pointers_quad()

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

inherited

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

◆ save_user_pointers_hex()

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

inherited

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

◆ load_user_pointers_hex()

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

inherited

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

◆ begin()

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

inherited

Iterator to the first used cell on level level.

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

◆ begin_active()

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

inherited

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

for (const auto cell=tria.begin_active(level);
     cell!=tria.end_active(level);
     ++cell)
  {
    ...
  }

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

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

◆ end() [1/2]

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

inherited

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

◆ end() [2/2]

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

inherited

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

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

◆ end_active()

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

inherited

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

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

◆ last()

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

inherited

Return an iterator pointing to the last used cell.

◆ last_active()

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

inherited

Return an iterator pointing to the last active cell.

◆ create_cell_iterator()

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

inherited

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

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

◆ cell_iterators()

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

inherited

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

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

◆ active_cell_iterators()

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

inherited

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

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

Triangulation<dim> triangulation;
...
typename Triangulation<dim>::active_cell_iterator
  cell = triangulation.begin_active(),
  endc = triangulation.end();
for (; cell!=endc; ++cell)
  cell->set_user_flag();

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

Triangulation<dim> triangulation;
...
for (const auto &cell : triangulation.active_cell_iterators())
  cell->set_user_flag();

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

◆ cell_iterators_on_level()

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

inherited

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

Parameters

[in] level A given level in the refinement hierarchy of this triangulation.

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

Precondition: level must be less than this->n_levels().

◆ active_cell_iterators_on_level()

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

inherited

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

Parameters

[in] level A given level in the refinement hierarchy of this triangulation.

Returns: The half open range [this->begin_active(level), this->end(level))

Precondition: level must be less than this->n_levels().

◆ begin_face()

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

inherited

Iterator to the first used face.

◆ begin_active_face()

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

inherited

Iterator to the first active face.

◆ end_face()

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

inherited

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

◆ active_face_iterators()

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

inherited

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

Triangulation<dim> triangulation;
...
for (auto &face : triangulation.active_face_iterators())
  face->set_manifold_id(42);

Returns: The half open range [this->begin_active_face(), this->end_face())

◆ begin_vertex()

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

inherited

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

◆ begin_active_vertex()

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

inherited

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

◆ end_vertex()

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

inherited

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

◆ n_lines() [1/2]

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

inherited

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

◆ n_lines() [2/2]

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

inherited

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

◆ n_active_lines() [1/2]

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

inherited

Return the total number of active lines.

◆ n_active_lines() [2/2]

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

inherited

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

◆ n_quads() [1/8]

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

inherited

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

◆ n_quads() [2/8]

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

inherited

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

◆ n_quads() [3/8]

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

inherited

Definition at line 12855 of file tria.cc.

◆ n_quads() [4/8]

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

inherited

Definition at line 12863 of file tria.cc.

◆ n_quads() [5/8]

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

inherited

Definition at line 12904 of file tria.cc.

◆ n_quads() [6/8]

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

inherited

Definition at line 12912 of file tria.cc.

◆ n_quads() [7/8]

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

inherited

Definition at line 12952 of file tria.cc.

◆ n_quads() [8/8]

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

inherited

Definition at line 12960 of file tria.cc.

◆ n_active_quads() [1/8]

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

inherited

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

◆ n_active_quads() [2/8]

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

inherited

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

◆ n_active_quads() [3/8]

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

inherited

Definition at line 12887 of file tria.cc.

◆ n_active_quads() [4/8]

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

inherited

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

◆ n_active_quads() [6/8]

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

inherited

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

◆ n_active_quads() [8/8]

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

inherited

Definition at line 12992 of file tria.cc.

◆ n_hexs() [1/4]

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

inherited

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

◆ n_hexs() [2/4]

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

inherited

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

◆ n_hexs() [3/4]

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

inherited

Definition at line 13130 of file tria.cc.

◆ n_hexs() [4/4]

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

inherited

Definition at line 13139 of file tria.cc.

◆ n_active_hexs() [1/4]

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

inherited

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

◆ n_active_hexs() [2/4]

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

inherited

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

◆ n_active_hexs() [3/4]

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

inherited

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

◆ n_cells() [1/2]

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

inherited

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

◆ n_cells() [2/2]

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

inherited

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

◆ n_active_cells() [1/2]

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

inherited

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

◆ n_active_cells() [2/2]

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

inherited

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

◆ n_faces()

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

inherited

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

◆ n_active_faces()

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

inherited

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

◆ n_levels()

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

inherited

Return the number of levels in this triangulation.

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

◆ n_vertices()

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

inherited

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

◆ get_vertices()

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

inherited

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

◆ n_used_vertices()

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

inherited

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

◆ vertex_used()

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

inherited

Return true if the vertex with this index is used.

◆ get_used_vertices()

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

inherited

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

◆ max_adjacent_cells() [1/4]

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

inherited

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

In one space dimension, two is returned.

◆ max_adjacent_cells() [2/4]

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

inherited

Definition at line 13197 of file tria.cc.

◆ max_adjacent_cells() [3/4]

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

inherited

Definition at line 13206 of file tria.cc.

◆ max_adjacent_cells() [4/4]

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

inherited

Definition at line 13214 of file tria.cc.

◆ get_triangulation() [1/2]

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

inherited

Return a reference to the current object.

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

◆ get_triangulation() [2/2]

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

inherited

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

◆ n_raw_lines() [1/2]

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

inherited

Total number of lines, used or unused.

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

◆ n_raw_lines() [2/2]

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

inherited

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

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

◆ n_raw_quads() [1/9]

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

inherited

Total number of quads, used or unused.

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

◆ n_raw_quads() [2/9]

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

inherited

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

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

◆ n_raw_quads() [3/9]

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

inherited

Definition at line 12871 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 12920 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 12968 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 13020 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 13030 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 13039 of file tria.cc.

◆ n_raw_quads() [9/9]

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

inherited

Definition at line 13059 of file tria.cc.

◆ n_raw_hexs() [1/5]

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

inherited

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

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

◆ n_raw_hexs() [2/5]

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

inherited

Definition at line 12879 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 12928 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 12976 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 13150 of file tria.cc.

◆ n_raw_cells()

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

inherited

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

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

◆ n_raw_faces()

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

inherited

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

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

◆ add_periodicity() [2/2]

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

virtualinherited

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

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

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

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

◆ get_periodic_face_map()

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

inherited

Return the periodic_face_map.

◆ get_reference_cells()

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

inherited

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

◆ all_reference_cells_are_hyper_cube()

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

inherited

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

◆ serialize()

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

inherited

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

◆ ExcInvalidLevel()

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

staticinherited

Exception

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

◆ ExcTriangulationNotEmpty()

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

staticinherited

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

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

◆ ExcGridReadError()

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

staticinherited

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

◆ ExcFacesHaveNoLevel()

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

staticinherited

Exception

◆ ExcEmptyLevel()

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

staticinherited

The triangulation level you accessed is empty.

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

◆ ExcNonOrientableTriangulation()

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

staticinherited

Exception

◆ ExcBoundaryIdNotFound()

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

staticinherited

Exception

Requested boundary_id not found

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

◆ ExcInconsistentCoarseningFlags()

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

staticinherited

Exception

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

◆ write_bool_vector()

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

staticprotectedinherited

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

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

◆ read_bool_vector()

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

staticprotectedinherited

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

◆ update_periodic_face_map()

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

protectedinherited

Recreate information about periodic neighbors from periodic_face_pairs_level_0.

◆ begin_raw()

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

privateinherited

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

◆ end_raw()

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

privateinherited

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

◆ begin_raw_line()

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

privateinherited

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

◆ begin_line()

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

privateinherited

Iterator to the first used line on level level.

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

◆ begin_active_line()

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

privateinherited

Iterator to the first active line on level level.

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

◆ end_line()

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

privateinherited

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

◆ begin_raw_quad()

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

privateinherited

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

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

◆ begin_quad()

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

privateinherited

Iterator to the first used quad on level level.

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

◆ begin_active_quad()

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

privateinherited

Iterator to the first active quad on level level.

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

◆ end_quad()

quad_iterator Triangulation< dim, spacedim >::end_quad ( ) const

privateinherited

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

◆ begin_raw_hex()

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

privateinherited

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

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

◆ begin_hex()

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

privateinherited

Iterator to the first used hex on level level.

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

◆ begin_active_hex()

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

privateinherited

Iterator to the first active hex on level level.

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

◆ end_hex()

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

privateinherited

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

◆ clear_despite_subscriptions()

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

privateinherited

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

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

◆ reset_policy()

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

privateinherited

Reset triangulation policy.

◆ reset_active_cell_indices()

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

privateinherited

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

◆ reset_cell_vertex_indices_cache()

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

privateinherited

Reset cache for the cells' vertex indices.

◆ execute_refinement()

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

privateinherited

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

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

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

◆ execute_coarsening()

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

privateinherited

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

◆ fix_coarsen_flags()

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

privateinherited

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

Friends And Related Function Documentation

◆ ::FETools::internal::ExtrapolateImplementation

template<int dim, int spacedim = dim>

template<int , int , class >

friend class ::FETools::internal::ExtrapolateImplementation

friend

Definition at line 814 of file tria.h.

◆ TemporarilyMatchRefineFlags

template<int dim, int spacedim = dim>

template<int , int >

friend class TemporarilyMatchRefineFlags

friend

Definition at line 817 of file tria.h.

Member Data Documentation

◆ settings

template<int dim, int spacedim = dim>

Settings parallel::distributed::Triangulation< dim, spacedim >::settings

private

store the Settings.

Definition at line 677 of file tria.h.

◆ triangulation_has_content

template<int dim, int spacedim = dim>

bool parallel::distributed::Triangulation< dim, spacedim >::triangulation_has_content

private

A flag that indicates whether the triangulation has actual content.

Definition at line 682 of file tria.h.

◆ connectivity

template<int dim, int spacedim = dim>

typename::internal::p4est::types<dim>::connectivity* parallel::distributed::Triangulation< dim, spacedim >::connectivity

private

A data structure that holds the connectivity between trees. Since each tree is rooted in a coarse grid cell, this data structure holds the connectivity between the cells of the coarse grid.

Definition at line 689 of file tria.h.

◆ parallel_forest

template<int dim, int spacedim = dim>

typename::internal::p4est::types<dim>::forest* parallel::distributed::Triangulation< dim, spacedim >::parallel_forest

private

A data structure that holds the local part of the global triangulation.

Definition at line 695 of file tria.h.

◆ parallel_ghost

template<int dim, int spacedim = dim>

typename::internal::p4est::types<dim>::ghost* parallel::distributed::Triangulation< dim, spacedim >::parallel_ghost

private

A data structure that holds some information about the ghost cells of the triangulation.

Definition at line 701 of file tria.h.

◆ coarse_cell_to_p4est_tree_permutation

template<int dim, int spacedim = dim>

std::vector<types::global_dof_index> parallel::distributed::Triangulation< dim, spacedim >::coarse_cell_to_p4est_tree_permutation

private

Two arrays that store which p4est tree corresponds to which coarse grid cell and vice versa. We need these arrays because p4est goes with the original order of coarse cells when it sets up its forest, and then applies the Morton ordering within each tree. But if coarse grid cells are badly ordered this may mean that individual parts of the forest stored on a local machine may be split across coarse grid cells that are not geometrically close. Consequently, we apply a hierarchical preordering according to SparsityTools::reorder_hierarchical() to ensure that the part of the forest stored by p4est is located on geometrically close coarse grid cells.

Definition at line 741 of file tria.h.

◆ p4est_tree_to_coarse_cell_permutation

template<int dim, int spacedim = dim>

std::vector<types::global_dof_index> parallel::distributed::Triangulation< dim, spacedim >::p4est_tree_to_coarse_cell_permutation

private

Definition at line 743 of file tria.h.

◆ local_cell_relations

std::vector<cell_relation_t> parallel::DistributedTriangulationBase< 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 715 of file tria_base.h.

◆ cell_attached_data

CellAttachedData parallel::DistributedTriangulationBase< dim, spacedim >::cell_attached_data

protectedinherited

Definition at line 748 of file tria_base.h.

◆ data_transfer

DataTransfer parallel::DistributedTriangulationBase< dim, spacedim >::data_transfer

protectedinherited

Definition at line 903 of file tria_base.h.

◆ mpi_communicator

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

protectedinherited

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

Definition at line 310 of file tria_base.h.

◆ my_subdomain

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

protectedinherited

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

Definition at line 316 of file tria_base.h.

◆ n_subdomains

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

protectedinherited

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

Definition at line 321 of file tria_base.h.

◆ number_cache

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

protectedinherited

Definition at line 370 of file tria_base.h.

◆ dimension

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

staticinherited

Make the dimension available in function templates.

Definition at line 1548 of file tria.h.

◆ space_dimension

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

staticinherited

Make the space-dimension available in function templates.

Definition at line 1553 of file tria.h.

◆ signals

Signals Triangulation< dim, spacedim >::signals

mutableinherited

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

Definition at line 2295 of file tria.h.

◆ smooth_grid

MeshSmoothing Triangulation< dim, spacedim >::smooth_grid

protectedinherited

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

Definition at line 3525 of file tria.h.

◆ reference_cells

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

protectedinherited

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

Definition at line 3531 of file tria.h.

◆ policy

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

privateinherited

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

Definition at line 3583 of file tria.h.

◆ periodic_face_pairs_level_0

std::vector<GridTools::PeriodicFacePair<cell_iterator> > Triangulation< dim, spacedim >::periodic_face_pairs_level_0

privateinherited

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

Definition at line 3592 of file tria.h.

◆ periodic_face_map

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

privateinherited

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

Definition at line 3600 of file tria.h.

◆ levels

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

privateinherited

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

Definition at line 3978 of file tria.h.

◆ faces

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

privateinherited

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

Definition at line 3986 of file tria.h.

◆ vertices

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

privateinherited

Array of the vertices of this triangulation.

Definition at line 3992 of file tria.h.

◆ vertices_used

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

privateinherited

Array storing a bit-pattern which vertices are used.

Definition at line 3997 of file tria.h.

◆ manifold

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

privateinherited

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

Definition at line 4004 of file tria.h.

◆ anisotropic_refinement

bool Triangulation< dim, spacedim >::anisotropic_refinement

privateinherited

Flag indicating whether anisotropic refinement took place.

Definition at line 4009 of file tria.h.

◆ check_for_distorted_cells

const bool Triangulation< dim, spacedim >::check_for_distorted_cells

privateinherited

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

Definition at line 4016 of file tria.h.

◆ vertex_to_boundary_id_map_1d

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

privateinherited

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

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

Definition at line 4044 of file tria.h.

◆ vertex_to_manifold_id_map_1d

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

privateinherited

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

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

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

Definition at line 4067 of file tria.h.

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

include/deal.II/distributed/tria.h
source/distributed/tria.cc

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Exceptions

Hex iterator functions for internal use

Subscriptor functionality

Cell iterator functions for internal use

Detailed Description

Interaction with boundary description

Member Typedef Documentation

◆ CellStatus

◆ cell_relation_t

◆ IteratorSelector

◆ level_cell_iterator

◆ face_iterator

◆ active_face_iterator

◆ vertex_iterator

◆ active_vertex_iterator

◆ line_iterator

◆ active_line_iterator

◆ quad_iterator

◆ active_quad_iterator

◆ hex_iterator

◆ active_hex_iterator

◆ raw_cell_iterator

◆ raw_face_iterator

◆ raw_vertex_iterator

◆ raw_line_iterator

◆ raw_quad_iterator

◆ raw_hex_iterator

Member Enumeration Documentation

◆ Settings

◆ MeshSmoothing

Constructor & Destructor Documentation

◆ Triangulation()

◆ ~Triangulation()

Member Function Documentation

◆ clear()

◆ is_multilevel_hierarchy_constructed()

◆ execute_transfer()

◆ copy_triangulation() [1/2]

◆ create_triangulation() [1/2]

◆ create_triangulation() [2/2]

◆ execute_coarsening_and_refinement()

◆ prepare_coarsening_and_refinement()

◆ repartition()

◆ has_hanging_nodes()

◆ memory_consumption()

◆ memory_consumption_p4est()

◆ write_mesh_vtk()

◆ get_checksum()

◆ save() [1/2]

◆ load() [1/3]

◆ load() [2/3]

◆ get_p4est_tree_to_coarse_cell_permutation()

◆ get_coarse_cell_to_p4est_tree_permutation()

◆ get_p4est()

◆ add_periodicity() [1/2]

◆ update_cell_relations()

◆ init_tree()

◆ setup_coarse_cell_to_p4est_tree_permutation()

◆ copy_new_triangulation_to_p4est() [1/2]

◆ copy_new_triangulation_to_p4est() [2/2]

◆ copy_local_forest_to_triangulation()

◆ get_cell_weights()

◆ mark_locally_active_vertices_on_level()

◆ coarse_cell_id_to_coarse_cell_index()

◆ coarse_cell_index_to_coarse_cell_id()

◆ save() [2/2]

◆ load() [3/3]

◆ register_data_attach()

◆ notify_ready_to_unpack()