www.mooseframework.org
Public Member Functions | Public Attributes | Protected Attributes | List of all members
SlaveNeighborhoodThread Class Reference

#include <SlaveNeighborhoodThread.h>

Public Member Functions

 SlaveNeighborhoodThread (const MooseMesh &mesh, const std::vector< dof_id_type > &trial_master_nodes, const std::map< dof_id_type, std::vector< dof_id_type >> &node_to_elem_map, const unsigned int patch_size, KDTree &_kd_tree)
 
 SlaveNeighborhoodThread (SlaveNeighborhoodThread &x, Threads::split split)
 Splitting Constructor. More...
 
void operator() (const NodeIdRange &range)
 Save a patch of nodes that are close to each of the slave nodes to speed the search algorithm TODO: This needs to be updated at some point in time. More...
 
void join (const SlaveNeighborhoodThread &other)
 

Public Attributes

KDTree_kd_tree
 
std::vector< dof_id_type > _slave_nodes
 List of the slave nodes we're actually going to keep track of. More...
 
std::map< dof_id_type, std::vector< dof_id_type > > _neighbor_nodes
 The neighborhood nodes associated with each node. More...
 
std::set< dof_id_type > _ghosted_elems
 Elements that we need to ghost. More...
 

Protected Attributes

const MooseMesh_mesh
 The Mesh. More...
 
const std::vector< dof_id_type > & _trial_master_nodes
 Nodes to search against. More...
 
const std::map< dof_id_type, std::vector< dof_id_type > > & _node_to_elem_map
 Node to elem map. More...
 
unsigned int _patch_size
 The number of nodes to keep. More...
 

Detailed Description

Definition at line 23 of file SlaveNeighborhoodThread.h.

Constructor & Destructor Documentation

◆ SlaveNeighborhoodThread() [1/2]

SlaveNeighborhoodThread::SlaveNeighborhoodThread ( const MooseMesh mesh,
const std::vector< dof_id_type > &  trial_master_nodes,
const std::map< dof_id_type, std::vector< dof_id_type >> &  node_to_elem_map,
const unsigned int  patch_size,
KDTree _kd_tree 
)

Definition at line 19 of file SlaveNeighborhoodThread.C.

25  : _kd_tree(kd_tree),
26  _mesh(mesh),
27  _trial_master_nodes(trial_master_nodes),
28  _node_to_elem_map(node_to_elem_map),
29  _patch_size(patch_size)
30 {
31 }
const std::map< dof_id_type, std::vector< dof_id_type > > & _node_to_elem_map
Node to elem map.
const std::vector< dof_id_type > & _trial_master_nodes
Nodes to search against.
unsigned int _patch_size
The number of nodes to keep.
const MooseMesh & _mesh
The Mesh.

◆ SlaveNeighborhoodThread() [2/2]

SlaveNeighborhoodThread::SlaveNeighborhoodThread ( SlaveNeighborhoodThread x,
Threads::split  split 
)

Splitting Constructor.

Definition at line 34 of file SlaveNeighborhoodThread.C.

36  : _kd_tree(x._kd_tree),
37  _mesh(x._mesh),
38  _trial_master_nodes(x._trial_master_nodes),
39  _node_to_elem_map(x._node_to_elem_map),
40  _patch_size(x._patch_size)
41 {
42 }
const std::map< dof_id_type, std::vector< dof_id_type > > & _node_to_elem_map
Node to elem map.
static PetscErrorCode Vec x
const std::vector< dof_id_type > & _trial_master_nodes
Nodes to search against.
unsigned int _patch_size
The number of nodes to keep.
const MooseMesh & _mesh
The Mesh.

Member Function Documentation

◆ join()

void SlaveNeighborhoodThread::join ( const SlaveNeighborhoodThread other)

Definition at line 175 of file SlaveNeighborhoodThread.C.

176 {
177  _slave_nodes.insert(_slave_nodes.end(), other._slave_nodes.begin(), other._slave_nodes.end());
178  _ghosted_elems.insert(other._ghosted_elems.begin(), other._ghosted_elems.end());
179  _neighbor_nodes.insert(other._neighbor_nodes.begin(), other._neighbor_nodes.end());
180 }
std::set< dof_id_type > _ghosted_elems
Elements that we need to ghost.
std::map< dof_id_type, std::vector< dof_id_type > > _neighbor_nodes
The neighborhood nodes associated with each node.
std::vector< dof_id_type > _slave_nodes
List of the slave nodes we&#39;re actually going to keep track of.

◆ operator()()

void SlaveNeighborhoodThread::operator() ( const NodeIdRange range)

Save a patch of nodes that are close to each of the slave nodes to speed the search algorithm TODO: This needs to be updated at some point in time.

If the hits into this data structure approach "the end" then it may be time to update

neighborSearch function takes the slave coordinates and patch_size as input and finds the k (=patch_size) nearest neighbors to the slave node from the trial master node set. The indices of the nearest neighbors are stored in the array return_index.

Now see if this processor needs to keep track of this slave and it's neighbors We're going to see if this processor owns the slave, any of the neighborhood nodes or any of the elements connected to either set. If it does then we're going to ghost all of the elements connected to the slave node and the neighborhood nodes to this processor. This is a very conservative approach that we might revisit later.

Definition at line 51 of file SlaveNeighborhoodThread.C.

52 {
53  unsigned int patch_size =
54  std::min(_patch_size, static_cast<unsigned int>(_trial_master_nodes.size()));
55 
56  std::vector<std::size_t> return_index(patch_size);
57 
58  for (const auto & node_id : range)
59  {
60  const Node & node = _mesh.nodeRef(node_id);
61  Point query_pt;
62  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
63  query_pt(i) = node(i);
64 
75  _kd_tree.neighborSearch(query_pt, patch_size, return_index);
76 
77  std::vector<dof_id_type> neighbor_nodes(return_index.size());
78  for (unsigned int i = 0; i < return_index.size(); ++i)
79  neighbor_nodes[i] = _trial_master_nodes[return_index[i]];
80 
81  processor_id_type processor_id = _mesh.processor_id();
82 
91  bool need_to_track = false;
92 
93  if (_mesh.nodeRef(node_id).processor_id() == processor_id)
94  need_to_track = true;
95  else
96  {
97  {
98  auto node_to_elem_pair = _node_to_elem_map.find(node_id);
99  if (node_to_elem_pair != _node_to_elem_map.end())
100  {
101  const std::vector<dof_id_type> & elems_connected_to_node = node_to_elem_pair->second;
102 
103  // See if we own any of the elements connected to the slave node
104  for (const auto & dof : elems_connected_to_node)
105  if (_mesh.elemPtr(dof)->processor_id() == processor_id)
106  {
107  need_to_track = true;
108  break; // Break out of element loop
109  }
110  }
111  }
112 
113  if (!need_to_track)
114  { // Now check the neighbor nodes to see if we own any of them
115  for (const auto & neighbor_node_id : neighbor_nodes)
116  {
117  if (_mesh.nodeRef(neighbor_node_id).processor_id() == processor_id)
118  need_to_track = true;
119  else // Now see if we own any of the elements connected to the neighbor nodes
120  {
121  auto node_to_elem_pair = _node_to_elem_map.find(neighbor_node_id);
122  mooseAssert(node_to_elem_pair != _node_to_elem_map.end(),
123  "Missing entry in node to elem map");
124  const std::vector<dof_id_type> & elems_connected_to_node = node_to_elem_pair->second;
125 
126  for (const auto & dof : elems_connected_to_node)
127  if (_mesh.elemPtr(dof)->processor_id() == processor_id)
128  {
129  need_to_track = true;
130  break; // Break out of element loop
131  }
132  }
133 
134  if (need_to_track)
135  break; // Breaking out of neighbor loop
136  }
137  }
138  }
139 
140  if (need_to_track)
141  {
142  // Add this node as a slave node to search in the future
143  _slave_nodes.push_back(node_id);
144 
145  // Set it's neighbors
146  _neighbor_nodes[node_id] = neighbor_nodes;
147 
148  { // Add the elements connected to the slave node to the ghosted list
149  auto node_to_elem_pair = _node_to_elem_map.find(node_id);
150 
151  if (node_to_elem_pair != _node_to_elem_map.end())
152  {
153  const std::vector<dof_id_type> & elems_connected_to_node = node_to_elem_pair->second;
154 
155  for (const auto & dof : elems_connected_to_node)
156  _ghosted_elems.insert(dof);
157  }
158  }
159  // Now add elements connected to the neighbor nodes to the ghosted list
160  for (unsigned int neighbor_it = 0; neighbor_it < neighbor_nodes.size(); neighbor_it++)
161  {
162  auto node_to_elem_pair = _node_to_elem_map.find(neighbor_nodes[neighbor_it]);
163  mooseAssert(node_to_elem_pair != _node_to_elem_map.end(),
164  "Missing entry in node to elem map");
165  const std::vector<dof_id_type> & elems_connected_to_node = node_to_elem_pair->second;
166 
167  for (const auto & dof : elems_connected_to_node)
168  _ghosted_elems.insert(dof);
169  }
170  }
171  }
172 }
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:2219
const std::map< dof_id_type, std::vector< dof_id_type > > & _node_to_elem_map
Node to elem map.
void neighborSearch(Point &query_point, unsigned int patch_size, std::vector< std::size_t > &return_index)
Definition: KDTree.C:26
std::set< dof_id_type > _ghosted_elems
Elements that we need to ghost.
virtual const Node & nodeRef(const dof_id_type i) const
Definition: MooseMesh.C:478
std::map< dof_id_type, std::vector< dof_id_type > > _neighbor_nodes
The neighborhood nodes associated with each node.
std::vector< dof_id_type > _slave_nodes
List of the slave nodes we&#39;re actually going to keep track of.
const std::vector< dof_id_type > & _trial_master_nodes
Nodes to search against.
unsigned int _patch_size
The number of nodes to keep.
const MooseMesh & _mesh
The Mesh.

