libMesh::MeshTools Namespace Reference

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

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

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

Functions
dof_id_type	total_weight (const MeshBase &mesh)
dof_id_type	weight (const MeshBase &mesh, const processor_id_type pid)
dof_id_type	weight (const MeshBase &mesh)
void	build_nodes_to_elem_map (const MeshBase &mesh, std::vector< std::vector< dof_id_type >> &nodes_to_elem_map)
	After calling this function the input vector nodes_to_elem_map will contain the node to element connectivity. More...
void	build_nodes_to_elem_map (const MeshBase &mesh, std::vector< std::vector< const Elem * >> &nodes_to_elem_map)
	The same, except element pointers are returned instead of indices. More...
void	build_nodes_to_elem_map (const MeshBase &mesh, std::unordered_map< dof_id_type, std::vector< dof_id_type >> &nodes_to_elem_map)
	After calling this function the input map nodes_to_elem_map will contain the node to element connectivity. More...
void	build_nodes_to_elem_map (const MeshBase &mesh, std::unordered_map< dof_id_type, std::vector< const Elem * >> &nodes_to_elem_map)
	The same, except element pointers are returned instead of indices. More...
void	find_boundary_nodes (const MeshBase &mesh, std::vector< bool > &on_boundary)
std::unordered_set< dof_id_type >	find_boundary_nodes (const MeshBase &mesh)
	Returns a std::set containing Node IDs for all of the boundary nodes. More...
std::unordered_set< dof_id_type >	find_block_boundary_nodes (const MeshBase &mesh)
	Returns a std::set containing Node IDs for all of the block boundary nodes. More...
BoundingBox	bounding_box (const MeshBase &mesh)
libMesh::BoundingBox	create_bounding_box (const MeshBase &mesh)
	The same functionality as the deprecated MeshTools::bounding_box(). More...
Sphere	bounding_sphere (const MeshBase &mesh)
libMesh::BoundingBox	create_nodal_bounding_box (const MeshBase &mesh)
libMesh::BoundingBox	create_local_bounding_box (const MeshBase &mesh)
BoundingBox	processor_bounding_box (const MeshBase &mesh, const processor_id_type pid)
libMesh::BoundingBox	create_processor_bounding_box (const MeshBase &mesh, const processor_id_type pid)
	The same functionality as the deprecated MeshTools::processor_bounding_box(). More...
Sphere	processor_bounding_sphere (const MeshBase &mesh, const processor_id_type pid)
BoundingBox	subdomain_bounding_box (const MeshBase &mesh, const subdomain_id_type sid)
libMesh::BoundingBox	create_subdomain_bounding_box (const MeshBase &mesh, const subdomain_id_type sid)
	The same functionality as the deprecated MeshTools::subdomain_bounding_box(). More...
Sphere	subdomain_bounding_sphere (const MeshBase &mesh, const subdomain_id_type sid)
void	elem_types (const MeshBase &mesh, std::vector< ElemType > &et)
	Fills in a vector of all element types in the mesh. More...
dof_id_type	n_elem_of_type (const MeshBase &mesh, const ElemType type)
dof_id_type	n_active_elem_of_type (const MeshBase &mesh, const ElemType type)
dof_id_type	n_non_subactive_elem_of_type_at_level (const MeshBase &mesh, const ElemType type, const unsigned int level)
unsigned int	n_levels (const MeshBase &mesh)
unsigned int	n_local_levels (const MeshBase &mesh)
unsigned int	n_active_levels (const MeshBase &mesh)
unsigned int	n_active_local_levels (const MeshBase &mesh)
unsigned int	n_p_levels (const MeshBase &mesh)
unsigned int	paranoid_n_levels (const MeshBase &mesh)
void	get_not_subactive_node_ids (const MeshBase &mesh, std::set< dof_id_type > &not_subactive_node_ids)
	Builds a set of node IDs for nodes which belong to non-subactive elements. More...
dof_id_type	n_elem (const MeshBase::const_element_iterator &begin, const MeshBase::const_element_iterator &end)
	Count up the number of elements of a specific type (as defined by an iterator range). More...
dof_id_type	n_nodes (const MeshBase::const_node_iterator &begin, const MeshBase::const_node_iterator &end)
	Count up the number of nodes of a specific type (as defined by an iterator range). More...
unsigned int	max_level (const MeshBase &mesh)
	Find the maximum h-refinement level in a mesh. More...
void	find_nodal_neighbors (const MeshBase &mesh, const Node &n, const std::vector< std::vector< const Elem * >> &nodes_to_elem_map, std::vector< const Node * > &neighbors)
	Given a mesh and a node in the mesh, the vector will be filled with every node directly attached to the given one. More...
void	find_nodal_neighbors (const MeshBase &mesh, const Node &n, const std::unordered_map< dof_id_type, std::vector< const Elem * >> &nodes_to_elem_map, std::vector< const Node * > &neighbors)
	Given a mesh and a node in the mesh, the vector will be filled with every node directly attached to the given one. More...
