libMesh::MeshTools Namespace Reference

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

Namespaces
namespace	Generation
	Tools for Mesh generation.
namespace	Modification
	Tools for Mesh modification.
namespace	Private
namespace	Subdivision
	Utility functions for subdivision surface operations on a Mesh.

Classes
class	SidesToElemMap
	This class implements a generalization of the MeshTools::build_nodes_to_elem_map() function, but rather than being a standalone function taking a std::unordered_map argument, we define a class with APIs for both building the underlying map data structure and querying its contents. 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.
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.
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.
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.
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.
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.
libMesh::BoundingBox	create_bounding_box (const MeshBase &mesh)
Sphere	bounding_sphere (const MeshBase &mesh)
libMesh::BoundingBox	create_nodal_bounding_box (const MeshBase &mesh)
libMesh::BoundingBox	create_local_bounding_box (const MeshBase &mesh)
libMesh::BoundingBox	create_processor_bounding_box (const MeshBase &mesh, const processor_id_type pid)
Sphere	processor_bounding_sphere (const MeshBase &mesh, const processor_id_type pid)
libMesh::BoundingBox	create_subdomain_bounding_box (const MeshBase &mesh, const subdomain_id_type sid)
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.
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)
dof_id_type	n_connected_components (const MeshBase &mesh, Real constraint_tol=0)
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.
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).
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).
Real	volume (const MeshBase &mesh, unsigned int dim=libMesh::invalid_uint)
	Find the total volume of a mesh (interpreting that as area for dim = 2, or total arc length for dim = 1, or number of NodeElem in the mesh for dim = 0).
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.
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.
void	find_nodal_or_face_neighbors (const MeshBase &mesh, const Node &node, 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.
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.
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.
void	clear_spline_nodes (MeshBase &)
	Remove spline node (for IsoGeometric Analysis meshes) elements and nodes and constraints from the mesh.
bool	valid_is_prepared (const MeshBase &mesh)
	A function for testing whether a mesh's cached is_prepared() setting is not a false positive.
template<>
void	libmesh_assert_topology_consistent_procids< Elem > (const MeshBase &mesh)
template<>
void	libmesh_assert_topology_consistent_procids< Node > (const MeshBase &mesh)
template<>
void	libmesh_assert_parallel_consistent_procids< Elem > (const MeshBase &mesh)
template<>
void	libmesh_assert_parallel_consistent_procids< Node > (const MeshBase &mesh)
void	libmesh_assert_equal_n_systems (const MeshBase &mesh)
	The following functions, only available in builds with NDEBUG undefined, are for asserting internal consistency that we hope should never be broken in opt.
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.
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.
void	libmesh_assert_valid_remote_elems (const MeshBase &mesh)
	A function for verifying that active local elements' neighbors are never remote elements.
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)
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)
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)
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 processor, as is required by libMesh numeric classes.
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).
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()
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.
void	libmesh_assert_no_links_to_elem (const MeshBase &mesh, const Elem *bad_elem)
	The following functions, only available in builds with DEBUG defined, typically have surprisingly slow asymptotic behavior, and so are unsuitable for use even with METHOD=devel.
void	libmesh_assert_equal_points (const MeshBase &mesh)
	A function for testing that node locations match across processors.
void	libmesh_assert_equal_connectivity (const MeshBase &mesh)
	A function for testing that element nodal connectivities match across processors.
void	libmesh_assert_connected_nodes (const MeshBase &mesh)
	A function for verifying that all nodes are connected to at least one element.
void	libmesh_assert_valid_constraint_rows (const MeshBase &mesh)
	A function for verifying that all mesh constraint rows express relations between nodes and elements that are semilocal (local or ghosted) to the current processor's portion of the mesh.
void	libmesh_assert_valid_boundary_ids (const MeshBase &mesh)
	A function for verifying that boundary condition ids match across processors.
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.
void	libmesh_assert_valid_unique_ids (const MeshBase &mesh)
	A function for verifying that unique ids match across processors.
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)
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.
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 received consistent DofObject::id(), using element topology to identify matching nodes.
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)
template<typename DofObjectSubclass >
void	libmesh_assert_valid_procids (const MeshBase &mesh)
	A function for verifying that processor assignment is both parallel and topologically consistent.
void	libmesh_assert_valid_refinement_flags (const MeshBase &mesh)
	A function for verifying that refinement flags on elements are consistent between processors.
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)

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

Sphere libMesh::MeshTools::bounding_sphere

(

const MeshBase &

mesh

)

Returns

A bounding sphere for mesh instead of a bounding box.

Definition at line 618 of file mesh_tools.C.

{
  libMesh::BoundingBox bbox = create_bounding_box(mesh);
 
  const Real  diag = (bbox.second - bbox.first).norm();
  const Point cent = (bbox.second + bbox.first)/2;
 
  return Sphere (cent, .5*diag);
}

References create_bounding_box(), mesh, and libMesh::Real.

