Utility functions for operations on a Mesh object. More...

Namespaces
	Generation
	Tools for `Mesh` generation.

	Modification
	Tools for `Mesh` modification.

	Private

	Subdivision
	Utility functions for subdivision surface operations on a `Mesh`.

Classes
class	BoundingBox
	Backwards compatibility with forward declarations. More...

Functions
dof_id_type	total_weight (const MeshBase &mesh)

dof_id_type	weight (const MeshBase &mesh, const processor_id_type pid)

dof_id_type	weight (const MeshBase &mesh)

void	build_nodes_to_elem_map (const MeshBase &mesh, std::vector< std::vector< dof_id_type >> &nodes_to_elem_map)
	After calling this function the input vector `nodes_to_elem_map` will contain the node to element connectivity. More...

void	build_nodes_to_elem_map (const MeshBase &mesh, std::vector< std::vector< const Elem *>> &nodes_to_elem_map)
	The same, except element pointers are returned instead of indices. More...

void	build_nodes_to_elem_map (const MeshBase &mesh, std::unordered_map< dof_id_type, std::vector< dof_id_type >> &nodes_to_elem_map)
	After calling this function the input map `nodes_to_elem_map` will contain the node to element connectivity. More...

void	build_nodes_to_elem_map (const MeshBase &mesh, std::unordered_map< dof_id_type, std::vector< const Elem *>> &nodes_to_elem_map)
	The same, except element pointers are returned instead of indices. More...

void	find_boundary_nodes (const MeshBase &mesh, std::vector< bool > &on_boundary)
	Calling this function on a 2D mesh will convert all the elements to triangles. More...

std::unordered_set< dof_id_type >	find_boundary_nodes (const MeshBase &mesh)
	Returns a std::set containing Node IDs for all of the boundary nodes. More...

std::unordered_set< dof_id_type >	find_block_boundary_nodes (const MeshBase &mesh)
	Returns a std::set containing Node IDs for all of the block boundary nodes. More...

BoundingBox	bounding_box (const MeshBase &mesh)

libMesh::BoundingBox	create_bounding_box (const MeshBase &mesh)
	The same functionality as the deprecated MeshTools::bounding_box(). More...

Sphere	bounding_sphere (const MeshBase &mesh)

libMesh::BoundingBox	create_nodal_bounding_box (const MeshBase &mesh)

libMesh::BoundingBox	create_local_bounding_box (const MeshBase &mesh)

BoundingBox	processor_bounding_box (const MeshBase &mesh, const processor_id_type pid)

libMesh::BoundingBox	create_processor_bounding_box (const MeshBase &mesh, const processor_id_type pid)
	The same functionality as the deprecated MeshTools::processor_bounding_box(). More...

Sphere	processor_bounding_sphere (const MeshBase &mesh, const processor_id_type pid)

BoundingBox	subdomain_bounding_box (const MeshBase &mesh, const subdomain_id_type sid)

libMesh::BoundingBox	create_subdomain_bounding_box (const MeshBase &mesh, const subdomain_id_type sid)
	The same functionality as the deprecated MeshTools::subdomain_bounding_box(). More...

Sphere	subdomain_bounding_sphere (const MeshBase &mesh, const subdomain_id_type sid)

void	elem_types (const MeshBase &mesh, std::vector< ElemType > &et)
	Fills in a vector of all element types in the mesh. More...

dof_id_type	n_elem_of_type (const MeshBase &mesh, const ElemType type)

dof_id_type	n_active_elem_of_type (const MeshBase &mesh, const ElemType type)

dof_id_type	n_non_subactive_elem_of_type_at_level (const MeshBase &mesh, const ElemType type, const unsigned int level)

unsigned int	n_levels (const MeshBase &mesh)

unsigned int	n_local_levels (const MeshBase &mesh)

unsigned int	n_active_levels (const MeshBase &mesh)

unsigned int	n_active_local_levels (const MeshBase &mesh)

unsigned int	n_p_levels (const MeshBase &mesh)

unsigned int	paranoid_n_levels (const MeshBase &mesh)

