Helper class that computes the intersection of a line segment defined by a point and a direction and a bounding box. More...

#include <BoundingBoxIntersectionHelper.h>

Public Member Functions
	BoundingBoxIntersectionHelper (const libMesh::BoundingBox &bbox, const unsigned int dim)
	Constructor.

libMesh::Point	intersection (const libMesh::Point &point, const libMesh::Point &direction) const

Private Attributes
libMesh::Parallel::Communicator	_comm
	Dummy communicator for the dummy mesh.

const std::unique_ptr< libMesh::Mesh >	_mesh
	Dummy mesh that contains a single element used for TraceRayTools intersection methods.

libMesh::Real	_hmax
	hmax for the dummy element

Detailed Description

Helper class that computes the intersection of a line segment defined by a point and a direction and a bounding box.

Definition at line 23 of file BoundingBoxIntersectionHelper.h.

Constructor & Destructor Documentation

◆ BoundingBoxIntersectionHelper()

BoundingBoxIntersectionHelper::BoundingBoxIntersectionHelper	(	const libMesh::BoundingBox &	bbox,
		const unsigned int	dim
	)

Constructor.

Parameters

bbox	The bounding box
dim	The dimension of the bounding box

Definition at line 20 of file BoundingBoxIntersectionHelper.C.

  : _comm(), _mesh(std::make_unique<Mesh>(_comm, dim))
{
  // Add the nodes that represent our bounding box
  _mesh->add_point(Point(bbox.min()(0), bbox.min()(1), bbox.min()(2)), 0, 0);
  _mesh->add_point(Point(bbox.max()(0), bbox.min()(1), bbox.min()(2)), 1, 0);
  if (dim > 1)
  {
    _mesh->add_point(Point(bbox.max()(0), bbox.max()(1), bbox.min()(2)), 2, 0);
    _mesh->add_point(Point(bbox.min()(0), bbox.max()(1), bbox.min()(2)), 3, 0);
 
    if (dim == 3)
    {
      _mesh->add_point(Point(bbox.min()(0), bbox.min()(1), bbox.max()(2)), 4, 0);
      _mesh->add_point(Point(bbox.max()(0), bbox.min()(1), bbox.max()(2)), 5, 0);
      _mesh->add_point(Point(bbox.max()(0), bbox.max()(1), bbox.max()(2)), 6, 0);
      _mesh->add_point(Point(bbox.min()(0), bbox.max()(1), bbox.max()(2)), 7, 0);
    }
  }
 
  // Build the element and set the nodes accordingly
  Elem * elem;
  if (dim == 1)
    elem = Elem::build(EDGE2).release();
  else if (dim == 2)
    elem = Elem::build(QUAD4).release();
  else
    elem = Elem::build(HEX8).release();
  elem = _mesh->add_elem(elem);
  elem->subdomain_id() = 0;
  elem->processor_id(0);
  elem->set_id() = 0;
  for (unsigned int n = 0; n < _mesh->n_nodes(); ++n)
    elem->set_node(n, _mesh->node_ptr(n));
 
  // All done with the mesh
  _mesh->skip_partitioning(true);
  _mesh->prepare_for_use();
 
  // This costs a little bit so why not cache it now
  _hmax = elem->hmax();
}

Member Function Documentation

◆ intersection()

Point BoundingBoxIntersectionHelper::intersection	(	const libMesh::Point &	point,
		const libMesh::Point &	direction
	)		const

Returns: The intersection of the segment defined by the point point and the direction direction. Will return RayTracingCommon::invalid_point if no intersection is found.

Definition at line 65 of file BoundingBoxIntersectionHelper.C.

{
  mooseAssert(std::abs(1.0 - direction.norm()) < TOLERANCE, "Unnormalized direction");
 
  const Elem * elem = _mesh->elem_ptr(0);
 
  // We're going to check all possible intersections and keep the one that's furthest away
  Point best_intersection_point = RayTracingCommon::invalid_point;
  Real best_intersection_distance = -std::numeric_limits<Real>::max();
 
  // For use in the intersection routines
  Point intersection_point;
  ElemExtrema intersected_extrema;
  Real intersection_distance;
  bool intersected;
 
  // Check intersection with sides
  for (const auto s : elem->side_index_range())
  {
    intersection_point = RayTracingCommon::invalid_point;
    intersected_extrema.invalidate();
 
    if (elem->dim() == 3) // 3D: Intersect HEX8
      intersected = TraceRayTools::sideIntersectedByLine<Hex8>(elem,
                                                               point,
                                                               direction,
                                                               s,
                                                               _hmax,
                                                               intersection_point,
                                                               intersection_distance,
                                                               intersected_extrema,
                                                               _hmax
#ifdef DEBUG_RAY_INTERSECTIONS
                                                               ,
                                                               false
#endif
      );
    else if (elem->dim() == 2) // 2D: Intersect QUAD4
    {
      intersected = TraceRayTools::sideIntersectedByLine<Quad4>(elem,
                                                                point,
                                                                direction,
                                                                s,
                                                                _hmax,
                                                                intersection_point,
                                                                intersection_distance,
                                                                intersected_extrema,
                                                                _hmax
#ifdef DEBUG_RAY_INTERSECTIONS
                                                                ,
                                                                false
#endif
      );
    }
    else // 1D: see if side point is between point and end far away
    {
      // Dummy end point outside of the element
      const Point dummy_end = point + 1.01 * direction * _hmax;
 
      intersected = TraceRayTools::isWithinSegment(point, dummy_end, elem->point(s));
      if (intersected)
      {
        intersection_distance = (elem->point(s) - point).norm();
        intersection_point = elem->point(s);
      }
    }
 
    if (intersected && intersection_distance > best_intersection_distance)
    {
      best_intersection_distance = intersection_distance;
      best_intersection_point = intersection_point;
    }
  }
 
  return best_intersection_point;
}