build_nodes_to_elem_map() [1/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.

Definition at line 511 of file mesh_tools.C.

{
  nodes_to_elem_map.clear();
 
  for (const auto & elem : mesh.element_ptr_range())
    for (auto & node : elem->node_ref_range())
      nodes_to_elem_map[node.id()].push_back(elem);
}

References mesh.

build_nodes_to_elem_map() [2/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.

Definition at line 499 of file mesh_tools.C.

{
  nodes_to_elem_map.clear();
 
  for (const auto & elem : mesh.element_ptr_range())
    for (auto & node : elem->node_ref_range())
      nodes_to_elem_map[node.id()].push_back(elem->id());
}

References mesh.

build_nodes_to_elem_map() [3/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.

Definition at line 478 of file mesh_tools.C.

{
  // A vector indexed over all nodes is too inefficient to use for a
  // distributed mesh.  Use the unordered_map API instead.
  if (!mesh.is_serial())
    libmesh_deprecated();
 
  nodes_to_elem_map.resize (mesh.max_node_id());
 
  for (const auto & elem : mesh.element_ptr_range())
    for (auto & node : elem->node_ref_range())
      {
        libmesh_assert_less (node.id(), nodes_to_elem_map.size());
 
        nodes_to_elem_map[node.id()].push_back(elem);
      }
}

References libMesh::MeshBase::is_serial(), libMesh::MeshBase::max_node_id(), and mesh.

build_nodes_to_elem_map() [4/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.

Definition at line 456 of file mesh_tools.C.

{
  // A vector indexed over all nodes is too inefficient to use for a
  // distributed mesh.  Use the unordered_map API instead.
  if (!mesh.is_serial())
    libmesh_deprecated();
 
  nodes_to_elem_map.resize (mesh.max_node_id());
 
  for (const auto & elem : mesh.element_ptr_range())
    for (auto & node : elem->node_ref_range())
      {
        libmesh_assert_less (node.id(), nodes_to_elem_map.size());
        libmesh_assert_less (elem->id(), mesh.n_elem());
 
        nodes_to_elem_map[node.id()].push_back(elem->id());
      }
}

References libMesh::MeshBase::is_serial(), libMesh::MeshBase::max_node_id(), mesh, and libMesh::MeshBase::n_elem().

Referenced by libMesh::VariationalSmootherConstraint::constrain(), NodalNeighborsTest::do_test(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::GenericProjector(), libMesh::MeshTools::Subdivision::prepare_subdivision_mesh(), libMesh::C0Polyhedron::retriangulate(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), MeshSmootherTest::testVariationalSmoother(), and libMesh::Tree< N >::Tree().

clear_spline_nodes()

void libMesh::MeshTools::clear_spline_nodes

(

MeshBase &

mesh

)

Remove spline node (for IsoGeometric Analysis meshes) elements and nodes and constraints from the mesh.

This should be done after the mesh is read but before the constraints are used by System initialization. The result is a mesh and solution space with lower required continuity and more unconstrained degrees of freedom, but with fewer total degrees of freedom and far fewer constraint equations.

Definition at line 1221 of file mesh_tools.C.

{
  std::vector<Elem *> nodeelem_to_delete;
 
  for (auto & elem : mesh.element_ptr_range())
    if (elem->type() == NODEELEM &&
        elem->mapping_type() == RATIONAL_BERNSTEIN_MAP)
      nodeelem_to_delete.push_back(elem);
 
  auto & constraint_rows = mesh.get_constraint_rows();
 
  // All our constraint_rows ought to be for spline constraints we're
  // about to get rid of.
#ifndef NDEBUG
  for (auto & node_row : constraint_rows)
    for (auto pr : node_row.second)
      {
        const Elem * elem = pr.first.first;
        libmesh_assert(elem->type() == NODEELEM);
        libmesh_assert(elem->mapping_type() == RATIONAL_BERNSTEIN_MAP);
      }
#endif
 
  constraint_rows.clear();
 
  for (Elem * elem : nodeelem_to_delete)
    {
      Node * node = elem->node_ptr(0);
      mesh.delete_elem(elem);
      mesh.delete_node(node);
    }
}

References libMesh::MeshBase::delete_elem(), libMesh::MeshBase::delete_node(), libMesh::MeshBase::get_constraint_rows(), libMesh::libmesh_assert(), libMesh::Elem::mapping_type(), mesh, libMesh::NODEELEM, libMesh::RATIONAL_BERNSTEIN_MAP, and libMesh::Elem::type().

Referenced by libMesh::DynaIO::read_mesh().

correct_node_proc_ids()

void libMesh::MeshTools::correct_node_proc_ids

(

MeshBase &

mesh

)

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.

Definition at line 2508 of file mesh_tools.C.

{
  LOG_SCOPE("correct_node_proc_ids()","MeshTools");
 
  // This function must be run on all processors at once
  libmesh_parallel_only(mesh.comm());
 
  // We require all processors to agree on nodal processor ids before
  // going into this algorithm.
#ifdef DEBUG
  libmesh_assert_parallel_consistent_procids<Node>(mesh);
#endif
 
  // If we have any unpartitioned elements at this
  // stage there is a problem
  libmesh_assert (n_elem(mesh.unpartitioned_elements_begin(),
                         mesh.unpartitioned_elements_end()) == 0);
 
  // Fix nodes' processor ids.  Coarsening may have left us with nodes
  // which are no longer touched by any elements of the same processor
  // id, and for DofMap to work we need to fix that.
 
  // This is harder now that libMesh no longer requires a distributed
  // mesh to ghost all nodal neighbors: it is possible for two active
  // elements on two different processors to share the same node in
  // such a way that neither processor knows the others' element
  // exists!
 
  // While we're at it, if this mesh is configured to allow
  // repartitioning, we'll repartition *all* the nodes' processor ids
  // using the canonical Node heuristic, to try and improve DoF load
  // balancing.  But if the mesh is disallowing repartitioning, we
  // won't touch processor_id on any node where it's valid, regardless
  // of whether or not it's canonical.
  bool repartition_all_nodes = !mesh.skip_noncritical_partitioning();
  std::unordered_set<const Node *> valid_nodes;
 
  // If we aren't allowed to repartition, then we're going to leave
  // every node we can at its current processor_id, and *only*
  // repartition the nodes whose current processor id is incompatible
  // with DoFMap (because it doesn't touch an active element, e.g. due
  // to coarsening)
  if (!repartition_all_nodes)
    {
      for (const auto & elem : mesh.active_element_ptr_range())
        for (const auto & node : elem->node_ref_range())
          if (elem->processor_id() == node.processor_id())
            valid_nodes.insert(&node);
 
      SyncNodeSet syncv(valid_nodes, mesh);
 
      Parallel::sync_dofobject_data_by_id
        (mesh.comm(), mesh.nodes_begin(), mesh.nodes_end(), syncv);
    }
 
  // We build up a set of compatible processor ids for each node
  proc_id_map_type new_proc_ids;
 
  for (auto & elem : mesh.active_element_ptr_range())
    {
      processor_id_type pid = elem->processor_id();
 
      for (auto & node : elem->node_ref_range())
        {
          const dof_id_type id = node.id();
          if (auto it = new_proc_ids.find(id);
              it == new_proc_ids.end())
            new_proc_ids.emplace(id, pid);
          else
            it->second = node.choose_processor_id(it->second, pid);
        }
    }
 
  // Sort the new pids to push to each processor
  std::map<processor_id_type, std::vector<std::pair<dof_id_type, processor_id_type>>>
    ids_to_push;
 
  for (const auto & node : mesh.node_ptr_range())
    if (const auto it = std::as_const(new_proc_ids).find(node->id());
        it != new_proc_ids.end() && node->processor_id() != DofObject::invalid_processor_id)
      ids_to_push[node->processor_id()].emplace_back(node->id(), /*pid=*/it->second);
 
  auto action_functor =
    [& mesh, & new_proc_ids]
    (processor_id_type,
     const std::vector<std::pair<dof_id_type, processor_id_type>> & data)
    {
      for (const auto & [id, pid] : data)
        {
          if (const auto it = new_proc_ids.find(id);
              it == new_proc_ids.end())
            new_proc_ids.emplace(id, pid);
          else
            {
              const Node & node = mesh.node_ref(id);
              it->second = node.choose_processor_id(it->second, pid);
            }
        }
    };
 
  Parallel::push_parallel_vector_data
    (mesh.comm(), ids_to_push, action_functor);
 
  // Now new_proc_ids is correct for every node we used to own.  Let's
  // ask every other processor about the nodes they used to own.  But
  // first we'll need to keep track of which nodes we used to own,
  // lest we get them confused with nodes we newly own.
  std::unordered_set<Node *> ex_local_nodes;
  for (auto & node : mesh.local_node_ptr_range())
    if (const auto it = new_proc_ids.find(node->id());
        it != new_proc_ids.end() && it->second != mesh.processor_id())
      ex_local_nodes.insert(node);
 
  SyncProcIdsFromMap sync(new_proc_ids, mesh);
  if (repartition_all_nodes)
    Parallel::sync_dofobject_data_by_id
      (mesh.comm(), mesh.nodes_begin(), mesh.nodes_end(), sync);
  else
    {
      NodesNotInSet nnis(valid_nodes);
 
      Parallel::sync_dofobject_data_by_id
        (mesh.comm(), mesh.nodes_begin(), mesh.nodes_end(), nnis, sync);
    }
 
  // And finally let's update the nodes we used to own.
  for (const auto & node : ex_local_nodes)
    {
      if (valid_nodes.count(node))
        continue;
 
      const dof_id_type id = node->id();
      const proc_id_map_type::iterator it = new_proc_ids.find(id);
      libmesh_assert(it != new_proc_ids.end());
      node->processor_id() = it->second;
    }
 
  // We should still have consistent nodal processor ids coming out of
  // this algorithm, but if we're allowed to repartition the mesh then
  // they should be canonically correct too.
#ifdef DEBUG
  libmesh_assert_valid_procids<Node>(mesh);
  //if (repartition_all_nodes)
  //  libmesh_assert_canonical_node_procids(mesh);
#endif
}

References libMesh::Node::choose_processor_id(), libMesh::ParallelObject::comm(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), libmesh_assert_parallel_consistent_procids< Node >(), mesh, n_elem(), new_proc_ids, libMesh::MeshBase::node_ref(), libMesh::ParallelObject::processor_id(), TIMPI::push_parallel_vector_data(), libMesh::MeshBase::skip_noncritical_partitioning(), and libMesh::Parallel::sync_dofobject_data_by_id().

Referenced by libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), and libMesh::MeshBase::partition().

create_bounding_box()

libMesh::BoundingBox libMesh::MeshTools::create_bounding_box

(

const MeshBase &

mesh

)

Returns

A BoundingBox that bounds the mesh.

Definition at line 566 of file mesh_tools.C.

{
  // This function must be run on all processors at once
  libmesh_parallel_only(mesh.comm());
 
  FindBBox find_bbox;
 
  // Start with any unpartitioned elements we know about locally
  Threads::parallel_reduce (ConstElemRange (mesh.pid_elements_begin(DofObject::invalid_processor_id),
                                            mesh.pid_elements_end(DofObject::invalid_processor_id)),
                            find_bbox);
 
  // And combine with our local elements
  find_bbox.bbox().union_with(create_local_bounding_box(mesh));
 
  // Compare the bounding boxes across processors
  mesh.comm().min(find_bbox.min());
  mesh.comm().max(find_bbox.max());
 
  return find_bbox.bbox();
}

References libMesh::ParallelObject::comm(), create_local_bounding_box(), libMesh::DofObject::invalid_processor_id, libMesh::Parallel::Communicator::max(), mesh, libMesh::Parallel::Communicator::min(), and libMesh::Threads::parallel_reduce().

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), bounding_sphere(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::MeshBase::get_info(), libMesh::PointLocatorTree::init(), libMesh::MetisPartitioner::partition_range(), libMesh::Partitioner::partition_unpartitioned_elements(), MeshGenerationTest::testBuildCube(), MeshGenerationTest::testBuildLine(), MeshGenerationTest::testBuildSquare(), libMesh::Tree< N >::Tree(), and libMesh::PostscriptIO::write().

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.

Definition at line 631 of file mesh_tools.C.

{
  FindBBox find_bbox;
 
  Threads::parallel_reduce (ConstElemRange (mesh.local_elements_begin(),
                                            mesh.local_elements_end()),
                            find_bbox);
 
  return find_bbox.bbox();
}

References mesh, and libMesh::Threads::parallel_reduce().

Referenced by create_bounding_box(), and libMesh::MeshBase::get_info().

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.

Definition at line 591 of file mesh_tools.C.

{
  // This function must be run on all processors at once
  libmesh_parallel_only(mesh.comm());
 
  FindBBox find_bbox;
 
  // Start with any unpartitioned nodes we know about locally
  Threads::parallel_reduce (ConstNodeRange (mesh.pid_nodes_begin(DofObject::invalid_processor_id),
                                            mesh.pid_nodes_end(DofObject::invalid_processor_id)),
                            find_bbox);
 
  // Add our local nodes
  Threads::parallel_reduce (ConstNodeRange (mesh.local_nodes_begin(),
                                            mesh.local_nodes_end()),
                            find_bbox);
 
  // Compare the bounding boxes across processors
  mesh.comm().min(find_bbox.min());
  mesh.comm().max(find_bbox.max());
 
  return find_bbox.bbox();
}

References libMesh::ParallelObject::comm(), libMesh::DofObject::invalid_processor_id, libMesh::Parallel::Communicator::max(), mesh, libMesh::Parallel::Communicator::min(), and libMesh::Threads::parallel_reduce().

Referenced by libMesh::MeshCommunication::assign_global_indices(), libMesh::MeshCommunication::check_for_duplicate_global_indices(), MeshGenerationTest::testBuildCube(), and MeshGenerationTest::testBuildSquare().

create_processor_bounding_box()

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

Returns

A BoundingBox that bounds the elements belonging to processor pid.

Definition at line 645 of file mesh_tools.C.

{
  // This can only be run in parallel, with consistent arguments.
  libmesh_parallel_only(mesh.comm());
  libmesh_assert(mesh.comm().verify(pid));
 
  libmesh_assert_less (pid, mesh.n_processors());
 
  FindBBox find_bbox;
 
  Threads::parallel_reduce (ConstElemRange (mesh.pid_elements_begin(pid),
                                            mesh.pid_elements_end(pid)),
                            find_bbox);
 
  // Compare the bounding boxes across processors
  mesh.comm().min(find_bbox.min());
  mesh.comm().max(find_bbox.max());
 
  return find_bbox.bbox();
}

References libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), mesh, libMesh::Parallel::Communicator::min(), libMesh::ParallelObject::n_processors(), libMesh::Threads::parallel_reduce(), and libMesh::Parallel::Communicator::verify().

Referenced by processor_bounding_sphere().

create_subdomain_bounding_box()

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

Returns

A BoundingBox that bounds the elements belonging to subdomain sid.

Definition at line 685 of file mesh_tools.C.

{
  // This can only be run in parallel, with consistent arguments.
  libmesh_parallel_only(mesh.comm());
  libmesh_assert(mesh.comm().verify(sid));
 
  FindBBox find_bbox;
 
  Threads::parallel_reduce
    (ConstElemRange (mesh.active_local_subdomain_elements_begin(sid),
                     mesh.active_local_subdomain_elements_end(sid)),
     find_bbox);
 
  // Compare the bounding boxes across processors
  mesh.comm().min(find_bbox.min());
  mesh.comm().max(find_bbox.max());
 
  return find_bbox.bbox();
}

References libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), mesh, libMesh::Parallel::Communicator::min(), libMesh::Threads::parallel_reduce(), and libMesh::Parallel::Communicator::verify().

Referenced by subdomain_bounding_sphere().

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.

Definition at line 723 of file mesh_tools.C.

{
  // Loop over the the elements.  If the current element type isn't in
  // the vector, insert it.
  for (const auto & elem : mesh.element_ptr_range())
    if (!std::count(et.begin(), et.end(), elem->type()))
      et.push_back(elem->type());
}

References mesh.

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 elements from 2 or more blocks

Definition at line 544 of file mesh_tools.C.

{
  std::unordered_set<dof_id_type> block_boundary_nodes;
 
  // Loop over elements, find those on boundary, and
  // mark them as true in on_boundary.
  for (const auto & elem : mesh.active_element_ptr_range())
    for (auto s : elem->side_index_range())
      if (elem->neighbor_ptr(s) && (elem->neighbor_ptr(s)->subdomain_id() != elem->subdomain_id()))
        {
          auto nodes_on_side = elem->nodes_on_side(s);
 
          for (auto & local_id : nodes_on_side)
            block_boundary_nodes.insert(elem->node_ptr(local_id)->id());
        }
 
  return block_boundary_nodes;
}

References mesh.

Referenced by libMesh::LaplaceMeshSmoother::smooth().

find_boundary_nodes()

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.

Definition at line 524 of file mesh_tools.C.

{
  std::unordered_set<dof_id_type> boundary_nodes;
 
  // Loop over elements, find those on boundary, and
  // mark them as true in on_boundary.
  for (const auto & elem : mesh.active_element_ptr_range())
    for (auto s : elem->side_index_range())
      if (elem->neighbor_ptr(s) == nullptr) // on the boundary
        {
          auto nodes_on_side = elem->nodes_on_side(s);
 
          for (auto & local_id : nodes_on_side)
            boundary_nodes.insert(elem->node_ptr(local_id)->id());
        }
 
  return boundary_nodes;
}

References mesh.

Referenced by libMesh::VariationalSmootherConstraint::constrain(), libMesh::MeshTools::Modification::distort(), DistortTest::perturb_and_check(), libMesh::LaplaceMeshSmoother::smooth(), and libMesh::MeshTools::Modification::smooth().

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.

Definition at line 1133 of file mesh_tools.C.

{
  // Loop through all the elements
  for (auto & elem : mesh.active_local_element_ptr_range())
    if (elem->type() == QUAD4)
      for (auto s : elem->side_index_range())
        {
          // Loop over the sides looking for sides that have hanging nodes
          // This code is inspired by compute_proj_constraints()
          const Elem * neigh = elem->neighbor_ptr(s);
 
          // If not a boundary side
          if (neigh != nullptr)
            {
              // Is there a coarser element next to this one?
              if (neigh->level() < elem->level())
                {
                  const Elem * ancestor = elem;
                  while (neigh->level() < ancestor->level())
                    ancestor = ancestor->parent();
                  unsigned int s_neigh = neigh->which_neighbor_am_i(ancestor);
                  libmesh_assert_less (s_neigh, neigh->n_neighbors());
 
                  // Couple of helper uints...
                  unsigned int local_node1=0;
                  unsigned int local_node2=0;
 
                  bool found_in_neighbor = false;
 
                  // Find the two vertices that make up this side
                  while (!elem->is_node_on_side(local_node1++,s)) { }
                  local_node1--;
 
                  // Start looking for the second one with the next node
                  local_node2=local_node1+1;
 
                  // Find the other one
                  while (!elem->is_node_on_side(local_node2++,s)) { }
                  local_node2--;
 
                  //Pull out their global ids:
                  dof_id_type node1 = elem->node_id(local_node1);
                  dof_id_type node2 = elem->node_id(local_node2);
 
                  // Now find which node is present in the neighbor
                  // FIXME This assumes a level one rule!
                  // The _other_ one is the hanging node
 
                  // First look for the first one
                  // FIXME could be streamlined a bit
                  for (unsigned int n=0;n<neigh->n_sides();n++)
                    if (neigh->node_id(n) == node1)
                      found_in_neighbor=true;
 
                  dof_id_type hanging_node=0;
 
                  if (!found_in_neighbor)
                    hanging_node=node1;
                  else // If it wasn't node1 then it must be node2!
                    hanging_node=node2;
 
                  // Reset for reuse
                  local_node1=0;
 
                  // Find the first node that makes up the side in the neighbor (these should be the parent nodes)
                  while (!neigh->is_node_on_side(local_node1++,s_neigh)) { }
                  local_node1--;
 
                  local_node2=local_node1+1;
 
                  // Find the second node...
                  while (!neigh->is_node_on_side(local_node2++,s_neigh)) { }
                  local_node2--;
 
                  // Save them if we haven't already found the parents for this one
                  if (hanging_nodes[hanging_node].size()<2)
                    {
                      hanging_nodes[hanging_node].push_back(neigh->node_id(local_node1));
                      hanging_nodes[hanging_node].push_back(neigh->node_id(local_node2));
                    }
                }
            }
        }
}

References libMesh::Elem::is_node_on_side(), libMesh::Elem::level(), mesh, libMesh::Elem::n_neighbors(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_id(), libMesh::Elem::parent(), libMesh::QUAD4, and libMesh::Elem::which_neighbor_am_i().

find_nodal_neighbors() [1/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.

Definition at line 1082 of file mesh_tools.C.

{
  const std::vector<const Elem *> node_to_elem_vec =
    libmesh_map_find(nodes_to_elem_map, node.id());
  find_nodal_neighbors_helper(node.id(), node_to_elem_vec, neighbors);
}

References libMesh::DofObject::id().

find_nodal_neighbors() [2/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.

Definition at line 1071 of file mesh_tools.C.

{
  find_nodal_neighbors_helper(node.id(), nodes_to_elem_map[node.id()],
                              neighbors);
}

References libMesh::DofObject::id().

Referenced by NodalNeighborsTest::do_test(), find_nodal_or_face_neighbors(), libMesh::MeshTools::Subdivision::prepare_subdivision_mesh(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), and libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner().

find_nodal_or_face_neighbors()

void libMesh::MeshTools::find_nodal_or_face_neighbors	(	const MeshBase &	mesh,
		const Node &	node,
		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.

IF NO nodal neighbors are found, all nodes on the containing side are treated as neighbors. This is useful when the node does not lie on an edge, such as the central face node in HEX27, TET14, etc. elements.

Definition at line 1092 of file mesh_tools.C.

{
  // Find all the nodal neighbors... that is the nodes directly connected
  // to this node through one edge.
  find_nodal_neighbors(mesh, node, nodes_to_elem_map, neighbors);
 
  // If no neighbors are found, use all nodes on the containing side as
  // neighbors.
  if (!neighbors.size())
    {
      // Grab the element containing node
      const auto * elem = libmesh_map_find(nodes_to_elem_map, node.id()).front();
      // Find the element side containing node
      for (const auto &side : elem->side_index_range())
        {
          const auto &nodes_on_side = elem->nodes_on_side(side);
          const auto it =
              std::find_if(nodes_on_side.begin(), nodes_on_side.end(), [&](auto local_node_id) {
                return elem->node_id(local_node_id) == node.id();
              });
 
          if (it != nodes_on_side.end())
            {
              for (const auto &local_node_id : nodes_on_side)
                // No need to add node itself as a neighbor
                if (const auto *node_ptr = elem->node_ptr(local_node_id);
                    *node_ptr != node)
                  neighbors.push_back(node_ptr);
              break;
            }
        }
    }
  libmesh_assert(neighbors.size());
}

References find_nodal_neighbors(), libMesh::DofObject::id(), libMesh::libmesh_assert(), and mesh.

Referenced by libMesh::VariationalSmootherConstraint::get_neighbors_for_boundary_constraint(), libMesh::VariationalSmootherConstraint::get_neighbors_for_subdomain_constraint(), and MeshSmootherTest::testVariationalSmoother().

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.

Definition at line 993 of file mesh_tools.C.

{
  for (const auto & elem : mesh.element_ptr_range())
    if (!elem->subactive())
      for (auto & n : elem->node_ref_range())
        not_subactive_node_ids.insert(n.id());
}

References mesh.

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

Definition at line 1614 of file mesh_tools.C.

{
  for (const auto & elem : mesh.active_element_ptr_range())
    for (auto & node : elem->node_ref_range())
      libmesh_assert_equal_to
        (node.processor_id(),
         node.choose_processor_id(node.processor_id(),
                                  elem->processor_id()));
}

References mesh.

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.

Definition at line 1722 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_connected_nodes()", "MeshTools");
 
  std::set<const Node *> used_nodes;
 
  for (const auto & elem : mesh.element_ptr_range())
    {
      libmesh_assert (elem);
 
      for (auto & n : elem->node_ref_range())
        used_nodes.insert(&n);
    }
 
  for (const auto & node : mesh.node_ptr_range())
    {
      libmesh_assert(node);
      libmesh_assert(used_nodes.count(node));
    }
}

References libMesh::libmesh_assert(), and mesh.

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)

Definition at line 2069 of file mesh_tools.C.

{
  libmesh_parallel_only(mesh.comm());
 
  dof_id_type parallel_max_elem_id = mesh.max_elem_id();
  mesh.comm().max(parallel_max_elem_id);
 
  for (dof_id_type i=0; i != parallel_max_elem_id; ++i)
    {
      const Elem * elem = mesh.query_elem_ptr(i);
      processor_id_type pid =
        elem ? elem->processor_id() : DofObject::invalid_processor_id;
      mesh.comm().min(pid);
      libmesh_assert(elem || pid != mesh.processor_id());
    }
 
  dof_id_type parallel_max_node_id = mesh.max_node_id();
  mesh.comm().max(parallel_max_node_id);
 
  for (dof_id_type i=0; i != parallel_max_node_id; ++i)
    {
      const Node * node = mesh.query_node_ptr(i);
      processor_id_type pid =
        node ? node->processor_id() : DofObject::invalid_processor_id;
      mesh.comm().min(pid);
      libmesh_assert(node || pid != mesh.processor_id());
    }
}

References libMesh::ParallelObject::comm(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::max_elem_id(), libMesh::MeshBase::max_node_id(), mesh, libMesh::Parallel::Communicator::min(), libMesh::DofObject::processor_id(), libMesh::ParallelObject::processor_id(), libMesh::MeshBase::query_elem_ptr(), and libMesh::MeshBase::query_node_ptr().

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.

Definition at line 2099 of file mesh_tools.C.

{
  libmesh_parallel_only(mesh.comm());
  auto locator = mesh.sub_point_locator();
 
  dof_id_type parallel_max_elem_id = mesh.max_elem_id();
  mesh.comm().max(parallel_max_elem_id);
 
  for (dof_id_type i=0; i != parallel_max_elem_id; ++i)
    {
      const Elem * elem = mesh.query_elem_ptr(i);
 
      const unsigned int my_n_nodes = elem ? elem->n_nodes() : 0;
      unsigned int n_nodes = my_n_nodes;
      mesh.comm().max(n_nodes);
 
      if (n_nodes)
        libmesh_assert(mesh.comm().semiverify(elem ? &my_n_nodes : nullptr));
 
      for (unsigned int n=0; n != n_nodes; ++n)
        {
          const Node * node = elem ? elem->node_ptr(n) : nullptr;
          processor_id_type pid =
            node ? node->processor_id() : DofObject::invalid_processor_id;
          mesh.comm().min(pid);
          libmesh_assert(node || pid != mesh.processor_id());
        }
    }
}

References libMesh::ParallelObject::comm(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::max_elem_id(), mesh, libMesh::Parallel::Communicator::min(), libMesh::Elem::n_nodes(), n_nodes, libMesh::Elem::node_ptr(), libMesh::DofObject::processor_id(), libMesh::ParallelObject::processor_id(), libMesh::MeshBase::query_elem_ptr(), libMesh::Parallel::Communicator::semiverify(), and libMesh::MeshBase::sub_point_locator().

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 processor, as is required by libMesh numeric classes.

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

Definition at line 1477 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_contiguous_dof_ids()", "MeshTools");
 
  if (mesh.n_processors() == 1)
    return;
 
  libmesh_parallel_only(mesh.comm());
 
  dof_id_type min_dof_id = std::numeric_limits<dof_id_type>::max(),
              max_dof_id = std::numeric_limits<dof_id_type>::min();
 
  // Figure out what our local dof id range is
  for (const auto * node : mesh.local_node_ptr_range())
    {
      for (auto v : make_range(node->n_vars(sysnum)))
        for (auto c : make_range(node->n_comp(sysnum, v)))
          {
            dof_id_type id = node->dof_number(sysnum, v, c);
            min_dof_id = std::min (min_dof_id, id);
            max_dof_id = std::max (max_dof_id, id);
          }
    }
 
  // Make sure no other processors' ids are inside it
  for (const auto * node : mesh.node_ptr_range())
    {
      if (node->processor_id() == mesh.processor_id())
        continue;
      for (auto v : make_range(node->n_vars(sysnum)))
        for (auto c : make_range(node->n_comp(sysnum, v)))
          {
            dof_id_type id = node->dof_number(sysnum, v, c);
            libmesh_assert (id < min_dof_id ||
                            id > max_dof_id);
          }
    }
}

References libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), libMesh::make_range(), mesh, libMesh::ParallelObject::n_processors(), and libMesh::ParallelObject::processor_id().

libmesh_assert_equal_connectivity()

void libMesh::MeshTools::libmesh_assert_equal_connectivity

(

const MeshBase &

mesh

)

A function for testing that element nodal connectivities match across processors.

Definition at line 1701 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_equal_connectivity()", "MeshTools");
 
  dof_id_type pmax_elem_id = mesh.max_elem_id();
  mesh.comm().max(pmax_elem_id);
 
  for (dof_id_type i=0; i != pmax_elem_id; ++i)
    {
      const Elem * e = mesh.query_elem_ptr(i);
 
      std::vector<dof_id_type> nodes;
      if (e)
        for (auto n : e->node_index_range())
          nodes.push_back(e->node_id(n));
 
      libmesh_assert(mesh.comm().semiverify(e ? &nodes : nullptr));
    }
}

References libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::max_elem_id(), mesh, libMesh::Elem::node_id(), libMesh::Elem::node_index_range(), libMesh::MeshBase::query_elem_ptr(), and libMesh::Parallel::Communicator::semiverify().

Referenced by libMesh::MeshCommunication::assign_global_indices(), and libMesh::SimplexRefiner::refine_via_edges().

libmesh_assert_equal_n_systems()

void libMesh::MeshTools::libmesh_assert_equal_n_systems

(

const MeshBase &

mesh

)

The following functions, only available in builds with NDEBUG undefined, are for asserting internal consistency that we hope should never be broken in opt.

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

Definition at line 1292 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_equal_n_systems()", "MeshTools");
 
  unsigned int n_sys = libMesh::invalid_uint;
 
  for (const auto & elem : mesh.element_ptr_range())
    {
      if (n_sys == libMesh::invalid_uint)
        n_sys = elem->n_systems();
      else
        libmesh_assert_equal_to (elem->n_systems(), n_sys);
    }
 
  for (const auto & node : mesh.node_ptr_range())
    {
      if (n_sys == libMesh::invalid_uint)
        n_sys = node->n_systems();
      else
        libmesh_assert_equal_to (node->n_systems(), n_sys);
    }
}

References libMesh::invalid_uint, and mesh.

libmesh_assert_equal_points()

void libMesh::MeshTools::libmesh_assert_equal_points

(

const MeshBase &

mesh

)

A function for testing that node locations match across processors.

Definition at line 1685 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_equal_points()", "MeshTools");
 
  dof_id_type pmax_node_id = mesh.max_node_id();
  mesh.comm().max(pmax_node_id);
 
  for (dof_id_type i=0; i != pmax_node_id; ++i)
    {
      const Point * p = mesh.query_node_ptr(i);
 
      libmesh_assert(mesh.comm().semiverify(p));
    }
}

References libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::max_node_id(), mesh, libMesh::MeshBase::query_node_ptr(), and libMesh::Parallel::Communicator::semiverify().

Referenced by libMesh::MeshCommunication::assign_global_indices(), and libMesh::SimplexRefiner::refine_via_edges().

libmesh_assert_no_links_to_elem()

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

The following functions, only available in builds with DEBUG defined, typically have surprisingly slow asymptotic behavior, and so are unsuitable for use even with METHOD=devel.

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

Definition at line 1666 of file mesh_tools.C.

{
  for (const auto & elem : mesh.element_ptr_range())
    {
      libmesh_assert (elem);
      libmesh_assert_not_equal_to (elem->parent(), bad_elem);
      for (auto n : elem->neighbor_ptr_range())
        libmesh_assert_not_equal_to (n, bad_elem);
 
#ifdef LIBMESH_ENABLE_AMR
      if (elem->has_children())
        for (auto & child : elem->child_ref_range())
          libmesh_assert_not_equal_to (&child, bad_elem);
#endif
    }
}

References libMesh::libmesh_assert(), and 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.

Definition at line 1318 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_old_dof_objects()", "MeshTools");
 
  for (const auto & elem : mesh.element_ptr_range())
    {
      if (elem->refinement_flag() == Elem::JUST_REFINED ||
          elem->refinement_flag() == Elem::INACTIVE)
        continue;
 
      if (elem->has_dofs())
        libmesh_assert(elem->get_old_dof_object());
 
      for (auto & node : elem->node_ref_range())
        if (node.has_dofs())
          libmesh_assert(node.get_old_dof_object());
    }
}

