Helper object for claiming Rays. More...

#include <ClaimRays.h>

Inheritance diagram for ClaimRays:

Public Member Functions
	ClaimRays (RayTracingStudy &study, const std::vector< std::shared_ptr< Ray > > &rays, std::vector< std::shared_ptr< Ray > > &local_rays, const bool do_exchange)
	Constructor.

virtual void	meshChanged () override
	Call on mesh changes to reinit the necessary data structures.

void	claim ()
	Claim the Rays.

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	init ()
	Initialize the object.

virtual void	preClaim ()
	Entry point before claim()

virtual void	postClaim ()
	Entry point after claim()

virtual void	prePossiblyClaimRay (const std::shared_ptr< Ray > &)
	Entry point before possibly claiming a Ray.

virtual void	postClaimRay (std::shared_ptr< Ray > &ray, const Elem *elem)
	Entry point for acting on a Ray after it is claimed.

virtual RayID	getID (const std::shared_ptr< Ray > &ray) const
	Gets an ID associated with the Ray for claiming purposes.

const libMesh::BoundingBox &	inflatedBoundingBox (const processor_id_type pid) const
	Get the inflated bounding box for rank \pid.

Protected Attributes
MooseMesh &	_mesh
	The mesh.

const processor_id_type	_pid
	This processor ID.

const bool	_do_exchange
	Whether or not the Rays need to be initially exchanged.

RayTracingStudy &	_study
	The RayTracingStudy.

ParallelStudy< std::shared_ptr< Ray >, Ray > &	_parallel_study
	The ParallelStudy, used as the context for communicating rays.

const Parallel::Communicator &	_communicator

FEProblemBase &	_mci_feproblem

Private Member Functions
void	buildBoundingBoxes ()
	Builds the bounding boxes (_inflated_bboxes).

void	buildPointNeighbors ()
	Build the map of elements to all of their point neighbors.

void	possiblyClaim (const std::shared_ptr< Ray > &obj)
	Possibly claim a Ray.

void	verifyClaiming ()
	Verifies that the claiming process succeeded.

const Elem *	claimPoint (const Point &point, const RayID id, const Elem *elem)
	Try to claim a spatial point.

Private Attributes
const std::vector< std::shared_ptr< Ray > > &	_rays
	The Rays that need to be searched to possibly claimed.

std::vector< std::shared_ptr< Ray > > &	_local_rays
	The local Rays that are claimed.

std::unique_ptr< libMesh::PointLocatorBase >	_point_locator = nullptr
	The point locator.

std::vector< libMesh::BoundingBox >	_inflated_bboxes
	The inflated bounding boxes for all processors.

std::unordered_map< dof_id_type, std::vector< const Elem * > >	_elem_point_neighbors
	Map of point neighbors for each element.

bool	_needs_init
	Whether or not an init is needed (bounding boxes, neighbors)

Detailed Description

Helper object for claiming Rays.

Definition at line 34 of file ClaimRays.h.

Constructor & Destructor Documentation

◆ ClaimRays()

ClaimRays::ClaimRays	(	RayTracingStudy &	study,
		const std::vector< std::shared_ptr< Ray > > &	rays,
		std::vector< std::shared_ptr< Ray > > &	local_rays,
		const bool	do_exchange
	)

Constructor.

Parameters

study	The RayTracingStudy
parallel_study	The base parallel study
mesh	The MooseMesh
rays	The vector of Rays that need to be claimed
local_rays	Insertion point for Rays that have been claimed
do_exchange	Whether or not an exchange is needed, i.e., if "rays" still needs to be filled by objects on other processors

Definition at line 22 of file ClaimRays.C.

  : ParallelObject(study.comm()),
    MeshChangedInterface(study.parameters()),
    _mesh(study.mesh()),
    _pid(comm().rank()),
    _do_exchange(do_exchange),
    _study(study),
    _parallel_study(*_study.parallelStudy()),
    _rays(rays),
    _local_rays(local_rays),
    _needs_init(true)
{
}

Member Function Documentation

◆ buildBoundingBoxes()

void ClaimRays::buildBoundingBoxes ( )

private

Builds the bounding boxes (_inflated_bboxes).

Definition at line 179 of file ClaimRays.C.