void	get_not_subactive_node_ids (const MeshBase &mesh, std::set< dof_id_type > &not_subactive_node_ids)
	Builds a set of node IDs for nodes which belong to non-subactive elements. More...

dof_id_type	n_elem (const MeshBase::const_element_iterator &begin, const MeshBase::const_element_iterator &end)
	Count up the number of elements of a specific type (as defined by an iterator range). More...

dof_id_type	n_nodes (const MeshBase::const_node_iterator &begin, const MeshBase::const_node_iterator &end)
	Count up the number of nodes of a specific type (as defined by an iterator range). More...

unsigned int	max_level (const MeshBase &mesh)
	Find the maximum h-refinement level in a mesh. More...

void	find_nodal_neighbors (const MeshBase &mesh, const Node &n, const std::vector< std::vector< const Elem >> &nodes_to_elem_map, std::vector< const Node > &neighbors)
	Given a mesh and a node in the mesh, the vector will be filled with every node directly attached to the given one. More...

void	find_nodal_neighbors (const MeshBase &mesh, const Node &n, const std::unordered_map< dof_id_type, std::vector< const Elem >> &nodes_to_elem_map, std::vector< const Node > &neighbors)
	Given a mesh and a node in the mesh, the vector will be filled with every node directly attached to the given one. More...

void	find_hanging_nodes_and_parents (const MeshBase &mesh, std::map< dof_id_type, std::vector< dof_id_type >> &hanging_nodes)
	Given a mesh hanging_nodes will be filled with an associative array keyed off the global id of all the hanging nodes in the mesh. More...

void	correct_node_proc_ids (MeshBase &)
	Changes the processor ids on each node so be the same as the id of the lowest element touching that node. More...

void	libmesh_assert_no_links_to_elem (const MeshBase &mesh, const Elem *bad_elem)
	A function for verifying that an element has been cut off from the rest of the mesh. More...

void	libmesh_assert_equal_n_systems (const MeshBase &mesh)
	A function for testing that all DofObjects within a mesh have the same n_systems count. More...

void	libmesh_assert_old_dof_objects (const MeshBase &mesh)
	A function for testing that all non-recently-created DofObjects within a mesh have old_dof_object data. More...

void	libmesh_assert_valid_node_pointers (const MeshBase &mesh)
	A function for walking across the mesh to try and ferret out invalidated or misassigned pointers. More...

void	libmesh_assert_valid_remote_elems (const MeshBase &mesh)
	A function for verifying that active local elements' neighbors are never remote elements. More...

void	libmesh_assert_valid_elem_ids (const MeshBase &mesh)
	A function for verifying that ids and processor assignment of elements are correctly sorted (monotone increasing) More...

void	libmesh_assert_valid_amr_elem_ids (const MeshBase &mesh)
	A function for verifying that ids of elements are correctly sorted for AMR (parents have lower ids than children) More...

void	libmesh_assert_valid_amr_interior_parents (const MeshBase &mesh)
	A function for verifying that any interior_parent pointers on elements are consistent with AMR (parents' interior_parents are interior_parents' parents) More...

void	libmesh_assert_connected_nodes (const MeshBase &mesh)
	A function for verifying that all nodes are connected to at least one element. More...

void	libmesh_assert_valid_boundary_ids (const MeshBase &mesh)
	A function for verifying that boundary condition ids match across processors. More...

void	libmesh_assert_valid_dof_ids (const MeshBase &mesh, unsigned int sysnum=libMesh::invalid_uint)
	A function for verifying that degree of freedom indexing matches across processors. More...

void	libmesh_assert_contiguous_dof_ids (const MeshBase &mesh, unsigned int sysnum)
	A function for verifying that degree of freedom indexes are contiguous on each processors, as is required by libMesh numeric classes. More...

void	libmesh_assert_valid_unique_ids (const MeshBase &mesh)
	A function for verifying that unique ids match across processors. More...

void	libmesh_assert_consistent_distributed (const MeshBase &mesh)
	A function for verifying that distribution of dof objects is parallel consistent (every processor can see every node or element it owns) More...