References libMesh::Elem::INACTIVE, libMesh::Elem::JUST_REFINED, libMesh::libmesh_assert(), and mesh.

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 received consistent DofObject::id(), using element topology to identify matching nodes.

Definition at line 2180 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_parallel_consistent_new_node_procids()", "MeshTools");
 
  if (mesh.n_processors() == 1)
    return;
 
  libmesh_parallel_only(mesh.comm());
 
  // We want this test to hit every node when called even after nodes
  // have been added asynchronously but before everything has been
  // renumbered.
  dof_id_type parallel_max_elem_id = mesh.max_elem_id();
  mesh.comm().max(parallel_max_elem_id);
 
  std::vector<bool> elem_touched_by_anyone(parallel_max_elem_id, false);
 
  for (dof_id_type i=0; i != parallel_max_elem_id; ++i)
    {
      const Elem * elem = mesh.query_elem_ptr(i);
 
      const unsigned int my_n_nodes = elem ? elem->n_nodes() : 0;
      unsigned int n_nodes = my_n_nodes;
      mesh.comm().max(n_nodes);
 
      if (n_nodes)
        libmesh_assert(mesh.comm().semiverify(elem ? &my_n_nodes : nullptr));
 
      for (unsigned int n=0; n != n_nodes; ++n)
        {
          const Node * node = elem ? elem->node_ptr(n) : nullptr;
          const processor_id_type pid = node ? node->processor_id() : 0;
          libmesh_assert(mesh.comm().semiverify (node ? &pid : nullptr));
        }
    }
}

References libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::max_elem_id(), mesh, libMesh::Elem::n_nodes(), n_nodes, libMesh::ParallelObject::n_processors(), libMesh::Elem::node_ptr(), libMesh::DofObject::processor_id(), libMesh::MeshBase::query_elem_ptr(), and libMesh::Parallel::Communicator::semiverify().

Referenced by libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent().

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

template<>

void libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem > ( const MeshBase &  mesh )

private

Definition at line 2132 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_parallel_consistent_procids()", "MeshTools");
 
  if (mesh.n_processors() == 1)
    return;
 
  libmesh_parallel_only(mesh.comm());
 
  // Some code (looking at you, stitch_meshes) modifies DofObject ids
  // without keeping max_elem_id()/max_node_id() consistent, but
  // that's done in a safe way for performance reasons, so we'll play
  // along and just figure out new max ids ourselves.
  dof_id_type parallel_max_elem_id = 0;
  for (const auto & elem : mesh.element_ptr_range())
    parallel_max_elem_id = std::max<dof_id_type>(parallel_max_elem_id,
                                                 elem->id()+1);
  mesh.comm().max(parallel_max_elem_id);
 
  // Check processor ids for consistency between processors
 
  for (dof_id_type i=0; i != parallel_max_elem_id; ++i)
    {
      const Elem * elem = mesh.query_elem_ptr(i);
 
      processor_id_type min_id =
        elem ? elem->processor_id() :
        std::numeric_limits<processor_id_type>::max();
      mesh.comm().min(min_id);
 
      processor_id_type max_id =
        elem ? elem->processor_id() :
        std::numeric_limits<processor_id_type>::min();
      mesh.comm().max(max_id);
 
      if (elem)
        {
          libmesh_assert_equal_to (min_id, elem->processor_id());
          libmesh_assert_equal_to (max_id, elem->processor_id());
        }
 
      if (min_id == mesh.processor_id())
        libmesh_assert(elem);
    }
}

References libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), mesh, libMesh::Parallel::Communicator::min(), libMesh::ParallelObject::n_processors(), libMesh::DofObject::processor_id(), libMesh::ParallelObject::processor_id(), and libMesh::MeshBase::query_elem_ptr().

libmesh_assert_parallel_consistent_procids< Node >()

template<>

void libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node > ( const MeshBase &  mesh )

private

Definition at line 2218 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_parallel_consistent_procids()", "MeshTools");
 
  if (mesh.n_processors() == 1)
    return;
 
  libmesh_parallel_only(mesh.comm());
 
  // We want this test to be valid even when called even after nodes
  // have been added asynchronously but before they're renumbered
  //
  // Plus, some code (looking at you, stitch_meshes) modifies
  // DofObject ids without keeping max_elem_id()/max_node_id()
  // consistent, but that's done in a safe way for performance
  // reasons, so we'll play along and just figure out new max ids
  // ourselves.
  dof_id_type parallel_max_node_id = 0;
  for (const auto & node : mesh.node_ptr_range())
    parallel_max_node_id = std::max<dof_id_type>(parallel_max_node_id,
                                                 node->id()+1);
  mesh.comm().max(parallel_max_node_id);
 
  std::vector<bool> node_touched_by_anyone(parallel_max_node_id, false);
 
  for (const auto & elem : as_range(mesh.local_elements_begin(),
                                    mesh.local_elements_end()))
    {
      libmesh_assert (elem);
 
      for (auto & node : elem->node_ref_range())
        {
          dof_id_type nodeid = node.id();
          node_touched_by_anyone[nodeid] = true;
        }
    }
  mesh.comm().max(node_touched_by_anyone);
 
  // Check processor ids for consistency between processors
  // on any node an element touches
  for (dof_id_type i=0; i != parallel_max_node_id; ++i)
    {
      if (!node_touched_by_anyone[i])
        continue;
 
      const Node * node = mesh.query_node_ptr(i);
      const processor_id_type pid = node ? node->processor_id() : 0;
 
      libmesh_assert(mesh.comm().semiverify (node ? &pid : nullptr));
    }
}

References libMesh::as_range(), libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), mesh, libMesh::ParallelObject::n_processors(), libMesh::DofObject::processor_id(), libMesh::MeshBase::query_node_ptr(), and libMesh::Parallel::Communicator::semiverify().

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements(), correct_node_proc_ids(), and libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent().

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

template<>

void libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Elem > ( const MeshBase &  mesh )

private

Definition at line 1519 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_topology_consistent_procids()", "MeshTools");
 
  // This parameter is not used when !LIBMESH_ENABLE_AMR
  libmesh_ignore(mesh);
 
  // If we're adaptively refining, check processor ids for consistency
  // between parents and children.
#ifdef LIBMESH_ENABLE_AMR
 
  // Ancestor elements we won't worry about, but subactive and active
  // elements ought to have parents with consistent processor ids
  for (const auto & elem : mesh.element_ptr_range())
    {
      libmesh_assert(elem);
 
      if (!elem->active() && !elem->subactive())
        continue;
 
      const Elem * parent = elem->parent();
 
      if (parent)
        {
          libmesh_assert(parent->has_children());
          processor_id_type parent_procid = parent->processor_id();
          bool matching_child_id = false;
          // If we've got a remote_elem then we don't know whether
          // it's responsible for the parent's processor id; all
          // we can do is assume it is and let its processor fail
          // an assert if there's something wrong.
          for (auto & child : parent->child_ref_range())
            if (&child == remote_elem ||
                child.processor_id() == parent_procid)
              matching_child_id = true;
          libmesh_assert(matching_child_id);
        }
    }
#endif
}

References libMesh::Elem::child_ref_range(), libMesh::Elem::has_children(), libMesh::libmesh_assert(), libMesh::libmesh_ignore(), mesh, libMesh::Elem::parent(), libMesh::DofObject::processor_id(), and libMesh::remote_elem.

libmesh_assert_topology_consistent_procids< Node >()

template<>

void libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node > ( const MeshBase &  mesh )

private

Definition at line 1563 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_topology_consistent_procids()", "MeshTools");
 
  if (mesh.n_processors() == 1)
    return;
 
  libmesh_parallel_only(mesh.comm());
 
  // We want this test to be valid even when called after nodes have
  // been added asynchronously but before they're renumbered.
  //
  // Plus, some code (looking at you, stitch_meshes) modifies
  // DofObject ids without keeping max_elem_id()/max_node_id()
  // consistent, but that's done in a safe way for performance
  // reasons, so we'll play along and just figure out new max ids
  // ourselves.
  dof_id_type parallel_max_node_id = 0;
  for (const auto & node : mesh.node_ptr_range())
    parallel_max_node_id = std::max<dof_id_type>(parallel_max_node_id,
                                                 node->id()+1);
  mesh.comm().max(parallel_max_node_id);
 
 
  std::vector<bool> node_touched_by_me(parallel_max_node_id, false);
 
  for (const auto & elem : as_range(mesh.local_elements_begin(),
                                    mesh.local_elements_end()))
    {
      libmesh_assert (elem);
 
      for (auto & node : elem->node_ref_range())
        {
          dof_id_type nodeid = node.id();
          node_touched_by_me[nodeid] = true;
        }
    }
  std::vector<bool> node_touched_by_anyone(node_touched_by_me);
  mesh.comm().max(node_touched_by_anyone);
 
  for (const auto & node : mesh.local_node_ptr_range())
    {
      libmesh_assert(node);
      dof_id_type nodeid = node->id();
      libmesh_assert(!node_touched_by_anyone[nodeid] ||
                     node_touched_by_me[nodeid]);
    }
}

References libMesh::as_range(), libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), mesh, and libMesh::ParallelObject::n_processors().

Referenced by libMesh::MeshCommunication::make_node_ids_parallel_consistent().

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)

Definition at line 1421 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_valid_amr_elem_ids()", "MeshTools");
 
  for (const auto & elem : mesh.element_ptr_range())
    {
      libmesh_assert (elem);
 
      const Elem * parent = elem->parent();
 
      if (parent)
        {
          libmesh_assert_greater_equal (elem->id(), parent->id());
          libmesh_assert_greater_equal (elem->processor_id(), parent->processor_id());
        }
    }
}

References libMesh::DofObject::id(), libMesh::libmesh_assert(), mesh, libMesh::Elem::parent(), and libMesh::DofObject::processor_id().

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements().

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)

Definition at line 1441 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_valid_amr_interior_parents()", "MeshTools");
 
  for (const auto & elem : mesh.element_ptr_range())
    {
      libmesh_assert (elem);
 
      // We can skip to the next element if we're full-dimension
      // and therefore don't have any interior parents
      if (elem->dim() >= LIBMESH_DIM)
        continue;
 
      const Elem * ip = elem->interior_parent();
 
      const Elem * parent = elem->parent();
 
      if (ip && (ip != remote_elem) && parent)
        {
          libmesh_assert_equal_to (ip->top_parent(),
                                   elem->top_parent()->interior_parent());
 
          if (ip->level() == elem->level())
            libmesh_assert_equal_to (ip->parent(),
                                     parent->interior_parent());
          else
            {
              libmesh_assert_less (ip->level(), elem->level());
              libmesh_assert_equal_to (ip, parent->interior_parent());
            }
        }
    }
}

References libMesh::Elem::interior_parent(), libMesh::Elem::level(), libMesh::libmesh_assert(), mesh, libMesh::Elem::parent(), libMesh::remote_elem, and libMesh::Elem::top_parent().

Referenced by libMesh::UnstructuredMesh::find_neighbors().

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.

Definition at line 1788 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_valid_boundary_ids()", "MeshTools");
 
  if (mesh.n_processors() == 1)
    return;
 
  libmesh_parallel_only(mesh.comm());
 
  const BoundaryInfo & boundary_info = mesh.get_boundary_info();
 
  dof_id_type pmax_elem_id = mesh.max_elem_id();
  mesh.comm().max(pmax_elem_id);
 
  for (dof_id_type i=0; i != pmax_elem_id; ++i)
    {
      const Elem * elem = mesh.query_elem_ptr(i);
      const unsigned int my_n_nodes = elem ? elem->n_nodes() : 0;
      const unsigned int my_n_edges = elem ? elem->n_edges() : 0;
      const unsigned int my_n_sides = elem ? elem->n_sides() : 0;
      unsigned int
        n_nodes = my_n_nodes,
        n_edges = my_n_edges,
        n_sides = my_n_sides;
 
      mesh.comm().max(n_nodes);
      mesh.comm().max(n_edges);
      mesh.comm().max(n_sides);
 
      if (elem)
        {
          libmesh_assert_equal_to(my_n_nodes, n_nodes);
          libmesh_assert_equal_to(my_n_edges, n_edges);
          libmesh_assert_equal_to(my_n_sides, n_sides);
        }
 
      // Let's test all IDs on the element with one communication
      // rather than n_nodes + n_edges + n_sides communications, to
      // cut down on latency in dbg modes.
      std::vector<boundary_id_type> all_bcids;
 
      for (unsigned int n=0; n != n_nodes; ++n)
        {
          std::vector<boundary_id_type> bcids;
          if (elem)
            {
              boundary_info.boundary_ids(elem->node_ptr(n), bcids);
 
              // Ordering of boundary ids shouldn't matter
              std::sort(bcids.begin(), bcids.end());
            }
          // libmesh_assert(mesh.comm().semiverify (elem ? &bcids : nullptr));
 
          all_bcids.insert(all_bcids.end(), bcids.begin(),
                           bcids.end());
          // Separator
          all_bcids.push_back(BoundaryInfo::invalid_id);
        }
 
      for (unsigned short e=0; e != n_edges; ++e)
        {
          std::vector<boundary_id_type> bcids;
 
          if (elem)
            {
              boundary_info.edge_boundary_ids(elem, e, bcids);
 
              // Ordering of boundary ids shouldn't matter
              std::sort(bcids.begin(), bcids.end());
            }
 
          // libmesh_assert(mesh.comm().semiverify (elem ? &bcids : nullptr));
 
          all_bcids.insert(all_bcids.end(), bcids.begin(),
                           bcids.end());
          // Separator
          all_bcids.push_back(BoundaryInfo::invalid_id);
 
          if (elem)
            {
              boundary_info.raw_edge_boundary_ids(elem, e, bcids);
 
              // Ordering of boundary ids shouldn't matter
              std::sort(bcids.begin(), bcids.end());
 
              all_bcids.insert(all_bcids.end(), bcids.begin(),
                               bcids.end());
              // Separator
              all_bcids.push_back(BoundaryInfo::invalid_id);
            }
 
          // libmesh_assert(mesh.comm().semiverify (elem ? &bcids : nullptr));
        }
 
      for (unsigned short s=0; s != n_sides; ++s)
        {
          std::vector<boundary_id_type> bcids;
 
          if (elem)
            {
              boundary_info.boundary_ids(elem, s, bcids);
 
              // Ordering of boundary ids shouldn't matter
              std::sort(bcids.begin(), bcids.end());
 
              all_bcids.insert(all_bcids.end(), bcids.begin(),
                               bcids.end());
              // Separator
              all_bcids.push_back(BoundaryInfo::invalid_id);
            }
 
          // libmesh_assert(mesh.comm().semiverify (elem ? &bcids : nullptr));
 
          if (elem)
            {
              boundary_info.raw_boundary_ids(elem, s, bcids);
 
              // Ordering of boundary ids shouldn't matter
              std::sort(bcids.begin(), bcids.end());
 
              all_bcids.insert(all_bcids.end(), bcids.begin(),
                               bcids.end());
              // Separator
              all_bcids.push_back(BoundaryInfo::invalid_id);
            }
 
          // libmesh_assert(mesh.comm().semiverify (elem ? &bcids : nullptr));
        }
 
      for (unsigned short sf=0; sf != 2; ++sf)
        {
          std::vector<boundary_id_type> bcids;
 
          if (elem)
            {
              boundary_info.shellface_boundary_ids(elem, sf, bcids);
 
              // Ordering of boundary ids shouldn't matter
              std::sort(bcids.begin(), bcids.end());
 
              all_bcids.insert(all_bcids.end(), bcids.begin(),
                               bcids.end());
              // Separator
              all_bcids.push_back(BoundaryInfo::invalid_id);
            }
 
          // libmesh_assert(mesh.comm().semiverify (elem ? &bcids : nullptr));
 
          if (elem)
            {
              boundary_info.raw_shellface_boundary_ids(elem, sf, bcids);
 
              // Ordering of boundary ids shouldn't matter
              std::sort(bcids.begin(), bcids.end());
 
              all_bcids.insert(all_bcids.end(), bcids.begin(),
                               bcids.end());
              // Separator
              all_bcids.push_back(BoundaryInfo::invalid_id);
            }
 
          // libmesh_assert(mesh.comm().semiverify (elem ? &bcids : nullptr));
        }
 
      libmesh_assert(mesh.comm().semiverify
                     (elem ? &all_bcids : nullptr));
    }
}

