libMesh
Public Member Functions | Protected Member Functions | Private Types | Private Attributes | List of all members
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::hashmap_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().

55 {
56  const dof_id_type mid_node_id = mid_node.id();
57 
58  libmesh_assert_not_equal_to(mid_node_id, DofObject::invalid_id);
59 
60  for (auto [id1, id2] : bracketing_nodes)
61  {
62  libmesh_assert_not_equal_to(id1, id2);
63 
64  const dof_id_type lower_id = std::min(id1, id2);
65  const dof_id_type upper_id = std::max(id1, id2);
66 
67  // We should never be inserting inconsistent data
68 #ifndef NDEBUG
69  if (const auto it = _map.find(std::make_pair(lower_id, upper_id));
70  it != _map.end())
71  libmesh_assert_equal_to (it->second, mid_node_id);
72 #endif
73 
74  this->_map.emplace(std::make_pair(lower_id, upper_id),
75  mid_node_id);
76 
77  }
78 }
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
uint8_t dof_id_type
Definition: id_types.h:67

◆ clear()

void libMesh::TopologyMap::clear ( )
inline

Definition at line 64 of file topology_map.h.

References _map.

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

64 { _map.clear(); }

◆ empty()

bool libMesh::TopologyMap::empty ( ) const
inline

Definition at line 75 of file topology_map.h.

References _map.

75 { return _map.empty(); }

◆ fill()

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

Definition at line 136 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().

137 {
138  // Populate the nodes map
139  for (const auto & elem : mesh.element_ptr_range())
140  {
141  // We only need to add nodes which might be added during mesh
142  // refinement; this means they need to be child nodes.
143  if (!elem->has_children())
144  continue;
145 
146  for (unsigned int c = 0, nc = elem->n_children(); c != nc; ++c)
147  {
148  const Elem * child = elem->child_ptr(c);
149  if (child == remote_elem)
150  continue;
151 
152  for (unsigned int n = 0, nnic = elem->n_nodes_in_child(c); n != nnic; ++n)
153  {
154  const std::vector<std::pair<dof_id_type, dof_id_type>>
155  bracketing_nodes = elem->bracketing_nodes(c,n);
156 
157  this->add_node(child->node_ref(n), bracketing_nodes);
158  }
159  }
160  }
161 }
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.
Definition: topology_map.C:53
MeshBase & mesh
const RemoteElem * remote_elem
Definition: remote_elem.C:57

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

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

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

117 {
118  const dof_id_type lower_id = std::min(bracket_node1, bracket_node2);
119  const dof_id_type upper_id = std::max(bracket_node1, bracket_node2);
120 
121  if (const auto it = _map.find(std::make_pair(lower_id, upper_id));
122  it != _map.end())
123  {
124  libmesh_assert_not_equal_to (it->second, DofObject::invalid_id);
125  return it->second;
126  }
127 
128  // If not found, return invalid_id
129  return DofObject::invalid_id;
130 }
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
uint8_t dof_id_type
Definition: id_types.h:67

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

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

82 {
83  dof_id_type new_node_id = DofObject::invalid_id;
84 
85  for (auto pair : bracketing_nodes)
86  {
87  const dof_id_type lower_id = std::min(pair.first, pair.second);
88  const dof_id_type upper_id = std::max(pair.first, pair.second);
89 
90  const dof_id_type possible_new_node_id =
91  this->find(lower_id, upper_id);
92 
93  if (possible_new_node_id != DofObject::invalid_id)
94  {
95  // If we found a node already, but we're still here, it's to
96  // debug map consistency: we'd better always find the same
97  // node
98  if (new_node_id != DofObject::invalid_id)
99  libmesh_assert_equal_to (new_node_id, possible_new_node_id);
100 
101  new_node_id = possible_new_node_id;
102  }
103 
104  // If we're not debugging map consistency then we can quit as
105  // soon as we find a node
106 #ifdef NDEBUG
107  if (new_node_id != DofObject::invalid_id)
108  break;
109 #endif
110  }
111  return new_node_id;
112 }
dof_id_type find(dof_id_type bracket_node1, dof_id_type bracket_node2) const
Definition: topology_map.C:115
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
Definition: dof_object.h:482
uint8_t dof_id_type
Definition: id_types.h:67

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

37 {
38  // This function must be run on all processors at once
39  // for non-serial meshes
40  if (!mesh.is_serial())
41  libmesh_parallel_only(mesh.comm());
42 
43  LOG_SCOPE("init()", "TopologyMap");
44 
45  // Clear the old map
46  _map.clear();
47 
48  this->fill(mesh);
49 }
MeshBase & mesh
void fill(const MeshBase &)
Definition: topology_map.C:136

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: