libMesh::TopologyMap Class Reference

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

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

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

{
  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
      map_type::iterator it =
        _map.find(std::make_pair(lower_id, upper_id));

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

    }
}

clear()

void libMesh::TopologyMap::clear ( )

inline

Definition at line 64 of file topology_map.h.

References _map.

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

{ _map.clear(); }

empty()

bool libMesh::TopologyMap::empty ( ) const

inline

Definition at line 75 of file topology_map.h.

References _map.

{ return _map.empty(); }

fill()

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

protected

Definition at line 138 of file topology_map.C.

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

Referenced by init().

{
  // 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);
            }
        }
    }
}

find() [1/2]

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

Definition at line 117 of file topology_map.C.

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

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

{
  const dof_id_type lower_id = std::min(bracket_node1, bracket_node2);
  const dof_id_type upper_id = std::max(bracket_node1, bracket_node2);

  map_type::const_iterator it =
    _map.find(std::make_pair(lower_id, upper_id));

  if (it == _map.end())
    return DofObject::invalid_id;

  libmesh_assert_not_equal_to (it->second, DofObject::invalid_id);

  return it->second;
}

find() [2/2]

dof_id_type libMesh::TopologyMap::find

(

const std::vector< std::pair< dof_id_type, dof_id_type >> &

bracketing_nodes

)

const

Definition at line 83 of file topology_map.C.

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

{
  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;
}

init()

void libMesh::TopologyMap::init

(

MeshBase &

mesh

)

Definition at line 36 of file topology_map.C.

References _map, fill(), and mesh.

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

{
  // 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);
}

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