References libMesh::BoundaryInfo::boundary_ids(), libMesh::ParallelObject::comm(), libMesh::BoundaryInfo::edge_boundary_ids(), libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::invalid_id, libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::max_elem_id(), mesh, libMesh::Elem::n_edges(), libMesh::Elem::n_nodes(), n_nodes, libMesh::ParallelObject::n_processors(), libMesh::Elem::n_sides(), libMesh::Elem::node_ptr(), libMesh::MeshBase::query_elem_ptr(), libMesh::BoundaryInfo::raw_boundary_ids(), libMesh::BoundaryInfo::raw_edge_boundary_ids(), libMesh::BoundaryInfo::raw_shellface_boundary_ids(), libMesh::Parallel::Communicator::semiverify(), and libMesh::BoundaryInfo::shellface_boundary_ids().

Referenced by libMesh::MeshBase::complete_preparation(), and libMesh::DofMap::create_dof_constraints().

libmesh_assert_valid_constraint_rows()

void libMesh::MeshTools::libmesh_assert_valid_constraint_rows

(

const MeshBase &

mesh

)

A function for verifying that all mesh constraint rows express relations between nodes and elements that are semilocal (local or ghosted) to the current processor's portion of the mesh.

Definition at line 1745 of file mesh_tools.C.

{
  libmesh_parallel_only(mesh.comm());
 
  const auto & constraint_rows = mesh.get_constraint_rows();
 
  bool have_constraint_rows = !constraint_rows.empty();
  mesh.comm().max(have_constraint_rows);
  if (!have_constraint_rows)
    return;
 
  for (auto & row : constraint_rows)
    {
      const Node * node = row.first;
      libmesh_assert(node == mesh.node_ptr(node->id()));
 
      for (auto & pr : row.second)
        {
          const Elem * spline_elem = pr.first.first;
          libmesh_assert(spline_elem == mesh.elem_ptr(spline_elem->id()));
        }
    }
 
  dof_id_type pmax_node_id = mesh.max_node_id();
  mesh.comm().max(pmax_node_id);
 
  for (dof_id_type i=0; i != pmax_node_id; ++i)
    {
      const Node * node = mesh.query_node_ptr(i);
 
      bool have_constraint = constraint_rows.count(node);
 
      const std::size_t my_n_constraints = have_constraint ?
        libmesh_map_find(constraint_rows, node).size() : std::size_t(-1);
      const std::size_t * n_constraints = node ?
        &my_n_constraints : nullptr;
 
      libmesh_assert(mesh.comm().semiverify(n_constraints));
    }
}

References libMesh::ParallelObject::comm(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::get_constraint_rows(), libMesh::DofObject::id(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::max_node_id(), mesh, libMesh::MeshBase::node_ptr(), libMesh::MeshBase::query_node_ptr(), and libMesh::Parallel::Communicator::semiverify().

Referenced by libMesh::MeshBase::complete_preparation(), and libMesh::MeshCommunication::delete_remote_elements().

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.

Definition at line 1958 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_valid_dof_ids()", "MeshTools");
 
  if (mesh.n_processors() == 1)
    return;
 
  libmesh_parallel_only(mesh.comm());
 
  dof_id_type pmax_elem_id = mesh.max_elem_id();
  mesh.comm().max(pmax_elem_id);
 
  for (dof_id_type i=0; i != pmax_elem_id; ++i)
    assert_semiverify_dofobj(mesh.comm(),
                             mesh.query_elem_ptr(i),
                             sysnum);
 
  dof_id_type pmax_node_id = mesh.max_node_id();
  mesh.comm().max(pmax_node_id);
 
  for (dof_id_type i=0; i != pmax_node_id; ++i)
    assert_semiverify_dofobj(mesh.comm(),
                             mesh.query_node_ptr(i),
                             sysnum);
}

References libMesh::ParallelObject::comm(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::max_elem_id(), libMesh::MeshBase::max_node_id(), mesh, libMesh::ParallelObject::n_processors(), libMesh::MeshBase::query_elem_ptr(), and libMesh::MeshBase::query_node_ptr().

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)

Definition at line 1398 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_valid_elem_ids()", "MeshTools");
 
  processor_id_type lastprocid = 0;
  dof_id_type lastelemid = 0;
 
  for (const auto & elem : mesh.active_element_ptr_range())
    {
      libmesh_assert (elem);
      processor_id_type elemprocid = elem->processor_id();
      dof_id_type elemid = elem->id();
 
      libmesh_assert_greater_equal (elemid, lastelemid);
      libmesh_assert_greater_equal (elemprocid, lastprocid);
 
      lastelemid = elemid;
      lastprocid = elemprocid;
    }
}

References libMesh::libmesh_assert(), and mesh.

Referenced by libMesh::DistributedMesh::renumber_nodes_and_elements().

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.

Definition at line 2320 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_valid_neighbors()", "MeshTools");
 
  for (const auto & elem : mesh.element_ptr_range())
    {
      libmesh_assert (elem);
      elem->libmesh_assert_valid_neighbors();
    }
 
  if (mesh.n_processors() == 1)
    return;
 
  libmesh_parallel_only(mesh.comm());
 
  dof_id_type pmax_elem_id = mesh.max_elem_id();
  mesh.comm().max(pmax_elem_id);
 
  for (dof_id_type i=0; i != pmax_elem_id; ++i)
    {
      const Elem * elem = mesh.query_elem_ptr(i);
 
      const unsigned int my_n_neigh = elem ? elem->n_neighbors() : 0;
      unsigned int n_neigh = my_n_neigh;
      mesh.comm().max(n_neigh);
      if (elem)
        libmesh_assert_equal_to (my_n_neigh, n_neigh);
 
      for (unsigned int n = 0; n != n_neigh; ++n)
        {
          dof_id_type my_neighbor = DofObject::invalid_id;
          dof_id_type * p_my_neighbor = nullptr;
 
          // If we have a non-remote_elem neighbor link, then we can
          // verify it.
          if (elem && elem->neighbor_ptr(n) != remote_elem)
            {
              p_my_neighbor = &my_neighbor;
              if (elem->neighbor_ptr(n))
                my_neighbor = elem->neighbor_ptr(n)->id();
 
              // But wait - if we haven't set remote_elem links yet then
              // some nullptr links on ghost elements might be
              // future-remote_elem links, so we can't verify those.
              if (!assert_valid_remote_elems &&
                  !elem->neighbor_ptr(n) &&
                  elem->processor_id() != mesh.processor_id())
                p_my_neighbor = nullptr;
            }
          libmesh_assert(mesh.comm().semiverify(p_my_neighbor));
        }
    }
}

References libMesh::ParallelObject::comm(), libMesh::DofObject::id(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::max_elem_id(), mesh, libMesh::Elem::n_neighbors(), libMesh::ParallelObject::n_processors(), libMesh::Elem::neighbor_ptr(), libMesh::DofObject::processor_id(), libMesh::ParallelObject::processor_id(), libMesh::MeshBase::query_elem_ptr(), libMesh::remote_elem, and libMesh::Parallel::Communicator::semiverify().

Referenced by libMesh::DistributedMesh::allgather(), libMesh::DistributedMesh::delete_remote_elements(), libMesh::UnstructuredMesh::find_neighbors(), and libMesh::UnstructuredMesh::stitching_helper().

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.

Definition at line 1342 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_valid_node_pointers()", "MeshTools");
 
  // Here we specifically do not want "auto &" because we need to
  // reseat the (temporary) pointer variable in the loop below,
  // without modifying the original.
  for (const Elem * elem : mesh.element_ptr_range())
    {
      libmesh_assert (elem);
      while (elem)
        {
          elem->libmesh_assert_valid_node_pointers();
          for (auto n : elem->neighbor_ptr_range())
            if (n && n != remote_elem)
              n->libmesh_assert_valid_node_pointers();
 
          libmesh_assert_not_equal_to (elem->parent(), remote_elem);
          elem = elem->parent();
        }
    }
}

References libMesh::libmesh_assert(), mesh, and libMesh::remote_elem.

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 599 of file mesh_tools.h.

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

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

Definition at line 2273 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_valid_refinement_flags()", "MeshTools");
 
  libmesh_parallel_only(mesh.comm());
  if (mesh.n_processors() == 1)
    return;
 
  dof_id_type pmax_elem_id = mesh.max_elem_id();
  mesh.comm().max(pmax_elem_id);
 
  std::vector<unsigned char> my_elem_h_state(pmax_elem_id, 255);
  std::vector<unsigned char> my_elem_p_state(pmax_elem_id, 255);
 
  for (const auto & elem : mesh.element_ptr_range())
    {
      libmesh_assert (elem);
      dof_id_type elemid = elem->id();
 
      my_elem_h_state[elemid] =
        static_cast<unsigned char>(elem->refinement_flag());
 
      my_elem_p_state[elemid] =
        static_cast<unsigned char>(elem->p_refinement_flag());
    }
  std::vector<unsigned char> min_elem_h_state(my_elem_h_state);
  mesh.comm().min(min_elem_h_state);
 
  std::vector<unsigned char> min_elem_p_state(my_elem_p_state);
  mesh.comm().min(min_elem_p_state);
 
  for (dof_id_type i=0; i!= pmax_elem_id; ++i)
    {
      libmesh_assert(my_elem_h_state[i] == 255 ||
                     my_elem_h_state[i] == min_elem_h_state[i]);
      libmesh_assert(my_elem_p_state[i] == 255 ||
                     my_elem_p_state[i] == min_elem_p_state[i]);
    }
}

References libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::max_elem_id(), mesh, libMesh::Parallel::Communicator::min(), and libMesh::ParallelObject::n_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.