{
  // Local bounding box
  const auto bbox = MeshTools::create_local_bounding_box(_mesh.getMesh());
 
  // Gather the bounding boxes of all processors
  std::vector<std::pair<Point, Point>> bb_points = {static_cast<std::pair<Point, Point>>(bbox)};
  comm().allgather(bb_points, true);
 
  // Inflate the local bboxes by a bit and store
  _inflated_bboxes.resize(comm().size());
  for (processor_id_type pid = 0; pid < comm().size(); ++pid)
  {
    BoundingBox pid_bbox = static_cast<BoundingBox>(bb_points[pid]);
    pid_bbox.scale(0.01);
    _inflated_bboxes[pid] = pid_bbox;
  }
}

Referenced by init().

◆ buildPointNeighbors()

void ClaimRays::buildPointNeighbors ( )

private

Build the map of elements to all of their point neighbors.

TODO: Move this eventually into MooseMesh, MeshBase, or FEProblemBase

Definition at line 199 of file ClaimRays.C.

{
  _elem_point_neighbors.clear();
  const auto & node_to_elem_map = _mesh.nodeToElemMap();
 
  for (const auto & elem : _mesh.getMesh().active_element_ptr_range())
  {
    auto & fill = _elem_point_neighbors[elem->id()];
    for (unsigned int v = 0; v < elem->n_vertices(); ++v)
    {
      const auto & node = elem->node_ptr(v);
      for (const auto & neighbor_id : libmesh_map_find(node_to_elem_map, node->id()))
      {
        if (neighbor_id == elem->id())
          continue;
 
        const auto & neighbor = _mesh.elemPtr(neighbor_id);
        if (std::count(fill.begin(), fill.end(), neighbor) == 0)
          fill.emplace_back(neighbor);
      }
    }
  }
}

Referenced by init().

◆ claim()

void ClaimRays::claim ( )

Claim the Rays.

do_exchange sets whether or not an exchange is needed, i.e., if _rays still needs to be filled by objects on other processors

Definition at line 40 of file ClaimRays.C.

{
  if (_needs_init)
  {
    init();
    _needs_init = false;
  }
 
  preClaim();
 
  // Clear these as we're about to fill
  _local_rays.clear();
 
  // Grab the point locator
  _point_locator = PointLocatorBase::build(TREE_LOCAL_ELEMENTS, _mesh.getMesh());
  _point_locator->enable_out_of_mesh_mode();
 
  // Exchange: filter Rays into processors that _may_ claim them
  std::unordered_map<processor_id_type, std::vector<std::shared_ptr<Ray>>> rays_to_send;
  if (_do_exchange)
    for (processor_id_type pid = 0; pid < comm().size(); ++pid)
      if (_pid != pid)
      {
        const BoundingBox & pid_bbox = inflatedBoundingBox(pid);
        for (auto & ray : _rays)
          if (pid_bbox.contains_point(ray->currentPoint()))
            rays_to_send[pid].push_back(ray);
      }
 
  // Functor for possibly claiming a vector of Rays
  auto claim_functor =
      [&](processor_id_type /* pid */, const std::vector<std::shared_ptr<Ray>> & rays)
  {
    for (auto & ray : rays)
      possiblyClaim(ray);
  };
 
  // Send the relevant Rays to everyone and then attempt to claim the ones that we receive
  if (_do_exchange)
    Parallel::push_parallel_packed_range(comm(), rays_to_send, &_parallel_study, claim_functor);
 
  // Attempt to claim the locally generated rays in _rays
  claim_functor(_pid, _rays);
 
  // Verify the claiming if the study so desires
  if (_study.verifyRays())
    verifyClaiming();
 
  postClaim();
}

Referenced by RepeatableRayStudyBase::claimRaysInternal(), and TestPICRayStudy::generateRays().

◆ claimPoint()

const Elem * ClaimRays::claimPoint	(	const Point &	point,
		const RayID	id,
		const Elem *	elem
	)

private

Try to claim a spatial point.

Parameters

point	The point to claim
id	An ID associated with the point
elem	The local element to first consider for this processor's ownership

Returns: The element that contains the point if we claim the point, nullptr if we don't claim it

Definition at line 106 of file ClaimRays.C.

{
  if (elem)
  {
    // Looking for smallest (even ID Ray) or largest (odd ID Ray) elem id
    const bool smallest = id % 2 == 0;
 
    // Start with the element we found, as it is a valid candidate
    const Elem * extremum_elem = elem;
 
    // All point neighbors for this element
    mooseAssert(_elem_point_neighbors.count(elem->id()), "Not in point neighbor map");
    const auto & neighbors = _elem_point_neighbors.at(elem->id());
 
    // Find element that matches the extremum criteria
    for (const auto & neighbor : neighbors)
    {
      mooseAssert(neighbor->active(), "Inactive neighbor");
 
      if ((smallest && neighbor->id() < extremum_elem->id()) || // satisfies
          (!smallest && neighbor->id() > extremum_elem->id()))  // ...one of the id checks
        if (neighbor->contains_point(point))                    // and also contains the point
          extremum_elem = neighbor;
    }
 
    // Claim the object if we own the extremum elem
    if (extremum_elem->processor_id() == _pid)
    {
      mooseAssert(extremum_elem->active(), "Inactive element");
      return extremum_elem;
    }
  }
 
  return nullptr;
}

Referenced by possiblyClaim().

◆ getID()

virtual RayID ClaimRays::getID ( const std::shared_ptr< Ray > & ray ) const

inlineprotectedvirtual

Gets an ID associated with the Ray for claiming purposes.

Defaults to the Ray's ID.

