libMesh::TopologyMap Class Reference

Enables topology-based lookups of nodes. 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)
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, myhash >	map_type

Private Attributes
map_type	_map

Detailed Description

Enables topology-based lookups of nodes.

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

Definition at line 69 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, myhash> libMesh::TopologyMap::map_type

private

Definition at line 72 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 52 of file topology_map.C.

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

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 (std::size_t i=0; i != bracketing_nodes.size(); ++i)
    {
      const dof_id_type id1 = bracketing_nodes[i].first;
      const dof_id_type id2 = bracketing_nodes[i].second;
      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.insert(std::make_pair(std::make_pair(lower_id, upper_id),
                                       mid_node_id));

    }
}

clear()

void libMesh::TopologyMap::clear ( )

inline

Definition at line 76 of file topology_map.h.

References _map.

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

{ _map.clear(); }

empty()

bool libMesh::TopologyMap::empty ( ) const

inline

Definition at line 87 of file topology_map.h.

References _map.

{ return _map.empty(); }

fill()

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

protected

Definition at line 139 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; n != elem->n_nodes_in_child(c); ++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 118 of file topology_map.C.

References _map, libMesh::DofObject::invalid_id, std::max(), and std::min().

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 82 of file topology_map.C.

References find(), libMesh::DofObject::invalid_id, std::max(), and std::min().

{
  dof_id_type new_node_id = DofObject::invalid_id;

  for (std::size_t i = 0; i != bracketing_nodes.size(); ++i)
    {
      const dof_id_type lower_id = std::min(bracketing_nodes[i].first,
                                            bracketing_nodes[i].second);
      const dof_id_type upper_id = std::max(bracketing_nodes[i].first,
                                            bracketing_nodes[i].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 35 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 100 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:

• topology_map.h
• topology_map.C