void	libmesh_assert_consistent_distributed_nodes (const MeshBase &mesh)
	A function for verifying that distribution of nodes is parallel consistent (every processor can see every node it owns) even before node ids have been made consistent. More...

void	libmesh_assert_parallel_consistent_new_node_procids (const MeshBase &mesh)
	A function for verifying that processor assignment is parallel consistent (every processor agrees on the processor id of each node it can see) even on nodes which have not yet recieved consistent DofObject::id(), using element topology to identify matching nodes. More...

template<typename DofObjectSubclass >
void	libmesh_assert_parallel_consistent_procids (const MeshBase &mesh)
	A function for verifying that processor assignment is parallel consistent (every processor agrees on the processor id of each dof object it can see) More...

template<typename DofObjectSubclass >
void	libmesh_assert_topology_consistent_procids (const MeshBase &mesh)
	A function for verifying that processor assignment is topologically consistent on nodes (each node part of an active element on its processor) or elements (each parent has the processor id of one of its children). More...

template<typename DofObjectSubclass >
void	libmesh_assert_valid_procids (const MeshBase &mesh)
	A function for verifying that processor assignment is both parallel and topologically consistent. More...

void	libmesh_assert_canonical_node_procids (const MeshBase &mesh)
	A function for verifying that processor assignment of nodes matches the heuristic specified in Node::choose_processor_id() More...

void	libmesh_assert_valid_refinement_flags (const MeshBase &mesh)
	A function for verifying that refinement flags on elements are consistent between processors. More...

void	libmesh_assert_valid_refinement_tree (const MeshBase &mesh)
	A function for verifying that elements on this processor have valid descendants and consistent active flags. More...

void	libmesh_assert_valid_neighbors (const MeshBase &mesh, bool assert_valid_remote_elems=true)
	A function for verifying that neighbor connectivity is correct (each element is a neighbor of or descendant of a neighbor of its neighbors) and consistent (each neighbor link goes to either the same neighbor or to a RemoteElem on each processor) More...

Detailed Description

Utility functions for operations on a Mesh object.

Here is where useful functions for interfacing with a Mesh should be defined. In general this namespace should be used to prevent the Mesh class from becoming too cluttered.

Author: Benjamin S. Kirk

Date: 2004

Function Documentation

◆ bounding_box()

BoundingBox libMesh::MeshTools::bounding_box ( const MeshBase & mesh )

Returns: Two points defining a cartesian box that bounds the mesh. The first entry in the pair is the minimum, the second is the maximum.

Deprecated:: Use create_bounding_box() instead.

◆ bounding_sphere()

Sphere libMesh::MeshTools::bounding_sphere ( const MeshBase & mesh )

Returns: A bounding sphere for mesh instead of a bounding box.

◆ build_nodes_to_elem_map() [1/4]

void libMesh::MeshTools::build_nodes_to_elem_map	(	const MeshBase &	mesh,
		std::vector< std::vector< dof_id_type >> &	nodes_to_elem_map
	)

After calling this function the input vector nodes_to_elem_map will contain the node to element connectivity.

That is to say nodes_to_elem_map[i][j] is the global number of $j^{th}$ element connected to node i.

◆ build_nodes_to_elem_map() [2/4]

void libMesh::MeshTools::build_nodes_to_elem_map	(	const MeshBase &	mesh,
		std::vector< std::vector< const Elem *>> &	nodes_to_elem_map
	)

The same, except element pointers are returned instead of indices.

◆ build_nodes_to_elem_map() [3/4]

void libMesh::MeshTools::build_nodes_to_elem_map	(	const MeshBase &	mesh,
		std::unordered_map< dof_id_type, std::vector< dof_id_type >> &	nodes_to_elem_map
	)

After calling this function the input map nodes_to_elem_map will contain the node to element connectivity.

That is to say nodes_to_elem_map[i][j] is the global number of $j^{th}$ element connected to node i.

◆ build_nodes_to_elem_map() [4/4]

void libMesh::MeshTools::build_nodes_to_elem_map	(	const MeshBase &	mesh,
		std::unordered_map< dof_id_type, std::vector< const Elem *>> &	nodes_to_elem_map
	)

The same, except element pointers are returned instead of indices.

◆ correct_node_proc_ids()

void libMesh::MeshTools::correct_node_proc_ids ( MeshBase & )

Changes the processor ids on each node so be the same as the id of the lowest element touching that node.

This corrects "orphaned" processor ids that may occur from element coarsening.

On a distributed mesh, this function must be called in parallel to sync everyone's corrected processor ids on ghost nodes.

◆ create_bounding_box()

libMesh::BoundingBox libMesh::MeshTools::create_bounding_box ( const MeshBase & mesh )

The same functionality as the deprecated MeshTools::bounding_box().

Returns: The non-deprecated libMesh::BoundingBox type.

◆ create_local_bounding_box()

libMesh::BoundingBox libMesh::MeshTools::create_local_bounding_box ( const MeshBase & mesh )

Returns: Two points defining a cartesian box that bounds the elements belonging to the local processor.

Unlike the other bounding box creation functions, this does not need to be run in parallel, because this is the only function we can guarantee can be resolved with only local information.

◆ create_nodal_bounding_box()

libMesh::BoundingBox libMesh::MeshTools::create_nodal_bounding_box ( const MeshBase & mesh )

Returns: Two points defining a cartesian box that bounds the nodes of the mesh.

In the case of curved elements, this box might not bound the elements of the mesh.

◆ create_processor_bounding_box()

libMesh::BoundingBox libMesh::MeshTools::create_processor_bounding_box	(	const MeshBase &	mesh,
		const processor_id_type	pid
	)

The same functionality as the deprecated MeshTools::processor_bounding_box().

Returns: The non-deprecated libMesh::BoundingBox type.

◆ create_subdomain_bounding_box()

libMesh::BoundingBox libMesh::MeshTools::create_subdomain_bounding_box	(	const MeshBase &	mesh,
		const subdomain_id_type	sid
	)

The same functionality as the deprecated MeshTools::subdomain_bounding_box().

Returns: The non-deprecated libMesh::BoundingBox type.

◆ elem_types()

void libMesh::MeshTools::elem_types	(	const MeshBase &	mesh,
		std::vector< ElemType > &	et
	)

Fills in a vector of all element types in the mesh.

Implemented in terms of element_iterators.

◆ find_block_boundary_nodes()

std::unordered_set<dof_id_type> libMesh::MeshTools::find_block_boundary_nodes ( const MeshBase & mesh )

Returns a std::set containing Node IDs for all of the block boundary nodes.

A "block boundary node" is a node that is connected to elemenents from 2 or more blockse

◆ find_boundary_nodes() [1/2]

void libMesh::MeshTools::find_boundary_nodes	(	const MeshBase &	mesh,
		std::vector< bool > &	on_boundary
	)

Calling this function on a 2D mesh will convert all the elements to triangles.

QUAD4s will be converted to TRI3s, QUAD8s and QUAD9s will be converted to TRI6s. Fills the vector "on_boundary" with flags that tell whether each node is on the domain boundary (true)) or not (false).

◆ find_boundary_nodes() [2/2]

std::unordered_set<dof_id_type> libMesh::MeshTools::find_boundary_nodes ( const MeshBase & mesh )

Returns a std::set containing Node IDs for all of the boundary nodes.

◆ find_hanging_nodes_and_parents()

void libMesh::MeshTools::find_hanging_nodes_and_parents	(	const MeshBase &	mesh,
		std::map< dof_id_type, std::vector< dof_id_type >> &	hanging_nodes
	)

Given a mesh hanging_nodes will be filled with an associative array keyed off the global id of all the hanging nodes in the mesh.