Member Data Documentation

◆ _ghosted_elems

std::set<dof_id_type> SlaveNeighborhoodThread::_ghosted_elems

Elements that we need to ghost.

Definition at line 48 of file SlaveNeighborhoodThread.h.

Referenced by join(), and operator()().

◆ _kd_tree

KDTree& SlaveNeighborhoodThread::_kd_tree

Definition at line 26 of file SlaveNeighborhoodThread.h.

Referenced by operator()().

◆ _mesh

const MooseMesh& SlaveNeighborhoodThread::_mesh
protected

The Mesh.

Definition at line 52 of file SlaveNeighborhoodThread.h.

Referenced by operator()().

◆ _neighbor_nodes

std::map<dof_id_type, std::vector<dof_id_type> > SlaveNeighborhoodThread::_neighbor_nodes

The neighborhood nodes associated with each node.

Definition at line 45 of file SlaveNeighborhoodThread.h.

Referenced by join(), and operator()().

◆ _node_to_elem_map

const std::map<dof_id_type, std::vector<dof_id_type> >& SlaveNeighborhoodThread::_node_to_elem_map
protected

Node to elem map.

Definition at line 58 of file SlaveNeighborhoodThread.h.

Referenced by operator()().

◆ _patch_size

unsigned int SlaveNeighborhoodThread::_patch_size
protected

The number of nodes to keep.

Definition at line 61 of file SlaveNeighborhoodThread.h.

Referenced by operator()().

◆ _slave_nodes

std::vector<dof_id_type> SlaveNeighborhoodThread::_slave_nodes

List of the slave nodes we're actually going to keep track of.

Definition at line 42 of file SlaveNeighborhoodThread.h.

Referenced by join(), and operator()().

◆ _trial_master_nodes

const std::vector<dof_id_type>& SlaveNeighborhoodThread::_trial_master_nodes
protected

Nodes to search against.

Definition at line 55 of file SlaveNeighborhoodThread.h.

Referenced by operator()().


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