void	find_hanging_nodes_and_parents (const MeshBase &mesh, std::map< dof_id_type, std::vector< dof_id_type >> &hanging_nodes)
	Given a mesh hanging_nodes will be filled with an associative array keyed off the global id of all the hanging nodes in the mesh. More...
void	correct_node_proc_ids (MeshBase &)
	Changes the processor ids on each node so be the same as the id of the lowest element touching that node. More...
void	libmesh_assert_no_links_to_elem (const MeshBase &mesh, const Elem *bad_elem)
	A function for verifying that an element has been cut off from the rest of the mesh. More...
void	libmesh_assert_equal_n_systems (const MeshBase &mesh)
	A function for testing that all DofObjects within a mesh have the same n_systems count. More...
void	libmesh_assert_old_dof_objects (const MeshBase &mesh)
	A function for testing that all non-recently-created DofObjects within a mesh have old_dof_object data. More...
void	libmesh_assert_valid_node_pointers (const MeshBase &mesh)
	A function for walking across the mesh to try and ferret out invalidated or misassigned pointers. More...
void	libmesh_assert_valid_remote_elems (const MeshBase &mesh)
	A function for verifying that active local elements' neighbors are never remote elements. More...
void	libmesh_assert_valid_elem_ids (const MeshBase &mesh)
	A function for verifying that ids and processor assignment of elements are correctly sorted (monotone increasing) More...
void	libmesh_assert_valid_amr_elem_ids (const MeshBase &mesh)
	A function for verifying that ids of elements are correctly sorted for AMR (parents have lower ids than children) More...
void	libmesh_assert_valid_amr_interior_parents (const MeshBase &mesh)
	A function for verifying that any interior_parent pointers on elements are consistent with AMR (parents' interior_parents are interior_parents' parents) More...
void	libmesh_assert_connected_nodes (const MeshBase &mesh)
	A function for verifying that all nodes are connected to at least one element. More...
void	libmesh_assert_valid_boundary_ids (const MeshBase &mesh)
	A function for verifying that boundary condition ids match across processors. More...
void	libmesh_assert_valid_dof_ids (const MeshBase &mesh, unsigned int sysnum=libMesh::invalid_uint)
	A function for verifying that degree of freedom indexing matches across processors. More...
void	libmesh_assert_contiguous_dof_ids (const MeshBase &mesh, unsigned int sysnum)
	A function for verifying that degree of freedom indexes are contiguous on each processors, as is required by libMesh numeric classes. More...
void	libmesh_assert_valid_unique_ids (const MeshBase &mesh)
	A function for verifying that unique ids match across processors. More...
void	libmesh_assert_consistent_distributed (const MeshBase &mesh)
	A function for verifying that distribution of dof objects is parallel consistent (every processor can see every node or element it owns) More...
void	libmesh_assert_consistent_distributed_nodes (const MeshBase &mesh)
	A function for verifying that distribution of nodes is parallel consistent (every processor can see every node it owns) even before node ids have been made consistent. More...
void	libmesh_assert_parallel_consistent_new_node_procids (const MeshBase &mesh)
	A function for verifying that processor assignment is parallel consistent (every processor agrees on the processor id of each node it can see) even on nodes which have not yet recieved consistent DofObject::id(), using element topology to identify matching nodes. More...
template<typename DofObjectSubclass >
void	libmesh_assert_parallel_consistent_procids (const MeshBase &mesh)
	A function for verifying that processor assignment is parallel consistent (every processor agrees on the processor id of each dof object it can see) More...
template<typename DofObjectSubclass >
void	libmesh_assert_topology_consistent_procids (const MeshBase &mesh)
	A function for verifying that processor assignment is topologically consistent on nodes (each node part of an active element on its processor) or elements (each parent has the processor id of one of its children). More...
template<typename DofObjectSubclass >
void	libmesh_assert_valid_procids (const MeshBase &mesh)
	A function for verifying that processor assignment is both parallel and topologically consistent. More...
void	libmesh_assert_canonical_node_procids (const MeshBase &mesh)
	A function for verifying that processor assignment of nodes matches the heuristic specified in Node::choose_processor_id() More...
void	libmesh_assert_valid_refinement_flags (const MeshBase &mesh)
	A function for verifying that refinement flags on elements are consistent between processors. More...
void	libmesh_assert_valid_refinement_tree (const MeshBase &mesh)
	A function for verifying that elements on this processor have valid descendants and consistent active flags. More...
void	libmesh_assert_valid_neighbors (const MeshBase &mesh, bool assert_valid_remote_elems=true)
	A function for verifying that neighbor connectivity is correct (each element is a neighbor of or descendant of a neighbor of its neighbors) and consistent (each neighbor link goes to either the same neighbor or to a RemoteElem on each processor) More...