Definition at line 1627 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_valid_refinement_tree()", "MeshTools");
 
  for (const auto & elem : mesh.element_ptr_range())
    {
      libmesh_assert(elem);
      if (elem->has_children())
        for (auto & child : elem->child_ref_range())
          if (&child != remote_elem)
            libmesh_assert_equal_to (child.parent(), elem);
      if (elem->active())
        {
          libmesh_assert(!elem->ancestor());
          libmesh_assert(!elem->subactive());
        }
      else if (elem->ancestor())
        {
          libmesh_assert(!elem->subactive());
        }
      else
        libmesh_assert(elem->subactive());
 
      if (elem->p_refinement_flag() == Elem::JUST_REFINED)
        libmesh_assert_greater(elem->p_level(), 0);
    }
}

References libMesh::Elem::JUST_REFINED, libMesh::libmesh_assert(), mesh, and libMesh::remote_elem.

Referenced by libMesh::DistributedMesh::delete_remote_elements(), and libMesh::MeshCommunication::delete_remote_elements().

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.

Definition at line 1367 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_valid_remote_elems()", "MeshTools");
 
  for (const auto & elem : as_range(mesh.local_elements_begin(),
                                    mesh.local_elements_end()))
    {
      libmesh_assert (elem);
 
      // We currently don't allow active_local_elements to have
      // remote_elem neighbors
      if (elem->active())
        for (auto n : elem->neighbor_ptr_range())
          libmesh_assert_not_equal_to (n, remote_elem);
 
#ifdef LIBMESH_ENABLE_AMR
      const Elem * parent = elem->parent();
      if (parent)
        libmesh_assert_not_equal_to (parent, remote_elem);
 
      // We can only be strict about active elements' subactive
      // children
      if (elem->active() && elem->has_children())
        for (auto & child : elem->child_ref_range())
          libmesh_assert_not_equal_to (&child, remote_elem);
#endif
    }
}

References libMesh::as_range(), libMesh::libmesh_assert(), mesh, libMesh::Elem::parent(), and libMesh::remote_elem.

Referenced by libMesh::Partitioner::partition().

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.

Definition at line 1986 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_valid_unique_ids()", "MeshTools");
 
  libmesh_parallel_only(mesh.comm());
 
  // Storage for semi-local DofObject ids.
  std::unordered_set<unique_id_type> semilocal_unique_ids;
 
  auto gather_elem_ids = [&]()
  {
    for (auto const & elem : mesh.active_element_ptr_range())
      {
        auto [it, inserted] = semilocal_unique_ids.insert(elem->unique_id());
        libmesh_assert(inserted);
        libmesh_ignore(it);
      }
  };
 
  auto gather_node_ids = [&]()
  {
    for (auto const & node : mesh.node_ptr_range())
      {
        auto [it, inserted] = semilocal_unique_ids.insert(node->unique_id());
        libmesh_assert(inserted);
        libmesh_ignore(it);
      }
  };
 
  auto verify_elems = [&]()
  {
    dof_id_type pmax_elem_id = mesh.max_elem_id();
    mesh.comm().max(pmax_elem_id);
 
    for (auto i : make_range(pmax_elem_id))
      {
        const Elem * elem = mesh.query_elem_ptr(i);
        assert_dofobj_unique_id(mesh.comm(), elem, semilocal_unique_ids);
      }
  };
 
  auto verify_nodes = [&]()
  {
    dof_id_type pmax_node_id = mesh.max_node_id();
    mesh.comm().max(pmax_node_id);
 
    for (auto i : make_range(pmax_node_id))
      {
        const Node * node = mesh.query_node_ptr(i);
        assert_dofobj_unique_id(mesh.comm(), node, semilocal_unique_ids);
      }
  };
 
  if (!mesh.allow_node_and_elem_unique_id_overlap())
  {
    // First collect all the unique_ids we can see and make sure there's
    // no duplicates
    gather_elem_ids();
    gather_node_ids();
 
    // Then make sure elements/nodes are all in sync and remote
    // elements don't duplicate semilocal
    verify_elems();
    verify_nodes();
  }
  else
  {
    // If the mesh allows Node and Elem unique_ids to overlap, then we only
    // check for validity and uniqueness of an Elem (resp. Node) unique id
    // within the set of Elem (resp. Node) unique_ids.
    gather_elem_ids();
    verify_elems();
 
    // Clear id list before checking Nodes
    semilocal_unique_ids.clear();
 
    // Finally, check Nodes
    gather_node_ids();
    verify_nodes();
  }
}

References libMesh::MeshBase::allow_node_and_elem_unique_id_overlap(), libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), libMesh::libmesh_ignore(), libMesh::make_range(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::max_elem_id(), libMesh::MeshBase::max_node_id(), mesh, libMesh::MeshBase::query_elem_ptr(), and libMesh::MeshBase::query_node_ptr().

Referenced by libMesh::MeshBase::complete_preparation(), and libMesh::SimplexRefiner::refine_via_edges().

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.

Definition at line 744 of file mesh_tools.C.

{
  return static_cast<dof_id_type>(std::distance(mesh.active_type_elements_begin(type),
                                                mesh.active_type_elements_end  (type)));
}

References mesh.

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.

Definition at line 796 of file mesh_tools.C.

{
  libmesh_parallel_only(mesh.comm());
 
  unsigned int nl = n_active_local_levels(mesh);
 
  for (const auto & elem : as_range(mesh.unpartitioned_elements_begin(),
                                    mesh.unpartitioned_elements_end()))
    if (elem->active())
      nl = std::max(elem->level() + 1, nl);
 
  mesh.comm().max(nl);
  return nl;
}

References libMesh::as_range(), libMesh::ParallelObject::comm(), libMesh::Parallel::Communicator::max(), mesh, and n_active_local_levels().

Referenced by libMesh::XdrIO::write_serialized_connectivity().

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.

Definition at line 767 of file mesh_tools.C.

{
  struct LevelCounter {
    unsigned int nl;
 
    LevelCounter () : nl(0) {}
 
    LevelCounter (LevelCounter &, Threads::split) :
      nl(0) {}
 
    void operator()(const ConstElemRange & range) {
      for (const Elem * elem : range)
        nl = std::max(elem->level() + 1, nl);
    }
 
    void join(const LevelCounter & other) {
      nl = std::max(nl, other.nl);
    }
  };
 
  LevelCounter counter;
 
  Threads::parallel_reduce(mesh.active_local_element_stored_range(), counter);
 
  return counter.nl;
}

References libMesh::MeshBase::active_local_element_stored_range(), mesh, and libMesh::Threads::parallel_reduce().

Referenced by n_active_levels().

n_connected_components()

dof_id_type libMesh::MeshTools::n_connected_components	(	const MeshBase &	mesh,
		Real	constraint_tol = 0
	)

Returns

The number of topologically connected components in the mesh, where a local connection is defined as two nodes connected to the same element, two elements connected to the same node, and/or two nodes connected by a constraint row; thus a connection can be made at a single vertex, not just at an element side.

To count sufficiently weak constraint row coefficients as a lack-of-connection, set a constraint_tol greater than 0.

Definition at line 864 of file mesh_tools.C.

{
  LOG_SCOPE("n_connected_components()", "MeshTools");
 
  // Yes, I'm being lazy.  This is for mesh analysis before a
  // simulation, not anything going in any loops.
  if (!mesh.is_serial_on_zero())
    libmesh_not_implemented();
 
  dof_id_type n_components = 0;
 
  if (mesh.processor_id())
  {
    mesh.comm().broadcast(n_components);
    return n_components;
  }
 
  // All nodes in a set here are connected (at least indirectly) to
  // all other nodes in the same set, but have not yet been discovered
  // to be connected to nodes in other sets.
  //
  // Using an unordered_set of ids rather than a set of pointers seems
  // to be roughly 150% faster?
  // typedef const Node * node_entry_type
  typedef dof_id_type node_entry_type;
  std::vector<std::unordered_set<node_entry_type>> components;
 
  // With a typical mesh with few components and somewhat-contiguous
  // ordering, vector performance should be fine.  With a mesh with
  // many components or completely scrambled ordering, performance
  // can be a disaster.
  auto find_component = [&components](node_entry_type n) {
    for (auto & c: components)
      if (c.find(n) != c.end())
        return &c;
 
    return (std::unordered_set<node_entry_type> *)(nullptr);
  };
 
  auto add_to_component =
    [&find_component]
    (std::unordered_set<node_entry_type> & component, node_entry_type n) {
    // We may already be in the desired component
    if (component.find(n) != component.end())
      return;
 
    auto current_component = find_component(n);
 
    // Didn't we *just* check this?
    libmesh_assert (&component != current_component);
 
    // If we're unknown, we should be in the desired component
    if (!current_component)
      component.insert(n);
 
    // If we think we're in another component, it should actually be
    // part of the desired component
    else
      {
        // Merge the component likely to be smaller into the one
        // likely to be larger - this is orders of magnitude faster
        // than the other way around!
        current_component->merge(component);
        current_component->swap(component);
        libmesh_assert(current_component->empty());
      }
  };
 
  auto & constraint_rows = mesh.get_constraint_rows();
 
  for (const auto & elem : mesh.element_ptr_range())
    {
      // const node_entry_type first_node = elem->node_ptr(0);
      const node_entry_type first_node = elem->node_id(0);
 
      auto component = find_component(first_node);
 
      // If we didn't find one, make a new one, reusing an existing
      // slot if possible or growing our vector if necessary
      if (!component)
        for (auto & c: components)
          if (c.empty())
            component = &c;
 
      if (!component)
        component = &components.emplace_back();
 
      for (const Node & node : elem->node_ref_range())
        {
          // const node_entry_type n = &node;
          const node_entry_type n = node.id();
          add_to_component(*component, n);
 
          auto it = constraint_rows.find(&node);
          if (it == constraint_rows.end())
            continue;
 
          for (const auto & [pr, val] : it->second)
            {
              // Ignore too-trivial constraint coefficients if
              // we get a non-default-0 constraint_tol
              if (std::abs(val) < constraint_tol)
                continue;
 
              const Elem * spline_elem = pr.first;
              libmesh_assert(spline_elem == mesh.elem_ptr(spline_elem->id()));
 
              const Node * spline_node =
                spline_elem->node_ptr(pr.second);
 
              // add_to_component(*component, spline_node);
              add_to_component(*component, spline_node->id());
            }
        }
    }
 
  for (auto & component : components)
    if (!component.empty())
      ++n_components;
 
  // We calculated this on proc 0; now let everyone else know too
  mesh.comm().broadcast(n_components);
 
  return n_components;
}

References libMesh::Parallel::Communicator::broadcast(), libMesh::ParallelObject::comm(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::get_constraint_rows(), libMesh::DofObject::id(), libMesh::MeshBase::is_serial_on_zero(), libMesh::libmesh_assert(), mesh, libMesh::Elem::node_ptr(), and libMesh::ParallelObject::processor_id().

Referenced by main(), and ConnectedComponentsTest::testEdge().

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

Definition at line 1004 of file mesh_tools.C.

{
  return cast_int<dof_id_type>(std::distance(begin, end));
}

Referenced by libMesh::MeshTools::Subdivision::add_boundary_ghosts(), correct_node_proc_ids(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::Partitioner::set_node_processor_ids(), libMesh::Partitioner::set_parent_processor_ids(), and libMesh::XdrIO::write_serialized_connectivity().

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.

Definition at line 735 of file mesh_tools.C.

{
  return static_cast<dof_id_type>(std::distance(mesh.type_elements_begin(type),
                                                mesh.type_elements_end  (type)));
}

References mesh.

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.

Definition at line 826 of file mesh_tools.C.

{
  libmesh_parallel_only(mesh.comm());
 
  unsigned int nl = n_local_levels(mesh);
 
  for (const auto & elem : as_range(mesh.unpartitioned_elements_begin(),
                                    mesh.unpartitioned_elements_end()))
    nl = std::max(elem->level() + 1, nl);
 
  mesh.comm().max(nl);
 
  // n_levels() is only valid and should only be called in cases where
  // the mesh is validly distributed (or serialized).  Let's run an
  // expensive test in debug mode to make sure this is such a case.
#ifdef DEBUG
  const unsigned int paranoid_nl = paranoid_n_levels(mesh);
  libmesh_assert_equal_to(nl, paranoid_nl);
#endif
  return nl;
}

References libMesh::as_range(), libMesh::ParallelObject::comm(), libMesh::Parallel::Communicator::max(), mesh, n_local_levels(), and paranoid_n_levels().

Referenced by libMesh::MeshCommunication::delete_remote_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::MeshTools::Modification::orient_elements(), libMesh::MeshTools::Modification::permute_elements(), libMesh::Partitioner::set_node_processor_ids(), and libMesh::MeshTools::Modification::smooth().

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.

Definition at line 813 of file mesh_tools.C.

{
  unsigned int nl = 0;
 
  for (const auto & elem : as_range(mesh.local_elements_begin(),
                                    mesh.local_elements_end()))
    nl = std::max(elem->level() + 1, nl);
 
  return nl;
}

References libMesh::as_range(), and mesh.

Referenced by n_levels().

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

Definition at line 1012 of file mesh_tools.C.

{
  return cast_int<dof_id_type>(std::distance(begin, end));
}

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.

Definition at line 751 of file mesh_tools.C.

{
  dof_id_type cnt = 0;
 
  // iterate over the elements of the specified type
  for (const auto & elem : as_range(mesh.type_elements_begin(type),
                                    mesh.type_elements_end(type)))
    if ((elem->level() == level) && !elem->subactive())
      cnt++;
 
  return cnt;
}

References libMesh::as_range(), and mesh.

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.

Definition at line 1049 of file mesh_tools.C.

{
  libmesh_parallel_only(mesh.comm());
 
  unsigned int max_p_level = 0;
 
  // first my local elements
  for (const auto & elem : as_range(mesh.local_elements_begin(),
                                    mesh.local_elements_end()))
    max_p_level = std::max(elem->p_level(), max_p_level);
 
  // then any unpartitioned objects
  for (const auto & elem : as_range(mesh.unpartitioned_elements_begin(),
                                    mesh.unpartitioned_elements_end()))
    max_p_level = std::max(elem->p_level(), max_p_level);
 
  mesh.comm().max(max_p_level);
  return max_p_level + 1;
}

References libMesh::as_range(), libMesh::ParallelObject::comm(), libMesh::Parallel::Communicator::max(), and mesh.

Referenced by libMesh::XdrIO::write().

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.

Definition at line 850 of file mesh_tools.C.

{
  libmesh_parallel_only(mesh.comm());
 
  unsigned int nl = 0;
  for (const auto & elem : mesh.element_ptr_range())
    nl = std::max(elem->level() + 1, nl);
 
  mesh.comm().max(nl);
  return nl;
}

References libMesh::ParallelObject::comm(), libMesh::Parallel::Communicator::max(), and mesh.

Referenced by n_levels().

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.

Definition at line 670 of file mesh_tools.C.

{
  libMesh::BoundingBox bbox =
    create_processor_bounding_box(mesh, pid);
 
  const Real  diag = (bbox.second - bbox.first).norm();
  const Point cent = (bbox.second + bbox.first)/2;
 
  return Sphere (cent, .5*diag);
}

References create_processor_bounding_box(), mesh, and libMesh::Real.

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.

Definition at line 709 of file mesh_tools.C.

{
  libMesh::BoundingBox bbox =
    create_subdomain_bounding_box(mesh, sid);
 
  const Real  diag = (bbox.second - bbox.first).norm();
  const Point cent = (bbox.second + bbox.first)/2;
 
  return Sphere (cent, .5*diag);
}

References create_subdomain_bounding_box(), mesh, and libMesh::Real.

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.

Definition at line 421 of file mesh_tools.C.

{
  if (!mesh.is_serial())
    {
      libmesh_parallel_only(mesh.comm());
      dof_id_type weight = MeshTools::weight (mesh, mesh.processor_id());
      mesh.comm().sum(weight);
      dof_id_type unpartitioned_weight =
        MeshTools::weight (mesh, DofObject::invalid_processor_id);
      return weight + unpartitioned_weight;
    }
 
  SumElemWeight sew;
 
  Threads::parallel_reduce (ConstElemRange (mesh.elements_begin(),
                                            mesh.elements_end()),
                            sew);
  return sew.weight();
 
}

References libMesh::ParallelObject::comm(), libMesh::DofObject::invalid_processor_id, libMesh::MeshBase::is_serial(), mesh, libMesh::Threads::parallel_reduce(), libMesh::ParallelObject::processor_id(), libMesh::Parallel::Communicator::sum(), and weight().

valid_is_prepared()

bool libMesh::MeshTools::valid_is_prepared

(

const MeshBase &

mesh

)

A function for testing whether a mesh's cached is_prepared() setting is not a false positive.

If the mesh is marked as not prepared, or if preparing the already-partitioned mesh (without any repartitioning or renumbering) does not change it, then we return true. If the mesh believes it is prepared but prepare_for_use() would change it, we return false.

Definition at line 1256 of file mesh_tools.C.

{
  LOG_SCOPE("valid_is_prepared()", "MeshTools");
 
  if (!mesh.is_prepared())
    return true;
 
  std::unique_ptr<MeshBase> mesh_clone = mesh.clone();
 
  // Try preparing (without allowing repartitioning or renumbering, to
  // avoid false assertion failures)
  bool old_allow_renumbering = mesh_clone->allow_renumbering();
  mesh_clone->allow_renumbering(false);
 
  bool old_skip_partitioning = mesh_clone->skip_partitioning();
  mesh_clone->skip_partitioning(true);
 
  bool old_allow_remote_element_removal = mesh_clone->allow_remote_element_removal();
  mesh_clone->allow_remote_element_removal(false);
 
  // Call prepare_for_use() on the clone
  mesh_clone->prepare_for_use();
 
  // Restore original flag values
  mesh_clone->allow_renumbering(old_allow_renumbering);
  mesh_clone->skip_partitioning(old_skip_partitioning);
  mesh_clone->allow_remote_element_removal(old_allow_remote_element_removal);
 
  // Check whether the original and clone compare equal
  return (mesh == *mesh_clone);
}

References libMesh::MeshBase::clone(), libMesh::MeshBase::is_prepared(), and mesh.

Referenced by ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), ConstraintOperatorTest::testCoreform(), MeshBaseTest::testMeshBaseVerifyHasCachedElemData(), MeshBaseTest::testMeshBaseVerifyHasNeighborPtrs(), MeshBaseTest::testMeshBaseVerifyIsPrepared(), MeshBaseTest::testMeshBaseVerifyRemovalPreparation(), and libMesh::MeshTetInterface::volume_to_surface_mesh().

volume()

Real libMesh::MeshTools::volume	(	const MeshBase &	mesh,
		unsigned int	dim = libMesh::invalid_uint
	)

Find the total volume of a mesh (interpreting that as area for dim = 2, or total arc length for dim = 1, or number of NodeElem in the mesh for dim = 0).

By default the dimension chosen will be the mesh_dimension(), which if not manually overridden will be the largest dimension of elements in the mesh.

Definition at line 1020 of file mesh_tools.C.

{
  libmesh_parallel_only(mesh.comm());
 
  if (dim == libMesh::invalid_uint)
    dim = mesh.mesh_dimension();
 
  Real vol = 0;
 
  // first my local elements
  for (const auto & elem : as_range(mesh.local_elements_begin(),
                                    mesh.local_elements_end()))
    if (elem->dim() == dim)
      vol += elem->volume();
 
  // then count any unpartitioned objects, once
  if (mesh.processor_id() == 0)
    for (const auto & elem : as_range(mesh.unpartitioned_elements_begin(),
                                      mesh.unpartitioned_elements_end()))
      if (elem->dim() == dim)
        vol += elem->volume();
 
  mesh.comm().sum(vol);
  return vol;
}

References libMesh::as_range(), libMesh::ParallelObject::comm(), dim, libMesh::invalid_uint, mesh, libMesh::MeshBase::mesh_dimension(), libMesh::ParallelObject::processor_id(), libMesh::Real, and libMesh::Parallel::Communicator::sum().

Referenced by AllRBBTest::test_box(), AllRBBTest::test_circle(), AllRBBTest::test_cylinder(), AllRBBTest::test_disk(), AllTriTest::test_helper(), AllTriTest::test_helper_c0polyhedron(), AllRBBTest::test_sphere(), AllTriTest::testAllTriC0PolygonOctagon(), MeshGenerationTest::testBuildCube(), MeshTetTest::testHole(), MeshTetTest::testNetGenQuadratic(), MeshTetTest::testNetGenTet14(), MeshTetTest::testTetInterfaceBase(), and MeshTetTest::testTetsToTets().

weight() [1/2]

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

inline

Definition at line 78 of file mesh_tools.h.

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

References mesh, and weight().

weight() [2/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.

Definition at line 444 of file mesh_tools.C.

{
  SumElemWeight sew;
 
  Threads::parallel_reduce (ConstElemRange (mesh.pid_elements_begin(pid),
                                            mesh.pid_elements_end(pid)),
                            sew);
  return sew.weight();
}

References mesh, and libMesh::Threads::parallel_reduce().

Referenced by libMesh::MeshTools::Modification::smooth(), total_weight(), and weight().