CacheInfoThread Class Reference

Fills lower-d side maps and node-to-block ownership for MooseMesh::cacheInfo(). More...

#include <CacheInfoThread.h>

Public Member Functions
	CacheInfoThread (MooseMesh &mesh, bool cache_node_blocks)
	CacheInfoThread (CacheInfoThread &x, Threads::split split)
void	operator() (const ConstElemRange &range)
void	join (const CacheInfoThread &y)

Protected Member Functions
void	cacheNodeBlock (dof_id_type node_id, SubdomainID block_id)
	Record that an element of subdomain block_id is incident on the node node_id.

Protected Attributes
MooseMesh &	_mesh
const bool	_cache_node_blocks
	Whether node-to-block ownership has to be recorded at all.
std::unordered_map< dof_id_type, SubdomainID >	_node_block
	The subdomain of the elements incident on a node, for the nodes whose incident elements all agree, which is every node away from a subdomain interface.
std::unordered_map< dof_id_type, std::set< SubdomainID > >	_interface_node_blocks
	The full subdomain set of the nodes whose incident elements disagree, that is the nodes on a subdomain interface.
std::set< SubdomainID >	_lower_d_interior_blocks
std::set< SubdomainID >	_lower_d_boundary_blocks
std::unordered_map< std::pair< const Elem *, unsigned short int >, const Elem * >	_higher_d_elem_side_to_lower_d_elem
std::unordered_map< const Elem *, unsigned short int >	_lower_d_elem_to_higher_d_elem_side

Friends
class	MooseMesh

Detailed Description

Fills lower-d side maps and node-to-block ownership for MooseMesh::cacheInfo().

The range is all elements this rank knows about (local and ghosted).

Definition at line 21 of file CacheInfoThread.h.

Constructor & Destructor Documentation

CacheInfoThread() [1/2]

CacheInfoThread::CacheInfoThread	(	MooseMesh &	mesh,
		bool	cache_node_blocks
	)

Parameters

cache_node_blocks

Whether to record node-to-block ownership. MooseMesh::cacheInfo() passes false when the relation is constant, i.e. when the mesh has a single subdomain.

Definition at line 15 of file CacheInfoThread.C.

  : _mesh(mesh), _cache_node_blocks(cache_node_blocks)
{
}

CacheInfoThread() [2/2]

CacheInfoThread::CacheInfoThread	(	CacheInfoThread &	x,
		Threads::split	split
	)

Definition at line 20 of file CacheInfoThread.C.

  : _mesh(x._mesh), _cache_node_blocks(x._cache_node_blocks)
{
}

Member Function Documentation

cacheNodeBlock()

void CacheInfoThread::cacheNodeBlock ( dof_id_type  node_id, SubdomainID  block_id  )

protected

Record that an element of subdomain block_id is incident on the node node_id.

Each node is a key in exactly one of _node_block and _interface_node_blocks: it stays in _node_block while every recorded subdomain for the given node_id matches, and the first mismatching subdomain moves it to _interface_node_blocks with both subdomains.

Definition at line 26 of file CacheInfoThread.C.

{
  // Most calls revisit a node away from any interface, which this single lookup settles
  if (const auto it = _node_block.find(node_id); it != _node_block.end())
  {
    if (it->second == block_id)
      return;
 
    // The elements incident on this node disagree, so it needs the full set from here on
    _interface_node_blocks.emplace(node_id, std::set<SubdomainID>{it->second, block_id});
    _node_block.erase(it);
    return;
  }
 
  if (const auto it = _interface_node_blocks.find(node_id); it != _interface_node_blocks.end())
    it->second.insert(block_id);
  else
    _node_block.emplace(node_id, block_id);
}

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

join()

void CacheInfoThread::join

(

const CacheInfoThread &

y

)

Definition at line 93 of file CacheInfoThread.C.

{
  // Adding y's entries through cacheNodeBlock() keeps each node in only one of _node_block and
  // _interface_node_blocks: a node that each thread saw with a single, but different, subdomain
  // becomes an interface node here
  for (const auto & [node_id, block_id] : y._node_block)
    cacheNodeBlock(node_id, block_id);
  for (const auto & [node_id, block_ids] : y._interface_node_blocks)
    for (const auto block_id : block_ids)
      cacheNodeBlock(node_id, block_id);
 
  _higher_d_elem_side_to_lower_d_elem.insert(y._higher_d_elem_side_to_lower_d_elem.begin(),
                                             y._higher_d_elem_side_to_lower_d_elem.end());
  _lower_d_elem_to_higher_d_elem_side.insert(y._lower_d_elem_to_higher_d_elem_side.begin(),
                                             y._lower_d_elem_to_higher_d_elem_side.end());
  _lower_d_interior_blocks.insert(y._lower_d_interior_blocks.begin(),
                                  y._lower_d_interior_blocks.end());
  _lower_d_boundary_blocks.insert(y._lower_d_boundary_blocks.begin(),
                                  y._lower_d_boundary_blocks.end());
}

