Data structures that enable topology-based lookups of nodes created by mesh refinement. More...

#include <topology_map.h>

Public Member Functions
void	init (MeshBase &)

void	clear ()

void	add_node (const Node &mid_node, const std::vector< std::pair< dof_id_type, dof_id_type > > &bracketing_nodes)
	Add a node to the map, between each pair of specified bracketing nodes.

bool	empty () const

dof_id_type	find (dof_id_type bracket_node1, dof_id_type bracket_node2) const

dof_id_type	find (const std::vector< std::pair< dof_id_type, dof_id_type > > &bracketing_nodes) const

Protected Member Functions
void	fill (const MeshBase &)

Private Types
typedef std::unordered_map< std::pair< dof_id_type, dof_id_type >, dof_id_type, libMesh::hash >	map_type

Private Attributes
map_type	_map

Detailed Description

Data structures that enable topology-based lookups of nodes created by mesh refinement.

The key is a pair of node ids for two nodes bracketing the new node, sorted lowest id first.

A node created in the middle of a cell's quad face will be the value of two keys, one for each node pair bracketing it.

For efficiency we will use a hashed map if it is available, otherwise a regular map.

Author: Roy Stogner

Date: 2015

Enables topology-based lookups of nodes.

Definition at line 57 of file topology_map.h.

Member Typedef Documentation

◆ map_type

typedef std::unordered_map<std::pair<dof_id_type, dof_id_type>, dof_id_type, libMesh::hash> libMesh::TopologyMap::map_type

private

Definition at line 60 of file topology_map.h.

Member Function Documentation

◆ add_node()

void libMesh::TopologyMap::add_node	(	const Node &	mid_node,
		const std::vector< std::pair< dof_id_type, dof_id_type > > &	bracketing_nodes
	)

Add a node to the map, between each pair of specified bracketing nodes.

Definition at line 53 of file topology_map.C.

{
  const dof_id_type mid_node_id = mid_node.id();
 
  libmesh_assert_not_equal_to(mid_node_id, DofObject::invalid_id);
 
  for (auto [id1, id2] : bracketing_nodes)
    {
      libmesh_assert_not_equal_to(id1, id2);
 
      const dof_id_type lower_id = std::min(id1, id2);
      const dof_id_type upper_id = std::max(id1, id2);
 
      // We should never be inserting inconsistent data
#ifndef NDEBUG
      if (const auto it = _map.find(std::make_pair(lower_id, upper_id));
          it != _map.end())
        libmesh_assert_equal_to (it->second, mid_node_id);
#endif
 
      this->_map.emplace(std::make_pair(lower_id, upper_id),
                         mid_node_id);
 
    }
}

References _map, libMesh::DofObject::id(), and libMesh::DofObject::invalid_id.

Referenced by libMesh::MeshRefinement::add_node(), and fill().

◆ clear()

void libMesh::TopologyMap::clear ( )

inline

Definition at line 64 of file topology_map.h.

64{ _map.clear(); }

References _map.

Referenced by libMesh::MeshRefinement::clear().

◆ empty()

bool libMesh::TopologyMap::empty ( ) const

inline

Definition at line 75 of file topology_map.h.

75{ return _map.empty(); }

References _map.

◆ fill()

void libMesh::TopologyMap::fill ( const MeshBase & mesh )

protected

Definition at line 136 of file topology_map.C.

{
  // Populate the nodes map
  for (const auto & elem : mesh.element_ptr_range())
    {
      // We only need to add nodes which might be added during mesh
      // refinement; this means they need to be child nodes.
      if (!elem->has_children())
        continue;
 
      for (unsigned int c = 0, nc = elem->n_children(); c != nc; ++c)
        {
          const Elem * child = elem->child_ptr(c);
          if (child == remote_elem)
            continue;
 
          for (unsigned int n = 0, nnic = elem->n_nodes_in_child(c); n != nnic; ++n)
            {
              const std::vector<std::pair<dof_id_type, dof_id_type>>
                bracketing_nodes = elem->bracketing_nodes(c,n);
 
              this->add_node(child->node_ref(n), bracketing_nodes);
            }
        }
    }
}

References add_node(), libMesh::Elem::bracketing_nodes(), libMesh::Elem::child_ptr(), mesh, libMesh::Elem::node_ref(), and libMesh::remote_elem.

Referenced by init().

◆ find() [1/2]

dof_id_type libMesh::TopologyMap::find ( const std::vector< std::pair< dof_id_type, dof_id_type > > & bracketing_nodes ) const

Definition at line 81 of file topology_map.C.

{
  dof_id_type new_node_id = DofObject::invalid_id;
 
  for (auto pair : bracketing_nodes)
    {
      const dof_id_type lower_id = std::min(pair.first, pair.second);
      const dof_id_type upper_id = std::max(pair.first, pair.second);
 
      const dof_id_type possible_new_node_id =
        this->find(lower_id, upper_id);
 
      if (possible_new_node_id != DofObject::invalid_id)
        {
          // If we found a node already, but we're still here, it's to
          // debug map consistency: we'd better always find the same
          // node
          if (new_node_id != DofObject::invalid_id)
            libmesh_assert_equal_to (new_node_id, possible_new_node_id);
 
          new_node_id = possible_new_node_id;
        }
 
      // If we're not debugging map consistency then we can quit as
      // soon as we find a node
#ifdef NDEBUG
      if (new_node_id != DofObject::invalid_id)
        break;
#endif
    }
  return new_node_id;
}

References find(), and libMesh::DofObject::invalid_id.

◆ find() [2/2]

dof_id_type libMesh::TopologyMap::find	(	dof_id_type	bracket_node1,
		dof_id_type	bracket_node2
	)		const

Definition at line 115 of file topology_map.C.

{
  const dof_id_type lower_id = std::min(bracket_node1, bracket_node2);
  const dof_id_type upper_id = std::max(bracket_node1, bracket_node2);
 
  if (const auto it = _map.find(std::make_pair(lower_id, upper_id));
      it != _map.end())
    {
      libmesh_assert_not_equal_to (it->second, DofObject::invalid_id);
      return it->second;
    }
 
  // If not found, return invalid_id
  return DofObject::invalid_id;
}

References _map, and libMesh::DofObject::invalid_id.

Referenced by libMesh::MeshRefinement::add_node(), and find().

◆ init()

void libMesh::TopologyMap::init ( MeshBase & mesh )

Definition at line 36 of file topology_map.C.

{
  // This function must be run on all processors at once
  // for non-serial meshes
  if (!mesh.is_serial())
    libmesh_parallel_only(mesh.comm());
 
  LOG_SCOPE("init()", "TopologyMap");
 
  // Clear the old map
  _map.clear();
 
  this->fill(mesh);
}

References _map, fill(), and mesh.

Member Data Documentation

◆ _map

map_type libMesh::TopologyMap::_map

private

Definition at line 88 of file topology_map.h.

Referenced by add_node(), clear(), empty(), find(), and init().

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

include/utils/topology_map.h
src/utils/topology_map.C

Public Member Functions

Protected Member Functions

Private Types

Private Attributes