template<>
void	libmesh_assert_topology_consistent_procids< Elem > (const MeshBase &mesh)
template<>
void	libmesh_assert_parallel_consistent_procids< Elem > (const MeshBase &mesh)
template<>
void	libmesh_assert_topology_consistent_procids< Node > (const MeshBase &mesh)
template<>
void	libmesh_assert_parallel_consistent_procids< Node > (const MeshBase &mesh)

Detailed Description

Utility functions for operations on a Mesh object.

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

Author

Benjamin S. Kirk

Date

2004

Function Documentation

bounding_box()

MeshTools::BoundingBox libMesh::MeshTools::bounding_box

(

const MeshBase &

mesh

)

Returns

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

Definition at line 376 of file mesh_tools.C.

{
  // This function is deprecated.  It simply calls
  // create_bounding_box() and converts the result to a
  // MeshTools::BoundingBox.
  libmesh_deprecated();
  return MeshTools::create_bounding_box(mesh);
}

References create_bounding_box(), and mesh.

Referenced by libMesh::TreeNode< N >::bounds_point(), libMesh::TreeNode< N >::create_bounding_box(), libMesh::TreeNode< N >::insert(), and libMesh::TreeNode< N >::set_bounding_box().

bounding_sphere()

Sphere libMesh::MeshTools::bounding_sphere

(

const MeshBase &

mesh

)

Returns

A bounding sphere for mesh instead of a bounding box.

Definition at line 441 of file mesh_tools.C.