To break ties in claiming (when multiple processors have elements that contain a point, say on an element's side on a processor boundary), we pick the smallest element ID when this ID is even and the largest element ID is odd. It is possible that the same Rays can be generated with different IDs, in which case the user may want to use a different ID for this process.

Definition at line 99 of file ClaimRays.h.

99{ return ray->id(); }

Referenced by possiblyClaim(), and verifyClaiming().

◆ inflatedBoundingBox()

const libMesh::BoundingBox & ClaimRays::inflatedBoundingBox ( const processor_id_type pid ) const

inlineprotected

Get the inflated bounding box for rank \pid.

Definition at line 104 of file ClaimRays.h.

  {
    return _inflated_bboxes[pid];
  }

Referenced by claim().

◆ init()

void ClaimRays::init ( )

protectedvirtual

Initialize the object.

Definition at line 166 of file ClaimRays.C.

{
  buildBoundingBoxes();
  buildPointNeighbors();
}

Referenced by claim().

◆ meshChanged()

void ClaimRays::meshChanged ( )

overridevirtual

Call on mesh changes to reinit the necessary data structures.

Reimplemented from MeshChangedInterface.

Definition at line 173 of file ClaimRays.C.

{
  _needs_init = true;
}

◆ possiblyClaim()

void ClaimRays::possiblyClaim ( const std::shared_ptr< Ray > & obj )

private

Possibly claim a Ray.

Definition at line 92 of file ClaimRays.C.

{
  prePossiblyClaimRay(ray);
 
  const auto elem =
      claimPoint(ray->currentPoint(), getID(ray), (*_point_locator)(ray->currentPoint()));
  if (elem)
  {
    _local_rays.push_back(ray);
    postClaimRay(_local_rays.back(), elem);
  }
}

Referenced by claim().

◆ postClaim()

virtual void ClaimRays::postClaim ( )

inlineprotectedvirtual

Entry point after claim()

Definition at line 78 of file ClaimRays.h.

78{}

Referenced by claim().

◆ postClaimRay()

void ClaimRays::postClaimRay	(	std::shared_ptr< Ray > &	ray,
		const Elem *	elem
	)

protectedvirtual

Entry point for acting on a Ray after it is claimed.

Definition at line 143 of file ClaimRays.C.

{
  mooseAssert(_mesh.queryElemPtr(elem->id()) == elem, "Mesh doesn't contain elem");
  mooseAssert(elem->active(), "Inactive element");
 
  // If the incoming side is set and is not incoming, or if it is not set at all, see
  // if we can find an incoming side that is valid.
  auto starting_incoming_side = RayTracingCommon::invalid_side;
  if (!(!ray->invalidCurrentIncomingSide() &&
        _study.elemSide(*elem, ray->currentIncomingSide()).contains_point(ray->currentPoint()) &&
        _study.sideIsIncoming(elem, ray->currentIncomingSide(), ray->direction(), /* tid = */ 0)))
    for (const auto s : elem->side_index_range())
      if (_study.elemSide(*elem, s).contains_point(ray->currentPoint()) &&
          _study.sideIsIncoming(elem, s, ray->direction(), /* tid = */ 0))
      {
        starting_incoming_side = s;
        break;
      }
 
  ray->setStart(ray->currentPoint(), elem, starting_incoming_side);
}

Referenced by possiblyClaim().

◆ preClaim()

virtual void ClaimRays::preClaim ( )

inlineprotectedvirtual

Entry point before claim()

Definition at line 74 of file ClaimRays.h.

74{}

Referenced by claim().

◆ prePossiblyClaimRay()

virtual void ClaimRays::prePossiblyClaimRay ( const std::shared_ptr< Ray > & )

inlineprotectedvirtual

Entry point before possibly claiming a Ray.

Definition at line 82 of file ClaimRays.h.

82{}

Referenced by possiblyClaim().

◆ verifyClaiming()

void ClaimRays::verifyClaiming ( )

private

Verifies that the claiming process succeeded.

That is, all Rays were claimed once and only once.

Definition at line 224 of file ClaimRays.C.

{
  // NOTE for all of the following: we use char here in place of bool.
  // This is because bool is not instantiated as a StandardType in
  // TIMPI due to the fun of std::vector<bool>
 
  // Map from Ray ID -> whether or not it was generated (false) or
  // claimed/possibly also generated (true)
  std::map<RayID, char> local_map;
  auto add_to_local_map =
      [this, &local_map](const std::vector<std::shared_ptr<Ray>> & rays, const bool claimed_rays)
  {
    for (const auto & ray : rays)
    {
      const auto id = getID(ray);
 
      // Try to insert into the map
      auto emplace_pair = local_map.emplace(id, claimed_rays);
 
      // If it already exists but has not been claimed yet, set it to being claimed
      if (!emplace_pair.second && claimed_rays)
      {
        mooseAssert(!emplace_pair.first->second,
                    "Ray was claimed more than once on a single processor");
        emplace_pair.first->second = true;
      }
    }
  };
 
  // Build the local_map
  add_to_local_map(_rays, false);
  add_to_local_map(_local_rays, true);
 
  // Build the structure to send the local generation/claiming information to rank 0
  std::map<processor_id_type, std::vector<std::pair<RayID, char>>> send_info;
  if (local_map.size())
    send_info.emplace(std::piecewise_construct,
                      std::forward_as_tuple(0),
                      std::forward_as_tuple(local_map.begin(), local_map.end()));
 
  // The mapping (filled on rank 0) from Ray ID -> (processor id, claiming status)
  std::map<RayID, std::vector<std::pair<processor_id_type, char>>> global_map;
 
  // Functor for receiving the generation/claiming information
  auto receive_functor = [&global_map](processor_id_type pid,
                                       const std::vector<std::pair<RayID, char>> & id_claimed_pairs)
  {
    for (const auto & id_claimed_pair : id_claimed_pairs)
      global_map[id_claimed_pair.first].emplace_back(pid, id_claimed_pair.second);
  };
 
  // Send claiming information to rank 0
  Parallel::push_parallel_vector_data(comm(), send_info, receive_functor);
 
  // Rank 0 will make sure everything looks good
  if (_pid == 0)
    for (const auto & id_pairs_pair : global_map)
    {
      const RayID id = id_pairs_pair.first;
      const std::vector<std::pair<processor_id_type, char>> & pid_claimed_pairs =
          id_pairs_pair.second;
 
      std::vector<processor_id_type> claimed_pids;
      for (const auto & pid_claimed_pair : pid_claimed_pairs)
        if (pid_claimed_pair.second)
          claimed_pids.push_back(pid_claimed_pair.first);
 
      if (claimed_pids.size() == 0)
        _study.mooseError("Failed to claim the Ray with ID ", id);
      mooseAssert(claimed_pids.size() == 1, "Ray was claimed on multiple processors");
    }
}

Definition at line 157 of file ClaimRays.h.

Referenced by claim(), and verifyClaiming().

◆ _study

RayTracingStudy& ClaimRays::_study

protected

The RayTracingStudy.

Definition at line 118 of file ClaimRays.h.

Referenced by claim(), postClaimRay(), and verifyClaiming().

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

ray_tracing/include/raytracing/ClaimRays.h
ray_tracing/src/raytracing/ClaimRays.C

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ClaimRays()

Member Function Documentation

◆ buildBoundingBoxes()

◆ buildPointNeighbors()

◆ claim()

◆ claimPoint()

◆ getID()

◆ inflatedBoundingBox()

◆ init()

◆ meshChanged()

◆ possiblyClaim()

◆ postClaim()

◆ postClaimRay()

◆ preClaim()

◆ prePossiblyClaimRay()

◆ verifyClaiming()

Member Data Documentation

◆ _do_exchange

◆ _elem_point_neighbors

◆ _inflated_bboxes

◆ _local_rays

◆ _mesh

◆ _needs_init

◆ _parallel_study

◆ _pid

◆ _point_locator

◆ _rays

◆ _study