It will hold an array of the parents of the node (meaning the two nodes to either side of it that make up the side the hanging node is on.

◆ find_nodal_neighbors() [1/2]

void libMesh::MeshTools::find_nodal_neighbors	(	const MeshBase &	mesh,
		const Node &	n,
		const std::vector< std::vector< const Elem *>> &	nodes_to_elem_map,
		std::vector< const Node *> &	neighbors
	)

Given a mesh and a node in the mesh, the vector will be filled with every node directly attached to the given one.

◆ find_nodal_neighbors() [2/2]

void libMesh::MeshTools::find_nodal_neighbors	(	const MeshBase &	mesh,
		const Node &	n,
		const std::unordered_map< dof_id_type, std::vector< const Elem *>> &	nodes_to_elem_map,
		std::vector< const Node *> &	neighbors
	)

Given a mesh and a node in the mesh, the vector will be filled with every node directly attached to the given one.

◆ get_not_subactive_node_ids()

void libMesh::MeshTools::get_not_subactive_node_ids	(	const MeshBase &	mesh,
		std::set< dof_id_type > &	not_subactive_node_ids
	)

Builds a set of node IDs for nodes which belong to non-subactive elements.

Non-subactive elements are those which are either active or inactive. This is useful for determining which nodes should be written to a data file, and is used by the XDA mesh writing methods.

◆ libmesh_assert_canonical_node_procids()

void libMesh::MeshTools::libmesh_assert_canonical_node_procids ( const MeshBase & mesh )

A function for verifying that processor assignment of nodes matches the heuristic specified in Node::choose_processor_id()

◆ libmesh_assert_connected_nodes()

void libMesh::MeshTools::libmesh_assert_connected_nodes ( const MeshBase & mesh )

A function for verifying that all nodes are connected to at least one element.

This will fail in the most general case. When DistributedMesh and NodeConstraints are enabled, we expect the possibility that a processor will be given remote nodes to satisfy node constraints without also being given the remote elements connected to those nodes.

◆ libmesh_assert_consistent_distributed()

void libMesh::MeshTools::libmesh_assert_consistent_distributed ( const MeshBase & mesh )

A function for verifying that distribution of dof objects is parallel consistent (every processor can see every node or element it owns)

◆ libmesh_assert_consistent_distributed_nodes()

void libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes ( const MeshBase & mesh )

A function for verifying that distribution of nodes is parallel consistent (every processor can see every node it owns) even before node ids have been made consistent.

◆ libmesh_assert_contiguous_dof_ids()

void libMesh::MeshTools::libmesh_assert_contiguous_dof_ids	(	const MeshBase &	mesh,
		unsigned int	sysnum
	)

A function for verifying that degree of freedom indexes are contiguous on each processors, as is required by libMesh numeric classes.

Verify a particular system by specifying that system's number.

◆ libmesh_assert_equal_n_systems()

void libMesh::MeshTools::libmesh_assert_equal_n_systems ( const MeshBase & mesh )

A function for testing that all DofObjects within a mesh have the same n_systems count.

◆ libmesh_assert_no_links_to_elem()

void libMesh::MeshTools::libmesh_assert_no_links_to_elem	(	const MeshBase &	mesh,
		const Elem *	bad_elem
	)

A function for verifying that an element has been cut off from the rest of the mesh.

◆ libmesh_assert_old_dof_objects()

void libMesh::MeshTools::libmesh_assert_old_dof_objects ( const MeshBase & mesh )

A function for testing that all non-recently-created DofObjects within a mesh have old_dof_object data.

This is not expected to be true at all points within a simulation code.

◆ libmesh_assert_parallel_consistent_new_node_procids()

void libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids ( const MeshBase & mesh )

A function for verifying that processor assignment is parallel consistent (every processor agrees on the processor id of each node it can see) even on nodes which have not yet recieved consistent DofObject::id(), using element topology to identify matching nodes.

◆ libmesh_assert_parallel_consistent_procids()

template<typename DofObjectSubclass >

void libMesh::MeshTools::libmesh_assert_parallel_consistent_procids ( const MeshBase & mesh )

A function for verifying that processor assignment is parallel consistent (every processor agrees on the processor id of each dof object it can see)

◆ libmesh_assert_topology_consistent_procids()

template<typename DofObjectSubclass >

void libMesh::MeshTools::libmesh_assert_topology_consistent_procids ( const MeshBase & mesh )

A function for verifying that processor assignment is topologically consistent on nodes (each node part of an active element on its processor) or elements (each parent has the processor id of one of its children).

◆ libmesh_assert_valid_amr_elem_ids()

void libMesh::MeshTools::libmesh_assert_valid_amr_elem_ids ( const MeshBase & mesh )

A function for verifying that ids of elements are correctly sorted for AMR (parents have lower ids than children)

◆ libmesh_assert_valid_amr_interior_parents()

void libMesh::MeshTools::libmesh_assert_valid_amr_interior_parents ( const MeshBase & mesh )

A function for verifying that any interior_parent pointers on elements are consistent with AMR (parents' interior_parents are interior_parents' parents)

◆ libmesh_assert_valid_boundary_ids()

void libMesh::MeshTools::libmesh_assert_valid_boundary_ids ( const MeshBase & mesh )

A function for verifying that boundary condition ids match across processors.

◆ libmesh_assert_valid_dof_ids()

void libMesh::MeshTools::libmesh_assert_valid_dof_ids	(	const MeshBase &	mesh,
		unsigned int	sysnum = `libMesh::invalid_uint`
	)

A function for verifying that degree of freedom indexing matches across processors.

Verify a particular system by specifying that system's number, or verify all systems at once by leaving sysnum unspecified.

◆ libmesh_assert_valid_elem_ids()

void libMesh::MeshTools::libmesh_assert_valid_elem_ids ( const MeshBase & mesh )

A function for verifying that ids and processor assignment of elements are correctly sorted (monotone increasing)

◆ libmesh_assert_valid_neighbors()

void libMesh::MeshTools::libmesh_assert_valid_neighbors	(	const MeshBase &	mesh,
		bool	assert_valid_remote_elems = `true`
	)

A function for verifying that neighbor connectivity is correct (each element is a neighbor of or descendant of a neighbor of its neighbors) and consistent (each neighbor link goes to either the same neighbor or to a RemoteElem on each processor)

If assert_valid_remote_elems is set to false, then no error will be thrown for neighbor links where a remote_elem should exist but a nullptr exists instead.

◆ libmesh_assert_valid_node_pointers()

void libMesh::MeshTools::libmesh_assert_valid_node_pointers ( const MeshBase & mesh )

A function for walking across the mesh to try and ferret out invalidated or misassigned pointers.

◆ libmesh_assert_valid_procids()

template<typename DofObjectSubclass >

void libMesh::MeshTools::libmesh_assert_valid_procids ( const MeshBase & mesh )

A function for verifying that processor assignment is both parallel and topologically consistent.

Definition at line 581 of file mesh_tools.h.

                                                           {
   libmesh_assert_parallel_consistent_procids<DofObjectSubclass>(mesh);
   libmesh_assert_topology_consistent_procids<DofObjectSubclass>(mesh);
 }

◆ libmesh_assert_valid_refinement_flags()

void libMesh::MeshTools::libmesh_assert_valid_refinement_flags ( const MeshBase & mesh )

A function for verifying that refinement flags on elements are consistent between processors.

◆ libmesh_assert_valid_refinement_tree()

void libMesh::MeshTools::libmesh_assert_valid_refinement_tree ( const MeshBase & mesh )

A function for verifying that elements on this processor have valid descendants and consistent active flags.

◆ libmesh_assert_valid_remote_elems()

void libMesh::MeshTools::libmesh_assert_valid_remote_elems ( const MeshBase & mesh )

A function for verifying that active local elements' neighbors are never remote elements.

◆ libmesh_assert_valid_unique_ids()

void libMesh::MeshTools::libmesh_assert_valid_unique_ids ( const MeshBase & mesh )

A function for verifying that unique ids match across processors.

FIXME: we ought to check for uniqueness too.

◆ max_level()

unsigned int libMesh::MeshTools::max_level ( const MeshBase & mesh )

Find the maximum h-refinement level in a mesh.

◆ n_active_elem_of_type()

dof_id_type libMesh::MeshTools::n_active_elem_of_type	(	const MeshBase &	mesh,
		const ElemType	type
	)

Returns: The number of active elements of type type.

Implemented in terms of active_type_element_iterators.

◆ n_active_levels()

unsigned int libMesh::MeshTools::n_active_levels ( const MeshBase & mesh )

Returns: The number of levels of refinement in the active mesh.

Implemented by looping over all the active local elements and finding the maximum level, then taking the max in parallel.

◆ n_active_local_levels()

unsigned int libMesh::MeshTools::n_active_local_levels ( const MeshBase & mesh )

Returns: The number of levels of refinement in the active local mesh.

Implemented by looping over all the active local elements and finding the maximum level.

◆ n_elem()

dof_id_type libMesh::MeshTools::n_elem	(	const MeshBase::const_element_iterator &	begin,
		const MeshBase::const_element_iterator &	end
	)

Count up the number of elements of a specific type (as defined by an iterator range).

◆ n_elem_of_type()

dof_id_type libMesh::MeshTools::n_elem_of_type	(	const MeshBase &	mesh,
		const ElemType	type
	)

Returns: The number of elements of type type.

Implemented in terms of type_element_iterators.

◆ n_levels()

unsigned int libMesh::MeshTools::n_levels ( const MeshBase & mesh )

Returns: The number of levels of refinement in the mesh.

Implemented by looping over all the local elements and unpartitioned elements and finding the maximum level, then summing in parallel.

◆ n_local_levels()

unsigned int libMesh::MeshTools::n_local_levels ( const MeshBase & mesh )

Returns: The number of levels of refinement in the local mesh.

Implemented by looping over all the local elements and finding the maximum level.

◆ n_nodes()

dof_id_type libMesh::MeshTools::n_nodes	(	const MeshBase::const_node_iterator &	begin,
		const MeshBase::const_node_iterator &	end
	)

Count up the number of nodes of a specific type (as defined by an iterator range).

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()(), libMesh::Side< SideType, ParentType >::set_node(), and libMesh::SideEdge< EdgeType, ParentType >::set_node().

◆ n_non_subactive_elem_of_type_at_level()

dof_id_type libMesh::MeshTools::n_non_subactive_elem_of_type_at_level	(	const MeshBase &	mesh,
		const ElemType	type,
		const unsigned int	level
	)

Returns: The number of elements of type type at the specified refinement level.

Todo:: Replace all of the n_xxx_elem() functions like this with a single function which takes a range of iterators and computes the std::distance between them.

◆ n_p_levels()

unsigned int libMesh::MeshTools::n_p_levels ( const MeshBase & mesh )

Returns: The number of p-levels of refinement in the mesh.

Implemented by looping over all the local elements and finding the maximum p-level, then summing in parallel.

◆ paranoid_n_levels()

unsigned int libMesh::MeshTools::paranoid_n_levels ( const MeshBase & mesh )

Returns: The number of levels of refinement in the mesh, even if that mesh is not currently properly distributed or properly serialized.

Implemented by looping over all elements and finding the maximum level, then summing in parallel. This is much slower than n_levels() but will return correct values even when the mesh is in an inconsistent parallel state.

◆ processor_bounding_box()

BoundingBox libMesh::MeshTools::processor_bounding_box	(	const MeshBase &	mesh,
		const processor_id_type	pid
	)

Returns: Two points defining a cartesian box that bounds the elements belonging to processor pid.

Deprecated:: Use create_processor_bounding_box() instead.

◆ processor_bounding_sphere()

Sphere libMesh::MeshTools::processor_bounding_sphere	(	const MeshBase &	mesh,
		const processor_id_type	pid
	)

Returns: A processor bounding sphere instead of a processor bounding box.

◆ subdomain_bounding_box()

BoundingBox libMesh::MeshTools::subdomain_bounding_box	(	const MeshBase &	mesh,
		const subdomain_id_type	sid
	)

Returns: Two points defining a Cartesian box that bounds the elements belonging to subdomain sid.

Deprecated:: Use create_subdomain_bounding_box() instead.

◆ subdomain_bounding_sphere()

Sphere libMesh::MeshTools::subdomain_bounding_sphere	(	const MeshBase &	mesh,
		const subdomain_id_type	sid
	)

Returns: A subdomain bounding sphere instead of a subdomain bounding box.

◆ total_weight()

dof_id_type libMesh::MeshTools::total_weight ( const MeshBase & mesh )

Returns: The sum over all the elements of the number of nodes per element.

This can be useful for partitioning hybrid meshes. A feasible load balancing scheme is to keep the weight per processor as uniform as possible.

◆ weight() [1/2]

dof_id_type libMesh::MeshTools::weight	(	const MeshBase &	mesh,
		const processor_id_type	pid
	)

Returns: The sum over all the elements on processor pid of nodes per element.

This can be useful for partitioning hybrid meshes. A feasible load balancing scheme is to keep the weight per processor as uniform as possible.

Referenced by weight().

◆ weight() [2/2]

dof_id_type libMesh::MeshTools::weight ( const MeshBase & mesh )

Definition at line 113 of file mesh_tools.h.

References libMesh::ParallelObject::processor_id(), and weight().

114 { return MeshTools::weight (mesh, mesh.processor_id()); }

libMesh::MeshTools::weight

dof_id_type weight(const MeshBase &mesh)

Definition: mesh_tools.h:113

Namespaces

Classes

Functions

Detailed Description

Function Documentation

◆ bounding_box()

◆ bounding_sphere()

◆ build_nodes_to_elem_map() [1/4]

◆ build_nodes_to_elem_map() [2/4]

◆ build_nodes_to_elem_map() [3/4]

◆ build_nodes_to_elem_map() [4/4]

◆ correct_node_proc_ids()

◆ create_bounding_box()

◆ create_local_bounding_box()

◆ create_nodal_bounding_box()

◆ create_processor_bounding_box()

◆ create_subdomain_bounding_box()

◆ elem_types()

◆ find_block_boundary_nodes()

◆ find_boundary_nodes() [1/2]

◆ find_boundary_nodes() [2/2]

◆ find_hanging_nodes_and_parents()

◆ find_nodal_neighbors() [1/2]

◆ find_nodal_neighbors() [2/2]

◆ get_not_subactive_node_ids()

◆ libmesh_assert_canonical_node_procids()

◆ libmesh_assert_connected_nodes()

◆ libmesh_assert_consistent_distributed()

◆ libmesh_assert_consistent_distributed_nodes()

◆ libmesh_assert_contiguous_dof_ids()

◆ libmesh_assert_equal_n_systems()

◆ libmesh_assert_no_links_to_elem()

◆ libmesh_assert_old_dof_objects()

◆ libmesh_assert_parallel_consistent_new_node_procids()

◆ libmesh_assert_parallel_consistent_procids()

◆ libmesh_assert_topology_consistent_procids()

◆ libmesh_assert_valid_amr_elem_ids()

◆ libmesh_assert_valid_amr_interior_parents()

◆ libmesh_assert_valid_boundary_ids()

◆ libmesh_assert_valid_dof_ids()

◆ libmesh_assert_valid_elem_ids()

◆ libmesh_assert_valid_neighbors()

◆ libmesh_assert_valid_node_pointers()

◆ libmesh_assert_valid_procids()

◆ libmesh_assert_valid_refinement_flags()

◆ libmesh_assert_valid_refinement_tree()

◆ libmesh_assert_valid_remote_elems()

◆ libmesh_assert_valid_unique_ids()

◆ max_level()

◆ n_active_elem_of_type()

◆ n_active_levels()

◆ n_active_local_levels()

◆ n_elem()

◆ n_elem_of_type()

◆ n_levels()

◆ n_local_levels()

◆ n_nodes()

◆ n_non_subactive_elem_of_type_at_level()

◆ n_p_levels()

◆ paranoid_n_levels()

◆ processor_bounding_box()

◆ processor_bounding_sphere()

◆ subdomain_bounding_box()

◆ subdomain_bounding_sphere()

◆ total_weight()

◆ weight() [1/2]

◆ weight() [2/2]