operator()()

void CacheInfoThread::operator()

(

const ConstElemRange &

range

)

Definition at line 47 of file CacheInfoThread.C.

{
  const auto & mesh = _mesh.getMesh();
 
  for (const auto & elem : range)
  {
    const Elem * ip_elem = elem->interior_parent();
 
    if (ip_elem)
    {
      unsigned int ip_side = ip_elem->which_side_am_i(elem);
 
      // For some grid sequencing tests: ip_side == libMesh::invalid_uint
      if (ip_side != libMesh::invalid_uint)
      {
        auto pair = std::make_pair(ip_elem, static_cast<unsigned short int>(ip_side));
        _higher_d_elem_side_to_lower_d_elem.emplace(pair, elem);
        _lower_d_elem_to_higher_d_elem_side.emplace(elem, pair.second);
 
        auto id = elem->subdomain_id();
        if (ip_elem->neighbor_ptr(ip_side))
        {
          if (mesh.subdomain_name(id).find("INTERNAL_SIDE_LOWERD_SUBDOMAIN_") != std::string::npos)
            _lower_d_interior_blocks.insert(id);
        }
        else
        {
          if (mesh.subdomain_name(id).find("BOUNDARY_SIDE_LOWERD_SUBDOMAIN_") != std::string::npos)
            _lower_d_boundary_blocks.insert(id);
        }
      }
    }
 
    if (_cache_node_blocks)
    {
      const auto block_id = elem->subdomain_id();
      for (const auto nd : make_range(elem->n_nodes()))
      {
        const Node & node = *elem->node_ptr(nd);
        cacheNodeBlock(node.id(), block_id);
      }
    }
  }
}

Friends And Related Symbol Documentation

MooseMesh

friend class MooseMesh

friend

Definition at line 64 of file CacheInfoThread.h.

Member Data Documentation

_cache_node_blocks

const bool CacheInfoThread::_cache_node_blocks

protected

Whether node-to-block ownership has to be recorded at all.

Definition at line 47 of file CacheInfoThread.h.

Referenced by operator()().

_higher_d_elem_side_to_lower_d_elem

std::unordered_map<std::pair<const Elem *, unsigned short int>, const Elem *> CacheInfoThread::_higher_d_elem_side_to_lower_d_elem

protected

Definition at line 61 of file CacheInfoThread.h.

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

_interface_node_blocks

std::unordered_map<dof_id_type, std::set<SubdomainID> > CacheInfoThread::_interface_node_blocks

protected

The full subdomain set of the nodes whose incident elements disagree, that is the nodes on a subdomain interface.

Interface nodes are typically a small fraction of the mesh, so storing a set for each of them costs little.

Definition at line 56 of file CacheInfoThread.h.

Referenced by MooseMesh::cacheInfo(), cacheNodeBlock(), and join().

_lower_d_boundary_blocks

std::set<SubdomainID> CacheInfoThread::_lower_d_boundary_blocks

protected

Definition at line 59 of file CacheInfoThread.h.

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

_lower_d_elem_to_higher_d_elem_side

std::unordered_map<const Elem *, unsigned short int> CacheInfoThread::_lower_d_elem_to_higher_d_elem_side

protected

Definition at line 62 of file CacheInfoThread.h.

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

_lower_d_interior_blocks

std::set<SubdomainID> CacheInfoThread::_lower_d_interior_blocks

protected

Definition at line 58 of file CacheInfoThread.h.

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

_mesh

MooseMesh& CacheInfoThread::_mesh

protected

Definition at line 44 of file CacheInfoThread.h.

Referenced by operator()().

_node_block

std::unordered_map<dof_id_type, SubdomainID> CacheInfoThread::_node_block

protected

The subdomain of the elements incident on a node, for the nodes whose incident elements all agree, which is every node away from a subdomain interface.

Definition at line 51 of file CacheInfoThread.h.

Referenced by MooseMesh::cacheInfo(), cacheNodeBlock(), and join().

---

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

• include/loops/CacheInfoThread.h
• src/loops/CacheInfoThread.C