{
  libMesh::BoundingBox bbox = MeshTools::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, std::norm(), 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 293 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 libMesh::MeshBase::element_ptr_range(), and 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 281 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 libMesh::MeshBase::element_ptr_range(), and 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 265 of file mesh_tools.C.

{
  nodes_to_elem_map.resize (mesh.n_nodes());
 
  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::element_ptr_range(), mesh, and libMesh::MeshBase::n_nodes().

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 248 of file mesh_tools.C.

{
  nodes_to_elem_map.resize (mesh.n_nodes());
 
  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::element_ptr_range(), mesh, libMesh::MeshBase::n_elem(), and libMesh::MeshBase::n_nodes().

Referenced by NodalNeighborsTest::do_test(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::GenericProjector(), libMesh::MeshTools::Subdivision::prepare_subdivision_mesh(), libMesh::VariationalMeshSmoother::readgr(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), and libMesh::Tree< N >::Tree().

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 2252 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
  MeshTools::libmesh_assert_parallel_consistent_procids<Node>(mesh);
#endif
 
  // If we have any unpartitioned elements at this
  // stage there is a problem
  libmesh_assert (MeshTools::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();
          const proc_id_map_type::iterator it = new_proc_ids.find(id);
          if (it == new_proc_ids.end())
            new_proc_ids.insert(std::make_pair(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())
    {
      const dof_id_type id = node->id();
      const proc_id_map_type::iterator it = new_proc_ids.find(id);
      if (it == new_proc_ids.end())
        continue;
      const processor_id_type pid = it->second;
      if (node->processor_id() != DofObject::invalid_processor_id)
        ids_to_push[node->processor_id()].push_back(std::make_pair(id, pid));
    }
 
  auto action_functor =
    [& mesh, & new_proc_ids]
    (processor_id_type,
     const std::vector<std::pair<dof_id_type, processor_id_type>> & data)
    {
      for (auto & p : data)
        {
          const dof_id_type id = p.first;
          const processor_id_type pid = p.second;
          const proc_id_map_type::iterator it = new_proc_ids.find(id);
          if (it == new_proc_ids.end())
            new_proc_ids.insert(std::make_pair(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())
    {
      const proc_id_map_type::iterator it = new_proc_ids.find(node->id());
      if (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
  MeshTools::libmesh_assert_valid_procids<Node>(mesh);
  //if (repartition_all_nodes)
  //  MeshTools::libmesh_assert_canonical_node_procids(mesh);
#endif
}

References libMesh::MeshBase::active_element_ptr_range(), libMesh::Node::choose_processor_id(), libMesh::ParallelObject::comm(), data, libMesh::libmesh_assert(), libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshBase::local_node_ptr_range(), mesh, n_elem(), new_proc_ids, libMesh::MeshBase::node_ptr_range(), libMesh::MeshBase::node_ref(), libMesh::MeshBase::nodes_begin(), libMesh::MeshBase::nodes_end(), libMesh::ParallelObject::processor_id(), libMesh::MeshBase::skip_noncritical_partitioning(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::MeshBase::unpartitioned_elements_begin(), and libMesh::MeshBase::unpartitioned_elements_end().

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

)

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

Returns

The non-deprecated libMesh::BoundingBox type.

Definition at line 389 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(MeshTools::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, mesh, libMesh::Threads::parallel_reduce(), libMesh::MeshBase::pid_elements_begin(), and libMesh::MeshBase::pid_elements_end().

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), bounding_box(), bounding_sphere(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::PointLocatorTree::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::MetisPartitioner::partition_range(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::TreeNode< N >::refine(), 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 454 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 libMesh::MeshBase::local_elements_begin(), libMesh::MeshBase::local_elements_end(), mesh, and libMesh::Threads::parallel_reduce().

Referenced by create_bounding_box().

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 414 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::MeshBase::local_nodes_begin(), libMesh::MeshBase::local_nodes_end(), mesh, libMesh::Threads::parallel_reduce(), libMesh::MeshBase::pid_nodes_begin(), and libMesh::MeshBase::pid_nodes_end().

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

create_processor_bounding_box()

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

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

Returns

The non-deprecated libMesh::BoundingBox type.

Definition at line 480 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(), mesh, libMesh::ParallelObject::n_processors(), libMesh::Threads::parallel_reduce(), libMesh::MeshBase::pid_elements_begin(), and libMesh::MeshBase::pid_elements_end().

Referenced by processor_bounding_box(), and processor_bounding_sphere().

create_subdomain_bounding_box()

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

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

Returns

The non-deprecated libMesh::BoundingBox type.

Definition at line 532 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::MeshBase::active_local_subdomain_elements_begin(), libMesh::MeshBase::active_local_subdomain_elements_end(), libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), mesh, and libMesh::Threads::parallel_reduce().

Referenced by subdomain_bounding_box(), and 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 570 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 libMesh::MeshBase::element_ptr_range(), and 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 elemenents from 2 or more blockse

Definition at line 354 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 libMesh::MeshBase::active_element_ptr_range(), and mesh.

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

find_boundary_nodes() [1/2]

std::unordered_set< dof_id_type > libMesh::MeshTools::find_boundary_nodes

(

const MeshBase &

mesh

)

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

Definition at line 334 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 libMesh::MeshBase::active_element_ptr_range(), and mesh.

find_boundary_nodes() [2/2]

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

    Calling this function on a 2D mesh will convert all the elements
    to triangles.  \p QUAD4s will be converted to \p TRI3s, \p QUAD8s
    and \p QUAD9s will be converted to \p TRI6s.
   ‍/

void all_tri (MeshBase & mesh);

#ifdef LIBMESH_ENABLE_DEPRECATED /** Fills the vector "on_boundary" with flags that tell whether each node is on the domain boundary (true)) or not (false).

Definition at line 306 of file mesh_tools.C.

{
  libmesh_deprecated();
 
  // Resize the vector which holds boundary nodes and fill with false.
  on_boundary.resize(mesh.max_node_id());
  std::fill(on_boundary.begin(),
            on_boundary.end(),
            false);
 
  // 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
        {
          std::unique_ptr<const Elem> side = elem->build_side_ptr(s);
 
          auto nodes_on_side = elem->nodes_on_side(s);
 
          for (auto & node_id : nodes_on_side)
            on_boundary[node_id] = true;
        }
}

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

Referenced by libMesh::MeshTools::Modification::distort(), DistortTest::perturb_and_check(), libMesh::VariationalMeshSmoother::readgr(), 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 1078 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 these for reuse
                  local_node1=0;
                  local_node2=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::MeshBase::active_local_element_ptr_range(), 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().

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

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 909 of file mesh_tools.C.

{
  // We'll refer back to the Node ID several times
  dof_id_type global_id = node.id();
 
  // We'll construct a std::set<const Node *> for more efficient
  // searching while finding the nodal neighbors, and return it to the
  // user in a std::vector.
  std::set<const Node *> neighbor_set;
 
  // List of Elems attached to this node.
  const auto & elem_vec = libmesh_map_find(nodes_to_elem_map, global_id);
 
  // Look through the elements that contain this node
  // find the local node id... then find the side that
  // node lives on in the element
  // next, look for the _other_ node on that side
  // That other node is a "nodal_neighbor"... save it
  for (const auto & elem : elem_vec)
    {
      // We only care about active elements...
      if (elem->active())
        {
          // Which local node number is global_id?
          unsigned local_node_number = elem->local_node(global_id);
 
          // Make sure it was found
          libmesh_assert_not_equal_to(local_node_number, libMesh::invalid_uint);
 
          const unsigned short n_edges = elem->n_edges();
 
          // If this element has no edges, the edge-based algorithm below doesn't make sense.
          if (!n_edges)
            {
              switch (elem->type())
                {
                case EDGE2:
                  {
                    switch (local_node_number)
                      {
                      case 0:
                        // The other node is a nodal neighbor
                        neighbor_set.insert(elem->node_ptr(1));
                        break;
 
                      case 1:
                        // The other node is a nodal neighbor
                        neighbor_set.insert(elem->node_ptr(0));
                        break;
 
                      default:
                        libmesh_error_msg("Invalid local node number: " << local_node_number << " found." << std::endl);
                      }
                    break;
                  }
 
                case EDGE3:
                  {
                    switch (local_node_number)
                      {
                        // The outside nodes have node 2 as a neighbor
                      case 0:
                      case 1:
                        neighbor_set.insert(elem->node_ptr(2));
                        break;
 
                        // The middle node has the outer nodes as neighbors
                      case 2:
                        neighbor_set.insert(elem->node_ptr(0));
                        neighbor_set.insert(elem->node_ptr(1));
                        break;
 
                      default:
                        libmesh_error_msg("Invalid local node number: " << local_node_number << " found." << std::endl);
                      }
                    break;
                  }
 
                case EDGE4:
                  {
                    switch (local_node_number)
                      {
                      case 0:
                        // The left-middle node is a nodal neighbor
                        neighbor_set.insert(elem->node_ptr(2));
                        break;
 
                      case 1:
                        // The right-middle node is a nodal neighbor
                        neighbor_set.insert(elem->node_ptr(3));
                        break;
 
                        // The left-middle node
                      case 2:
                        neighbor_set.insert(elem->node_ptr(0));
                        neighbor_set.insert(elem->node_ptr(3));
                        break;
 
                        // The right-middle node
                      case 3:
                        neighbor_set.insert(elem->node_ptr(1));
                        neighbor_set.insert(elem->node_ptr(2));
                        break;
 
                      default:
                        libmesh_error_msg("Invalid local node number: " << local_node_number << " found." << std::endl);
                      }
                    break;
                  }
 
                default:
                  libmesh_error_msg("Unrecognized ElemType: " << Utility::enum_to_string(elem->type()) << std::endl);
                }
            }
 
          // Index of the current edge
          unsigned current_edge = 0;
 
          const unsigned short n_nodes = elem->n_nodes();
 
          while (current_edge < n_edges)
            {
              // Find the edge the node is on
              bool found_edge = false;
              for (; current_edge<n_edges; ++current_edge)
                if (elem->is_node_on_edge(local_node_number, current_edge))
                  {
                    found_edge = true;
                    break;
                  }
 
              // Did we find one?
              if (found_edge)
                {
                  const Node * node_to_save = nullptr;
 
                  // Find another node in this element on this edge
                  for (unsigned other_node_this_edge = 0; other_node_this_edge != n_nodes; other_node_this_edge++)
                    if ( (elem->is_node_on_edge(other_node_this_edge, current_edge)) && // On the current edge
                         (elem->node_id(other_node_this_edge) != global_id))               // But not the original node
                      {
                        // We've found a nodal neighbor!  Save a pointer to it..
                        node_to_save = elem->node_ptr(other_node_this_edge);
                        break;
                      }
 
                  // Make sure we found something
                  libmesh_assert(node_to_save != nullptr);
 
                  neighbor_set.insert(node_to_save);
                }
 
              // Keep looking for edges, node may be on more than one edge
              current_edge++;
            }
        } // if (elem->active())
    } // for
 
  // Assign the entries from the set to the vector.  Note: this
  // replaces any existing contents in neighbors and modifies its size
  // accordingly.
  neighbors.assign(neighbor_set.begin(), neighbor_set.end());
}

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::Utility::enum_to_string(), libMesh::DofObject::id(), libMesh::invalid_uint, libMesh::libmesh_assert(), and n_nodes.

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 743 of file mesh_tools.C.

{
  // We'll refer back to the Node ID several times
  dof_id_type global_id = node.id();
 
  // We'll construct a std::set<const Node *> for more efficient
  // searching while finding the nodal neighbors, and return it to the
  // user in a std::vector.
  std::set<const Node *> neighbor_set;
 
  // Look through the elements that contain this node
  // find the local node id... then find the side that
  // node lives on in the element
  // next, look for the _other_ node on that side
  // That other node is a "nodal_neighbor"... save it
  for (const auto & elem : nodes_to_elem_map[global_id])
    {
      // We only care about active elements...
      if (elem->active())
        {
          // Which local node number is global_id?
          unsigned local_node_number = elem->local_node(global_id);
 
          // Make sure it was found
          libmesh_assert_not_equal_to(local_node_number, libMesh::invalid_uint);
 
          const unsigned short n_edges = elem->n_edges();
 
          // If this element has no edges, the edge-based algorithm below doesn't make sense.
          if (!n_edges)
            {
              switch (elem->type())
                {
                case EDGE2:
                  {
                    switch (local_node_number)
                      {
                      case 0:
                        // The other node is a nodal neighbor
                        neighbor_set.insert(elem->node_ptr(1));
                        break;
 
                      case 1:
                        // The other node is a nodal neighbor
                        neighbor_set.insert(elem->node_ptr(0));
                        break;
 
                      default:
                        libmesh_error_msg("Invalid local node number: " << local_node_number << " found." << std::endl);
                      }
                    break;
                  }
 
                case EDGE3:
                  {
                    switch (local_node_number)
                      {
                        // The outside nodes have node 2 as a neighbor
                      case 0:
                      case 1:
                        neighbor_set.insert(elem->node_ptr(2));
                        break;
 
                        // The middle node has the outer nodes as neighbors
                      case 2:
                        neighbor_set.insert(elem->node_ptr(0));
                        neighbor_set.insert(elem->node_ptr(1));
                        break;
 
                      default:
                        libmesh_error_msg("Invalid local node number: " << local_node_number << " found." << std::endl);
                      }
                    break;
                  }
 
                case EDGE4:
                  {
                    switch (local_node_number)
                      {
                      case 0:
                        // The left-middle node is a nodal neighbor
                        neighbor_set.insert(elem->node_ptr(2));
                        break;
 
                      case 1:
                        // The right-middle node is a nodal neighbor
                        neighbor_set.insert(elem->node_ptr(3));
                        break;
 
                        // The left-middle node
                      case 2:
                        neighbor_set.insert(elem->node_ptr(0));
                        neighbor_set.insert(elem->node_ptr(3));
                        break;
 
                        // The right-middle node
                      case 3:
                        neighbor_set.insert(elem->node_ptr(1));
                        neighbor_set.insert(elem->node_ptr(2));
                        break;
 
                      default:
                        libmesh_error_msg("Invalid local node number: " << local_node_number << " found." << std::endl);
                      }
                    break;
                  }
 
                default:
                  libmesh_error_msg("Unrecognized ElemType: " << Utility::enum_to_string(elem->type()) << std::endl);
                }
            }
 
          // Index of the current edge
          unsigned current_edge = 0;
 
          const unsigned short n_nodes = elem->n_nodes();
 
          while (current_edge < n_edges)
            {
              // Find the edge the node is on
              bool found_edge = false;
              for (; current_edge<n_edges; ++current_edge)
                if (elem->is_node_on_edge(local_node_number, current_edge))
                  {
                    found_edge = true;
                    break;
                  }
 
              // Did we find one?
              if (found_edge)
                {
                  const Node * node_to_save = nullptr;
 
                  // Find another node in this element on this edge
                  for (unsigned other_node_this_edge = 0; other_node_this_edge != n_nodes; other_node_this_edge++)
                    if ( (elem->is_node_on_edge(other_node_this_edge, current_edge)) && // On the current edge
                         (elem->node_id(other_node_this_edge) != global_id))               // But not the original node
                      {
                        // We've found a nodal neighbor!  Save a pointer to it..
                        node_to_save = elem->node_ptr(other_node_this_edge);
                        break;
                      }
 
                  // Make sure we found something
                  libmesh_assert(node_to_save != nullptr);
 
                  neighbor_set.insert(node_to_save);
                }
 
              // Keep looking for edges, node may be on more than one edge
              current_edge++;
            }
        } // if (elem->active())
    } // for
 
  // Assign the entries from the set to the vector.  Note: this
  // replaces any existing contents in neighbors and modifies its size
  // accordingly.
  neighbors.assign(neighbor_set.begin(), neighbor_set.end());
}

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::Utility::enum_to_string(), libMesh::DofObject::id(), libMesh::invalid_uint, libMesh::libmesh_assert(), and n_nodes.

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

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 694 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 libMesh::MeshBase::element_ptr_range(), and 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 1961 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 libMesh::MeshBase::active_element_ptr_range(), and 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 1371 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::MeshBase::element_ptr_range(), libMesh::libmesh_assert(), mesh, and libMesh::MeshBase::node_ptr_range().

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 1664 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::MeshBase::max_elem_id(), libMesh::MeshBase::max_node_id(), mesh, libMesh::ParallelObject::processor_id(), libMesh::DofObject::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 1694 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::MeshBase::max_elem_id(), mesh, n_nodes(), libMesh::Elem::n_nodes(), libMesh::Elem::node_ptr(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::MeshBase::query_elem_ptr(), 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 processors, as is required by libMesh numeric classes.

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

Definition at line 1593 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 : IntRange<unsigned int>(0, node->n_vars(sysnum)))
        for (auto c : IntRange<unsigned int>(0, 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 : IntRange<unsigned int>(0, node->n_vars(sysnum)))
        for (auto c : IntRange<unsigned int>(0, 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::MeshBase::local_node_ptr_range(), mesh, libMesh::ParallelObject::n_processors(), libMesh::MeshBase::node_ptr_range(), and libMesh::ParallelObject::processor_id().

libmesh_assert_equal_n_systems()

void libMesh::MeshTools::libmesh_assert_equal_n_systems

(

const MeshBase &

mesh

)

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

Definition at line 1168 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::MeshBase::element_ptr_range(), libMesh::invalid_uint, mesh, and libMesh::MeshBase::node_ptr_range().

libmesh_assert_no_links_to_elem()

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

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

Definition at line 1272 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::MeshBase::element_ptr_range(), 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 1194 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->old_dof_object);
 
      for (auto & node : elem->node_ref_range())
        if (node.has_dofs())
          libmesh_assert(node.old_dof_object);
    }
}

References libMesh::MeshBase::element_ptr_range(), 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 recieved consistent DofObject::id(), using element topology to identify matching nodes.

Definition at line 1870 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::MeshBase::max_elem_id(), mesh, n_nodes(), libMesh::Elem::n_nodes(), libMesh::ParallelObject::n_processors(), libMesh::Elem::node_ptr(), libMesh::DofObject::processor_id(), and libMesh::MeshBase::query_elem_ptr().

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

)

Definition at line 1770 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::MeshBase::element_ptr_range(), libMesh::libmesh_assert(), mesh, libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::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

)

Definition at line 1908 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::MeshBase::local_elements_begin(), libMesh::MeshBase::local_elements_end(), mesh, libMesh::ParallelObject::n_processors(), libMesh::MeshBase::node_ptr_range(), libMesh::DofObject::processor_id(), and libMesh::MeshBase::query_node_ptr().

Referenced by 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

)

Definition at line 1726 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::MeshBase::element_ptr_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

)

Definition at line 1819 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 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_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::MeshBase::local_elements_begin(), libMesh::MeshBase::local_elements_end(), libMesh::MeshBase::local_node_ptr_range(), mesh, libMesh::ParallelObject::n_processors(), and libMesh::MeshBase::node_ptr_range().

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 1315 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::MeshBase::element_ptr_range(), 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 1335 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::MeshBase::element_ptr_range(), 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 1396 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::ParallelObject::comm(), libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::invalid_id, libMesh::libmesh_assert(), libMesh::MeshBase::max_elem_id(), mesh, libMesh::Elem::n_edges(), n_nodes(), libMesh::Elem::n_nodes(), libMesh::ParallelObject::n_processors(), libMesh::Elem::n_sides(), libMesh::Elem::node_ptr(), and libMesh::MeshBase::query_elem_ptr().

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

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

Referenced by libMesh::DofMap::distribute_dofs().

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 1292 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::MeshBase::active_element_ptr_range(), 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 2061 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::MeshBase::element_ptr_range(), libMesh::DofObject::id(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::MeshBase::max_elem_id(), mesh, libMesh::Elem::n_neighbors(), libMesh::ParallelObject::n_processors(), libMesh::Elem::neighbor_ptr(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::MeshBase::query_elem_ptr(), and libMesh::remote_elem.

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

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 1218 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::MeshBase::element_ptr_range(), 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 581 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 1978 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::MeshBase::element_ptr_range(), libMesh::libmesh_assert(), libMesh::MeshBase::max_elem_id(), mesh, 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 2026 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::MeshBase::element_ptr_range(), libMesh::Elem::JUST_REFINED, libMesh::libmesh_assert(), mesh, and libMesh::remote_elem.

Referenced by libMesh::MeshCommunication::delete_remote_elements(), and libMesh::DistributedMesh::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 1242 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(), libMesh::MeshBase::local_elements_begin(), libMesh::MeshBase::local_elements_end(), 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.

FIXME: we ought to check for uniqueness too.

Definition at line 1634 of file mesh_tools.C.

{
  LOG_SCOPE("libmesh_assert_valid_unique_ids()", "MeshTools");
 
  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 unique_id_type unique_id = elem ? elem->unique_id() : 0;
      const unique_id_type * uid_ptr = elem ? &unique_id : nullptr;
      libmesh_assert(mesh.comm().semiverify(uid_ptr));
    }
 
  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);
      const unique_id_type unique_id = node ? node->unique_id() : 0;
      const unique_id_type * uid_ptr = node ? &unique_id : nullptr;
      libmesh_assert(mesh.comm().semiverify(uid_ptr));
    }
}

References libMesh::ParallelObject::comm(), libMesh::libmesh_assert(), libMesh::MeshBase::max_elem_id(), libMesh::MeshBase::max_node_id(), mesh, libMesh::MeshBase::query_elem_ptr(), libMesh::MeshBase::query_node_ptr(), and libMesh::DofObject::unique_id().

Referenced by libMesh::MeshBase::prepare_for_use().

max_level()

unsigned int libMesh::MeshTools::max_level

(

const MeshBase &

mesh

)

Find the maximum h-refinement level in a mesh.

Referenced by libMesh::MeshRefinement::make_coarsening_compatible(), and libMesh::CheckpointIO::n_active_levels_in().

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 591 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 libMesh::MeshBase::active_type_elements_begin(), libMesh::MeshBase::active_type_elements_end(), distance(), and 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 626 of file mesh_tools.C.

{
  libmesh_parallel_only(mesh.comm());
 
  unsigned int nl = MeshTools::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(), mesh, n_active_local_levels(), libMesh::MeshBase::unpartitioned_elements_begin(), and libMesh::MeshBase::unpartitioned_elements_end().

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 614 of file mesh_tools.C.

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

References libMesh::MeshBase::active_local_element_ptr_range(), and mesh.

Referenced by n_active_levels().

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 705 of file mesh_tools.C.

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

References distance(), and end.

Referenced by libMesh::MeshTools::Subdivision::add_boundary_ghosts(), add_cube_convex_hull_to_mesh(), correct_node_proc_ids(), NodalNeighborsTest::do_test(), libMesh::MeshBase::get_info(), main(), libMesh::SFCPartitioner::partition_range(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::XdrIO::read(), libMesh::XdrIO::read_header(), libMesh::DynaIO::read_mesh(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::Partitioner::set_node_processor_ids(), libMesh::Partitioner::set_parent_processor_ids(), BoundaryInfoTest::testEdgeBoundaryConditions(), libMesh::XdrIO::write(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::UCDIO::write_nodal_data(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_vector(), and libMesh::System::write_serialized_vectors().

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 582 of file mesh_tools.C.

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

References distance(), mesh, libMesh::MeshBase::type_elements_begin(), and libMesh::MeshBase::type_elements_end().

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 656 of file mesh_tools.C.

{
  libmesh_parallel_only(mesh.comm());
 
  unsigned int nl = MeshTools::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 = MeshTools::paranoid_n_levels(mesh);
  libmesh_assert_equal_to(nl, paranoid_nl);
#endif
  return nl;
}

References libMesh::as_range(), libMesh::ParallelObject::comm(), mesh, n_local_levels(), paranoid_n_levels(), libMesh::MeshBase::unpartitioned_elements_begin(), and libMesh::MeshBase::unpartitioned_elements_end().

Referenced by libMesh::MeshCommunication::delete_remote_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::PetscDMWrapper::init_dm_data(), 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 643 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(), libMesh::MeshBase::local_elements_begin(), libMesh::MeshBase::local_elements_end(), 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 713 of file mesh_tools.C.

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

References distance(), and end.

Referenced by libmesh_assert_consistent_distributed_nodes(), libmesh_assert_parallel_consistent_new_node_procids(), and libmesh_assert_valid_boundary_ids().

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.

Definition at line 598 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(), mesh, libMesh::MeshBase::type_elements_begin(), and libMesh::MeshBase::type_elements_end().

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 721 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::MeshBase::local_elements_begin(), libMesh::MeshBase::local_elements_end(), mesh, libMesh::MeshBase::unpartitioned_elements_begin(), and libMesh::MeshBase::unpartitioned_elements_end().

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 680 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::MeshBase::element_ptr_range(), and mesh.

Referenced by n_levels().

processor_bounding_box()

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

Returns

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

Definition at line 469 of file mesh_tools.C.

{
  libmesh_deprecated();
  return MeshTools::create_processor_bounding_box(mesh, pid);
}

References create_processor_bounding_box(), and mesh.

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 505 of file mesh_tools.C.

{
  libMesh::BoundingBox bbox =
    MeshTools::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, std::norm(), and libMesh::Real.

subdomain_bounding_box()

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

Returns

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

Definition at line 521 of file mesh_tools.C.

{
  libmesh_deprecated();
  return MeshTools::create_subdomain_bounding_box(mesh, sid);
}

References create_subdomain_bounding_box(), and mesh.

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 556 of file mesh_tools.C.

{
  libMesh::BoundingBox bbox =
    MeshTools::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, std::norm(), 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 213 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::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), libMesh::DofObject::invalid_processor_id, libMesh::MeshBase::is_serial(), mesh, libMesh::Threads::parallel_reduce(), libMesh::ParallelObject::processor_id(), and weight().

weight() [1/2]

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

inline

Definition at line 113 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 236 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, libMesh::Threads::parallel_reduce(), libMesh::MeshBase::pid_elements_begin(), and libMesh::MeshBase::pid_elements_end().

Referenced by assemble_SchroedingerEquation(), assemble_wave(), libMesh::QGrundmann_Moller::gm_rule(), libMesh::QGrid::init_2D(), libMesh::QGrid::init_3D(), libMesh::FE< Dim, LAGRANGE_VEC >::init_shape_functions(), libMesh::InfFE< Dim, T_radial, T_map >::init_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), libMesh::InverseDistanceInterpolation< KDDim >::interpolate(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), CoupledFEMFunctionsx::operator()(), CoupledFEMFunctionsy::operator()(), libMesh::MeshTools::Modification::smooth(), total_weight(), and weight().