TraceRayTools Namespace Reference

Enumerations
enum	SegmentVertices { SEGMENT_VERTEX_0 = 0 , SEGMENT_VERTEX_1 = 1 , SEGMENT_VERTEX_NONE = 7 }
	Enum for the possible vertices on a segment used in lineLineIntersect2D() More...

Functions
bool	lineLineIntersect2D (const Point &start, const Point &direction, const Real length, const Point &v0, const Point &v1, Point &intersection_point, Real &intersection_distance, SegmentVertices &segment_vertex #ifdef DEBUG_RAY_INTERSECTIONS, const bool debug #endif)
	Checks for the intersection of the line u0 -> u1 with the line v0 -> v1, where u0 = start and u1 = start + direction * length.
bool	isWithinSegment (const Point &segment1, const Point &segment2, const Point &point, const Real tolerance=TRACE_TOLERANCE)
	Checks whether or not a point is within a line segment.
bool	isWithinSegment (const Point &segment1, const Point &segment2, const Real segment_length, const Point &point, const Real tolerance=TRACE_TOLERANCE)
	Checks whether or not a point is within a line segment.
void	findPointNeighbors (const Elem *const elem, const Point &point, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &neighbor_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &untested_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &next_untested_set, std::vector< const Elem * > active_neighbor_children, std::vector< NeighborInfo > &info)
	Rewrite of the find_point_neighbors function in libMesh, instead using a statically allocated set: returns the active point neighbors at p within elem.
void	findNodeNeighbors (const Elem *const elem, const Node *const node, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &neighbor_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &untested_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &next_untested_set, std::vector< const Elem * > active_neighbor_children, std::vector< NeighborInfo > &info)
void	findEdgeNeighbors (const Elem *const elem, const Node *const node1, const Node *const node2, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &neighbor_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &untested_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &next_untested_set, std::vector< const Elem * > active_neighbor_children, std::vector< NeighborInfo > &info)
template<typename KeepFunctor >
void	findNeighbors (const Elem *const elem, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &neighbor_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &untested_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &next_untested_set, std::vector< const Elem * > active_neighbor_children, KeepFunctor &keep_functor)
	More generalized form of the find_point_neighbors function in libMesh.
template<typename T >
bool	findEdgeNeighborsWithinEdgeInternal (const Elem *const candidate, const Elem *const elem, const Node *const vertex1, const Node *const vertex2, const Real edge_length, std::vector< NeighborInfo > &info)
const Elem *	childContainingPointOnSide (const Elem *elem, const Point &point, const unsigned short side)
	Find the child of an elem that contains a point on a specified side of elem.
const Elem *	getActiveNeighbor (const Elem *elem, const unsigned short side, const Point &point)
	Get the active neighbor on side of elem that contains point.
bool	intersectTriangle (const Point &start, const Point &direction, const Elem *const elem, const unsigned short v0, const unsigned short v1, const unsigned short v2, Real &intersection_distance, ElemExtrema &intersected_extrema, const Real hmax #ifdef DEBUG_RAY_INTERSECTIONS, const bool debug #endif)
	Checks for the intersection of a ray and a triangular face.
bool	intersectQuad (const Point &start, const Point &direction, const Elem *const elem, const unsigned short v00, const unsigned short v10, const unsigned short v11, const unsigned short v01, Real &intersection_distance, ElemExtrema &intersected_extrema, const Real hmax #ifdef DEBUG_RAY_INTERSECTIONS, const bool debug #endif)
	Checks for the intersection of a ray and a quadrilateral, numbered as such:
template<typename T >
std::enable_if< std::is_base_of< libMesh::Face, T >::value, bool >::type	sideIntersectedByLine (const Elem *elem, const Point &start_point, const Point &direction, const unsigned short side, const Real max_length, Point &intersection_point, Real &intersection_distance, ElemExtrema &intersected_extrema, const Real #ifdef DEBUG_RAY_INTERSECTIONS, const bool debug #endif)
	SFINAE typed object for checking the intersection of a line segment with the face of a Face typed element, i.e., the intersection with the edge of a 2D element.
template<typename T >
std::enable_if< std::is_base_of< Hex, T >::value, bool >::type	sideIntersectedByLine (const Elem *elem, const Point &start_point, const Point &direction, const unsigned short side, const Real, Point &intersection_point, Real &intersection_distance, ElemExtrema &intersected_extrema, const Real hmax #ifdef DEBUG_RAY_INTERSECTIONS, const bool debug #endif)
	SFINAE typed object for checking the intersection of a line segment with the face of a Hex typed element.
template<typename T >
std::enable_if< std::is_base_of< Tet, T >::value, bool >::type	sideIntersectedByLine (const Elem *elem, const Point &start_point, const Point &direction, const unsigned short side, const Real, Point &intersection_point, Real &intersection_distance, ElemExtrema &intersected_extrema, const Real hmax #ifdef DEBUG_RAY_INTERSECTIONS, const bool debug #endif)
	SFINAE typed object for checking the intersection of a line segment with the face of a Tet typed element.
template<typename T >
std::enable_if< std::is_base_of< libMesh::Pyramid, T >::value, bool >::type	sideIntersectedByLine (const Elem *elem, const Point &start_point, const Point &direction, const unsigned short side, const Real, Point &intersection_point, Real &intersection_distance, ElemExtrema &intersected_extrema, const Real hmax #ifdef DEBUG_RAY_INTERSECTIONS, const bool debug #endif)
	SFINAE typed object for checking the intersection of a line segment with the face of a Pyramid typed element.
template<typename T >
std::enable_if< std::is_base_of< libMesh::Prism, T >::value, bool >::type	sideIntersectedByLine (const Elem *elem, const Point &start_point, const Point &direction, const unsigned short side, const Real, Point &intersection_point, Real &intersection_distance, ElemExtrema &intersected_extrema, const Real hmax #ifdef DEBUG_RAY_INTERSECTIONS, const bool debug #endif)
	SFINAE typed object for checking the intersection of a line segment with the face of a Prism typed element.
bool	isTraceableElem (const Elem *elem)
bool	isAdaptivityTraceableElem (const Elem *elem)
unsigned short	atVertex (const Elem *elem, const Point &point)
	Determines if a point is at a vertex of an element.
unsigned short	atVertexOnSide (const Elem *elem, const Point &point, const unsigned short side)
	Determines if a point is at a vertex on the side of en element.
template<typename T >
std::enable_if<!std::is_base_of< libMesh::Pyramid, T >::value &&!std::is_base_of< libMesh::Prism, T >::value, unsignedshort >::type	nodesPerSide (const unsigned short)
	Returns the number of nodes on a side for an Elem that is not a Pyramid or Prism.
template<typename T >
std::enable_if< std::is_base_of< Pyramid, T >::value, unsignedshort >::type	nodesPerSide (const unsigned short side)
	Returns the number of nodes on a side on a Pyramid elem.
template<typename T >
std::enable_if< std::is_base_of< libMesh::Prism, T >::value, unsignedshort >::type	nodesPerSide (const unsigned short side)
	Returns the number of nodes on a side on a Prism elem.
template<typename T >
std::enable_if<!std::is_base_of< Edge, T >::value, unsignedshort >::type	atVertexOnSideTempl (const Elem *elem, const Point &point, const unsigned short side)
	Determines if a point is at a vertex on the side of an element.
template<typename T >
std::enable_if< std::is_base_of< Edge, T >::value, unsignedshort >::type	atVertexOnSideTempl (const Elem *elem, const Point &point, const unsigned short side)
	Determines if a point is at a vertex on the side of an element.
template<typename T >
bool	withinEdgeTempl (const Elem *elem, const Point &point, ElemExtrema &extrema, const Real tolerance=TRACE_TOLERANCE)
	Determines if a point is within edge on an element.
bool	withinEdge (const Elem *elem, const Point &point, ElemExtrema &extrema, const Real tolerance=TRACE_TOLERANCE)
	Determines if a point is within an edge on an element.
bool	withinEdgeOnSide (const Elem *const elem, const Point &point, const unsigned short side, ElemExtrema &extrema)
	Determines if a point is within an edge on the side of an element.
bool	withinExtremaOnSide (const Elem *const elem, const Point &point, const unsigned short side, const unsigned int dim, ElemExtrema &extrema)
	Determines if a point is within an Elem's extrema (at vertex/within edge) on a side.
template<typename T >
std::enable_if< std::is_base_of< libMesh::Cell, T >::value, bool >::type	withinEdgeOnSideTempl (const Elem *const elem, const Point &point, const unsigned short side, ElemExtrema &extrema)
	Determines if a point is within an edge on the side of an element.
template<typename T >
std::enable_if<!std::is_base_of< libMesh::Cell, T >::value, bool >::type	withinEdgeOnSideTempl (const Elem *const, const Point &, const unsigned short, ElemExtrema &)
	Determines if a point is within an edge on the side of an element.
bool	onBoundingBoxBoundary (const BoundingBox &bbox, const Point &point, const unsigned int dim, const Real tolerance)
	Whether or not point is on the boundary (min/max) of bbox.
bool	lineLineIntersect2D (const Point &start, const Point &direction, const Real length, const Point &v0, const Point &v1, Point &intersection_point, Real &intersection_distance, SegmentVertices &segment_vertex #ifdef DEBUG_RAY_INTERSECTIONS, const bool debug #endif)
void	findPointNeighbors (const Elem *const elem, const Point &point, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &neighbor_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &untested_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &next_untested_set, std::vector< const Elem * > active_neighbor_children, std::vector< NeighborInfo > &info)
void	findNodeNeighbors (const Elem *const elem, const Node *const node, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &neighbor_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &untested_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &next_untested_set, std::vector< const Elem * > active_neighbor_children, std::vector< NeighborInfo > &info)
void	findEdgeNeighbors (const Elem *const elem, const Node *const node1, const Node *const node2, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &neighbor_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &untested_set, MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &next_untested_set, std::vector< const Elem * > active_neighbor_children, std::vector< NeighborInfo > &info)
const Elem *	childContainingPointOnSide (const Elem *elem, const Point &point, const unsigned short side)
const Elem *	getActiveNeighbor (const Elem *elem, const unsigned short side, const Point &point)
bool	intersectTriangle (const Point &start, const Point &direction, const Elem *const elem, const unsigned short v0, const unsigned short v1, const unsigned short v2, Real &intersection_distance, ElemExtrema &intersected_extrema, const Real hmax #ifdef DEBUG_RAY_INTERSECTIONS, const bool debug #endif)
bool	intersectQuad (const Point &start, const Point &direction, const Elem *const elem, const unsigned short v00, const unsigned short v10, const unsigned short v11, const unsigned short v01, Real &intersection_distance, ElemExtrema &intersected_extrema, const Real hmax #ifdef DEBUG_RAY_INTERSECTIONS, const bool debug #endif)
bool	isTraceableElem (const Elem *elem)
bool	isAdaptivityTraceableElem (const Elem *elem)
unsigned short	atVertex (const Elem *elem, const Point &point)
template<typename T >
bool	withinEdgeTempl (const Elem *elem, const Point &point, ElemExtrema &extrema, const Real tolerance)
bool	withinEdge (const Elem *elem, const Point &point, ElemExtrema &extrema, const Real tolerance)
unsigned short	atVertexOnSide (const Elem *elem, const Point &point, const unsigned short side)
template<typename T >
std::enable_if<!std::is_base_of< Edge, T >::value, unsignedshort >::type	atVertexOnSideTempl (const Elem *elem, const Point &point, const unsigned short side)
template<typename T >
std::enable_if< std::is_base_of< Edge, T >::value, unsignedshort >::type	atVertexOnSideTempl (const Elem *elem, const Point &point, const unsigned short side)
bool	withinEdgeOnSide (const Elem *const elem, const Point &point, const unsigned short side, ElemExtrema &extrema)
template<typename T >
std::enable_if< std::is_base_of< Cell, T >::value, bool >::type	withinEdgeOnSideTempl (const Elem *const elem, const Point &point, const unsigned short side, ElemExtrema &extrema)
bool	withinExtremaOnSide (const Elem *const elem, const Point &point, const unsigned short side, const unsigned int dim, ElemExtrema &extrema)
bool	isWithinSegment (const Point &segment1, const Point &segment2, const Point &point, const Real tolerance)
bool	isWithinSegment (const Point &segment1, const Point &segment2, const Real segment_length, const Point &point, const Real tolerance)
bool	onBoundingBoxBoundary (const BoundingBox &bbox, const Point &point, const unsigned int dim, const Real tolerance)

Variables
const std::set< int >	TRACEABLE_ELEMTYPES
	The element types that are traceable.
const std::set< int >	ADAPTIVITY_TRACEABLE_ELEMTYPES = {QUAD4, HEX8, TRI3, TET4, EDGE2}
	The element types that are traceable with adaptivity.
const Real	TRACE_TOLERANCE = 1e-8
	The standard tolerance to use in tracing.
const Real	LOOSE_TRACE_TOLERANCE = 1e-5
	Looser tolerance for use in error checking in difficult situations.
const int	INVALID_INT = std::numeric_limits<int>::max()
	Value for an invalid integer.

Enumeration Type Documentation

SegmentVertices

enum TraceRayTools::SegmentVertices

Enum for the possible vertices on a segment used in lineLineIntersect2D()

Enumerator
SEGMENT_VERTEX_0
SEGMENT_VERTEX_1
SEGMENT_VERTEX_NONE

Definition at line 58 of file TraceRayTools.h.

{
  SEGMENT_VERTEX_0 = 0,
  SEGMENT_VERTEX_1 = 1,
  SEGMENT_VERTEX_NONE = 7
};

Function Documentation

atVertex() [1/2]

unsigned short TraceRayTools::atVertex	(	const Elem *	elem,
		const Point &	point
	)

Determines if a point is at a vertex of an element.

Parameters

elem	The element
point	The point

Returns

The local vertex ID the point is at, if any (invalid_point otherwise)

Referenced by TraceRay::applyOnInternalBoundary(), TEST(), and TraceRay::trace().

atVertex() [2/2]

unsigned short TraceRayTools::atVertex	(	const Elem *	elem,
		const Point &	point
	)

Definition at line 563 of file TraceRayTools.C.

{
  for (unsigned int v = 0; v < elem->n_vertices(); ++v)
    if (elem->point(v).absolute_fuzzy_equals(point, TRACE_TOLERANCE))
      return v;
 
  return RayTracingCommon::invalid_vertex;
}

atVertexOnSide() [1/2]

unsigned short TraceRayTools::atVertexOnSide	(	const Elem *	elem,
		const Point &	point,
		const unsigned short	side
	)

Determines if a point is at a vertex on the side of en element.

Parameters

elem	The element
point	The point
side	The side

Returns

The local vertex ID the point is at, if any (invalid_point otherwise)

Referenced by TEST(), TraceRay::trace(), and withinExtremaOnSide().

atVertexOnSide() [2/2]

unsigned short TraceRayTools::atVertexOnSide	(	const Elem *	elem,
		const Point &	point,
		const unsigned short	side
	)

Definition at line 628 of file TraceRayTools.C.

{
  switch (elem->type())
  {
    case HEX8:
    case HEX20:
    case HEX27:
      return atVertexOnSideTempl<Hex8>(elem, point, side);
    case QUAD4:
    case QUAD8:
    case QUAD9:
      return atVertexOnSideTempl<Quad4>(elem, point, side);
    case TRI3:
    case TRI6:
    case TRI7:
      return atVertexOnSideTempl<Tri3>(elem, point, side);
    case TET4:
    case TET10:
    case TET14:
      return atVertexOnSideTempl<Tet4>(elem, point, side);
    case PYRAMID5:
    case PYRAMID13:
    case PYRAMID14:
      return atVertexOnSideTempl<Pyramid5>(elem, point, side);
    case PRISM6:
    case PRISM15:
    case PRISM18:
      return atVertexOnSideTempl<Prism6>(elem, point, side);
    case EDGE2:
    case EDGE3:
    case EDGE4:
      return atVertexOnSideTempl<Edge2>(elem, point, side);
    default:
      mooseError("Element type ",
                 Utility::enum_to_string(elem->type()),
                 " not supported in TraceRayTools::atVertexOnSide()");
  }
 
  return RayTracingCommon::invalid_vertex;
}

atVertexOnSideTempl() [1/4]

template<typename T >

std::enable_if<!std::is_base_of< Edge, T >::value, unsignedshort >::type TraceRayTools::atVertexOnSideTempl	(	const Elem *	elem,
		const Point &	point,
		const unsigned short	side
	)

Determines if a point is at a vertex on the side of an element.

SFINAE here makes this method available for only 2D/3D elem types (not edges)

The template argument should be the first order type of the elem - this is used to access the vertex mappings for said element without calling any virtuals

Parameters

elem	The element
point	The point
side	The side

Returns

The local vertex ID the point is at, if any (invalid_point otherwise)

atVertexOnSideTempl() [2/4]

template<typename T >

std::enable_if< std::is_base_of< Edge, T >::value, unsignedshort >::type TraceRayTools::atVertexOnSideTempl	(	const Elem *	elem,
		const Point &	point,
		const unsigned short	side
	)

Determines if a point is at a vertex on the side of an element.

SFINAE here makes this method available for only 1D elem types (edges)

The template argument should be the first order type of the elem - this is used to access the vertex mappings for said element without calling any virtuals

Parameters

elem	The element
point	The point
side	The side

Returns

The local vertex ID the point is at, if any (invalid_point otherwise)

atVertexOnSideTempl() [3/4]

template<typename T >

std::enable_if<!std::is_base_of< Edge, T >::value, unsignedshort >::type TraceRayTools::atVertexOnSideTempl	(	const Elem *	elem,
		const Point &	point,
		const unsigned short	side
	)

Definition at line 671 of file TraceRayTools.C.

{
  mooseAssert(side < elem->n_sides(), "Invalid side");
  mooseAssert(elem->side_ptr(side)->close_to_point(point, LOOSE_TRACE_TOLERANCE),
              "Side does not contain point");
 
  for (int i = 0; i < nodesPerSide<T>(side); ++i)
    if (elem->point(T::side_nodes_map[side][i]).absolute_fuzzy_equals(point, TRACE_TOLERANCE))
      return T::side_nodes_map[side][i];
 
  return RayTracingCommon::invalid_vertex;
}

atVertexOnSideTempl() [4/4]

template<typename T >

std::enable_if< std::is_base_of< Edge, T >::value, unsignedshort >::type TraceRayTools::atVertexOnSideTempl	(	const Elem *	elem,
		const Point &	point,
		const unsigned short	side
	)

Definition at line 686 of file TraceRayTools.C.

{
  mooseAssert(side < elem->n_sides(), "Invalid side");
  mooseAssert(elem->side_ptr(side)->close_to_point(point, LOOSE_TRACE_TOLERANCE),
              "Side does not contain point");
 
  if (elem->point(side).absolute_fuzzy_equals(point, TRACE_TOLERANCE))
    return side;
 
  return RayTracingCommon::invalid_vertex;
}

childContainingPointOnSide() [1/2]

const Elem * TraceRayTools::childContainingPointOnSide	(	const Elem *	elem,
		const Point &	point,
		const unsigned short	side
	)

Find the child of an elem that contains a point on a specified side of elem.

Parameters

elem	The parent element
point	The point that is in elem
side	The side that point is on in elem

Returns

The child that contains the point

Referenced by childContainingPointOnSide(), and getActiveNeighbor().

childContainingPointOnSide() [2/2]

const Elem * TraceRayTools::childContainingPointOnSide	(	const Elem *	elem,
		const Point &	point,
		const unsigned short	side
	)

Definition at line 329 of file TraceRayTools.C.

{
  mooseAssert(!elem->active(), "Should be inactive");
  mooseAssert(elem->side_ptr(side)->contains_point(point), "Side should contain point");
 
  for (unsigned int c = 0; c < elem->n_children(); ++c)
  {
    if (!elem->is_child_on_side(c, side))
      continue;
 
    const auto child = elem->child_ptr(c);
    // Experience shows that we need to loosen this tolerance just a little
    // The default is libMesh::TOLERANCE = 1e-6
    if (child->close_to_point(point, 5.e-5))
    {
      if (child->active())
        return child;
      else
        return childContainingPointOnSide(child, point, side);
    }
  }
 
  mooseError("Failed to find child containing point on side");
}

findEdgeNeighbors() [1/2]

void TraceRayTools::findEdgeNeighbors	(	const Elem *const	elem,
		const Node *const	node1,
		const Node *const	node2,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	neighbor_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	untested_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	next_untested_set,
		std::vector< const Elem * >	active_neighbor_children,
		std::vector< NeighborInfo > &	info
	)

Referenced by TraceRay::getEdgeNeighbors().

findEdgeNeighbors() [2/2]

void TraceRayTools::findEdgeNeighbors	(	const Elem *const	elem,
		const Node *const	node1,
		const Node *const	node2,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	neighbor_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	untested_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	next_untested_set,
		std::vector< const Elem * >	active_neighbor_children,
		std::vector< NeighborInfo > &	info
	)

Definition at line 254 of file TraceRayTools.C.

{
  mooseAssert(elem->get_node_index(node1) != libMesh::invalid_uint, "Doesn't contain node");
  mooseAssert(elem->get_node_index(node2) != libMesh::invalid_uint, "Doesn't contain node");
 
  info.clear();
 
  // The length for this edge used for checking if a point is contained within said edge
  const Real edge_length = ((Point)*node1 - (Point)*node2).norm();
 
  // Lambda that returns whether or not a candidate element contains an edge that is within the
  // target edge defined by node1 and node2. Also fills "info" if a match is found
  auto within_edge = [&elem, &node1, &node2, &edge_length, &info](const Elem * const candidate)
  {
    switch (candidate->type())
    {
      case HEX8:
        return findEdgeNeighborsWithinEdgeInternal<Hex8>(
            candidate, elem, node1, node2, edge_length, info);
      case TET4:
        return findEdgeNeighborsWithinEdgeInternal<Tet4>(
            candidate, elem, node1, node2, edge_length, info);
      case PYRAMID5:
        return findEdgeNeighborsWithinEdgeInternal<Pyramid5>(
            candidate, elem, node1, node2, edge_length, info);
      case PRISM6:
        return findEdgeNeighborsWithinEdgeInternal<Prism6>(
            candidate, elem, node1, node2, edge_length, info);
      case HEX20:
        return findEdgeNeighborsWithinEdgeInternal<Hex20>(
            candidate, elem, node1, node2, edge_length, info);
      case HEX27:
        return findEdgeNeighborsWithinEdgeInternal<Hex27>(
            candidate, elem, node1, node2, edge_length, info);
      case TET10:
        return findEdgeNeighborsWithinEdgeInternal<Tet10>(
            candidate, elem, node1, node2, edge_length, info);
      case TET14:
        return findEdgeNeighborsWithinEdgeInternal<Tet14>(
            candidate, elem, node1, node2, edge_length, info);
      case PYRAMID13:
        return findEdgeNeighborsWithinEdgeInternal<Pyramid13>(
            candidate, elem, node1, node2, edge_length, info);
      case PYRAMID14:
        return findEdgeNeighborsWithinEdgeInternal<Pyramid14>(
            candidate, elem, node1, node2, edge_length, info);
      case PRISM15:
        return findEdgeNeighborsWithinEdgeInternal<Prism15>(
            candidate, elem, node1, node2, edge_length, info);
      case PRISM18:
        return findEdgeNeighborsWithinEdgeInternal<Prism18>(
            candidate, elem, node1, node2, edge_length, info);
      default:
        mooseError("Element type ",
                   Utility::enum_to_string(candidate->type()),
                   " not supported in TraceRayTools::findEdgeNeighbors()");
    }
  };
 
  // Fill info for the element that was passed in
  within_edge(elem);
 
  findNeighbors(
      elem, neighbor_set, untested_set, next_untested_set, active_neighbor_children, within_edge);
}

findEdgeNeighborsWithinEdgeInternal()

template<typename T >

bool TraceRayTools::findEdgeNeighborsWithinEdgeInternal	(	const Elem *const	candidate,
		const Elem *const	elem,
		const Node *const	vertex1,
		const Node *const	vertex2,
		const Real	edge_length,
		std::vector< NeighborInfo > &	info
	)

Definition at line 234 of file TraceRayTools.h.

{
  // If we have the type already: use it so we can avoid all of the virtual
  // calls that we would be making on Elem
  mooseAssert(dynamic_cast<const T *>(candidate), "Incorrect elem type");
  const T * const T_candidate = static_cast<const T *>(candidate);
 
  // Local index of our two vertices of interest (if any)
  auto v1 = T_candidate->get_node_index(vertex1);
  auto v2 = T_candidate->get_node_index(vertex2);
  // Whether or not we have said vertices
  const bool has_v1 = v1 != invalid_uint;
  const bool has_v2 = v2 != invalid_uint;
 
  // If the candidate has both vertices, it shares the complete edge
  if (has_v1 && has_v2)
  {
    // Add the sides that contain said edge
    for (MooseIndex(T::num_edges) e = 0; e < T::num_edges; ++e)
      if (T_candidate->is_node_on_edge(v1, e) && T_candidate->is_node_on_edge(v2, e))
      {
        std::vector<unsigned short> sides(2);
        sides[0] = T::edge_sides_map[e][0];
        sides[1] = T::edge_sides_map[e][1];
        info.emplace_back(candidate, std::move(sides), 0, 1);
        return true;
      }
 
    mooseError("Failed to find a side that the vertices are on");
  }
 
  const auto n_vertices = T_candidate->n_vertices();
 
  // If we only have one of the vertices, we can still be contained within the edge if we have
  // another vertex that is within the edge
  if (has_v1 || has_v2)
  {
    // Local index of the vertex that the candidate and the target edge have in common
    const auto common_v = has_v1 ? v1 : v2;
 
    // See if another vertex that isn't the common node is contained
    MooseIndex(n_vertices) other_v;
    for (other_v = 0; other_v < n_vertices; ++other_v)
      if (other_v != common_v &&
          isWithinSegment(*vertex1, *vertex2, edge_length, T_candidate->point(other_v)))
        break;
 
    // If we have the common vertex and another vertex within the target edge, use the sides
    // that contain both of those vertices
    if (other_v != n_vertices)
    {
      for (MooseIndex(T::num_edges) e = 0; e < T::num_edges; ++e)
        if (T_candidate->is_node_on_edge(common_v, e) && T_candidate->is_node_on_edge(other_v, e))
        {
          std::vector<unsigned short> sides(2);
          sides[0] = T::edge_sides_map[e][0];
          sides[1] = T::edge_sides_map[e][1];
 
          info.emplace_back(
              candidate,
              std::move(sides),
              has_v1 ? 0 : (T_candidate->point(other_v) - (Point)*vertex1).norm() / edge_length,
              has_v1 ? (T_candidate->point(other_v) - (Point)*vertex1).norm() / edge_length : 1);
          return true;
        }
      mooseError("Failed to find a side that the vertices are on");
    }
    else if (T_candidate->level() < elem->level())
    {
      for (MooseIndex(T::num_edges) e = 0; e < T::num_edges; ++e)
        if (T_candidate->is_node_on_edge(common_v, e) &&
            isWithinSegment(T_candidate->point(T::edge_nodes_map[e][0]),
                            T_candidate->point(T::edge_nodes_map[e][1]),
                            has_v1 ? *vertex2 : *vertex1))
        {
          other_v = T::edge_nodes_map[e][0] == common_v ? T::edge_nodes_map[e][1]
                                                        : T::edge_nodes_map[e][0];
          std::vector<unsigned short> sides(2);
          sides[0] = T::edge_sides_map[e][0];
          sides[1] = T::edge_sides_map[e][1];
 
          info.emplace_back(
              candidate,
              std::move(sides),
              has_v1 ? 0 : (T_candidate->point(other_v) - (Point)*vertex1).norm() / edge_length,
              has_v1 ? (T_candidate->point(other_v) - (Point)*vertex1).norm() / edge_length : 1);
          return true;
        }
 
      return false;
    }
  }
  // When the candidate level is less, one of our vertices could be in a candidate's face and the
  // other could be within one of the candidate's edges
  else if (T_candidate->level() < elem->level())
  {
    auto v1_edge = RayTracingCommon::invalid_edge;
    auto v2_edge = RayTracingCommon::invalid_edge;
 
    // See if any of the edges contain one of the vertices
    for (MooseIndex(T::num_edges) e = 0; e < T::num_edges; ++e)
    {
      if (v1_edge == RayTracingCommon::invalid_edge &&
          isWithinSegment(T_candidate->point(T::edge_nodes_map[e][0]),
                          T_candidate->point(T::edge_nodes_map[e][1]),
                          *vertex1))
        v1_edge = e;
      if (v2_edge == RayTracingCommon::invalid_edge &&
          isWithinSegment(T_candidate->point(T::edge_nodes_map[e][0]),
                          T_candidate->point(T::edge_nodes_map[e][1]),
                          *vertex2))
        v2_edge = e;
    }
 
    const auto v1_within = v1_edge != RayTracingCommon::invalid_edge;
    const auto v2_within = v2_edge != RayTracingCommon::invalid_edge;
 
    if (v1_within && v2_within)
    {
      mooseAssert(v1_edge == v2_edge, "Vertices should be contained in same edge");
 
      std::vector<unsigned short> sides(2);
      sides[0] = T::edge_sides_map[v1_edge][0];
      sides[1] = T::edge_sides_map[v1_edge][1];
      info.emplace_back(candidate, std::move(sides), 0, 1);
      return true;
    }
    else if (v1_within || v2_within)
    {
      const auto in_edge = v1_within ? v1_edge : v2_edge;
      const Point & check_point = v1_within ? *vertex2 : *vertex1;
 
      std::vector<unsigned short> sides(1);
      Real lower_bound = 0;
      Real upper_bound = 1;
 
      if (candidate->side_ptr(T::edge_sides_map[in_edge][0])->contains_point(check_point))
        sides[0] = T::edge_sides_map[in_edge][0];
      else if (candidate->side_ptr(T::edge_sides_map[in_edge][1])->contains_point(check_point))
        sides[0] = T::edge_sides_map[in_edge][1];
      else
      {
        const Real point_bound = v1_within ? 0 : 1;
        lower_bound = point_bound;
        upper_bound = point_bound;
        sides[0] = T::edge_sides_map[in_edge][0];
        sides.push_back(T::edge_sides_map[in_edge][1]);
      }
 
      info.emplace_back(candidate, std::move(sides), lower_bound, upper_bound);
      return true;
    }
 
    return false;
  }
  // If we have neither of the vertices, and the candidate's edge can't fully contain [vertex1,
  // vertex2], check for other vertices that are contained within the edge
  else
  {
    for (v1 = 0; v1 < n_vertices; ++v1)
      if (isWithinSegment(*vertex1, *vertex2, edge_length, candidate->point(v1)))
      {
        for (v2 = v1 + 1; v2 < n_vertices; ++v2)
          if (isWithinSegment(*vertex1, *vertex2, edge_length, candidate->point(v2)))
            break;
        break;
      }
 
    // No vertices are contained within the edge
    if (v1 == n_vertices)
      return false;
 
    // Only one vertex contained: add the sides associated with that vertex
    if (v2 >= n_vertices)
    {
      std::vector<unsigned short> sides;
      sides.reserve(2);
 
      for (MooseIndex(T::num_sides) s = 0; s < T::num_sides; ++s)
        if (T_candidate->is_node_on_side(v1, s))
          sides.push_back(s);
 
      if (sides.empty())
        mooseError("Failed to find sides that the vertex is on");
 
      // Bounds are the same because we only touch at a point
      const auto bound = (T_candidate->point(v1) - (Point)*vertex1).norm() / edge_length;
      info.emplace_back(candidate, std::move(sides), bound, bound);
      return true;
    }
    // Two vertices contained: find the sides that contain both vertices
    else
    {
      for (MooseIndex(T::num_edges) e = 0; e < T::num_edges; ++e)
        if (T_candidate->is_node_on_edge(v1, e) && T_candidate->is_node_on_edge(v2, e))
        {
          auto lower_bound = (T_candidate->point(v1) - (Point)*vertex1).norm() / edge_length;
          auto upper_bound = (T_candidate->point(v2) - (Point)*vertex1).norm() / edge_length;
          if (lower_bound > upper_bound)
          {
            const auto temp = lower_bound;
            lower_bound = upper_bound;
            upper_bound = temp;
          }
 
          std::vector<unsigned short> sides(2);
          sides[0] = T::edge_sides_map[e][0];
          sides[1] = T::edge_sides_map[e][1];
          info.emplace_back(candidate, std::move(sides), lower_bound, upper_bound);
          return true;
        }
 
      mooseError("Failed to find sides that the vertices are on");
    }
  }
 
  return false;
}

findNeighbors()

template<typename KeepFunctor >

void TraceRayTools::findNeighbors	(	const Elem *const	elem,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	neighbor_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	untested_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	next_untested_set,
		std::vector< const Elem * >	active_neighbor_children,
		KeepFunctor &	keep_functor
	)

More generalized form of the find_point_neighbors function in libMesh.

Instead uses a statically allocated set and accepts a functor for the rejection/acceptance of an element.

Returns the active neighbors that fit the criteria of keep_functor. Does not the return the current element (elem)

Parameters

elem	The element for which we are searching for the neighbors
neighbor_set	The set to fill the neighbors into
untested_set	Set for internal use
next_untested_set	Set for internal use
active_neighbor_children	Vector to use in the search
keep_functor	The functor that is used to accept or reject an element

Definition at line 179 of file TraceRayTools.h.

{
  mooseAssert(elem->active(), "Inactive element");
 
  neighbor_set.clear();
  untested_set.clear();
  next_untested_set.clear();
 
  untested_set.insert(elem);
 
  while (!untested_set.empty())
  {
    // Loop over all the elements in the patch that haven't already been tested
    for (const Elem * const test_elem : untested_set)
      for (const auto * const current_neighbor : test_elem->neighbor_ptr_range())
        if (current_neighbor && current_neighbor != remote_elem &&
            current_neighbor != elem) // we have a real neighbor on elem side
        {
          if (current_neighbor->active()) // ... if it is active
          {
            if (!neighbor_set.contains(current_neighbor) && keep_functor(current_neighbor))
            {
              next_untested_set.insert(current_neighbor);
              neighbor_set.insert(current_neighbor);
            }
          }
#ifdef LIBMESH_ENABLE_AMR
          else // ... the neighbor is *not* active,
          {    // ... so add *all* neighboring
               // active children that touch p
            current_neighbor->active_family_tree_by_neighbor(active_neighbor_children, test_elem);
 
            for (const Elem * current_child : active_neighbor_children)
              if (!neighbor_set.contains(current_child) && keep_functor(current_child) &&
                  current_child != elem)
              {
                next_untested_set.insert(current_child);
                neighbor_set.insert(current_child);
              }
          }
#endif // #ifdef LIBMESH_ENABLE_AMR
        }
    untested_set.swap(next_untested_set);
    next_untested_set.clear();
  }
}

Referenced by findEdgeNeighbors(), findNodeNeighbors(), and findPointNeighbors().

findNodeNeighbors() [1/2]

void TraceRayTools::findNodeNeighbors	(	const Elem *const	elem,
		const Node *const	node,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	neighbor_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	untested_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	next_untested_set,
		std::vector< const Elem * >	active_neighbor_children,
		std::vector< NeighborInfo > &	info
	)

Referenced by TraceRay::getVertexNeighbors().

findNodeNeighbors() [2/2]

void TraceRayTools::findNodeNeighbors	(	const Elem *const	elem,
		const Node *const	node,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	neighbor_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	untested_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	next_untested_set,
		std::vector< const Elem * >	active_neighbor_children,
		std::vector< NeighborInfo > &	info
	)

Definition at line 179 of file TraceRayTools.C.

{
  mooseAssert(elem->get_node_index(node) != libMesh::invalid_uint, "Doesn't contain node");
 
  info.clear();
 
  // Helper for avoiding extraneous allocations when building side elements
  std::unique_ptr<const Elem> side_helper;
 
  auto contains_node = [&node, &elem, &info, &side_helper](const Elem * const candidate)
  {
    // Candidate has this node and it is a vertex - add sides that contain said node
    const auto n = candidate->get_node_index(node);
    if (n != invalid_uint && candidate->is_vertex(n))
    {
      std::vector<unsigned short> sides;
      for (const auto s : candidate->side_index_range())
        if (candidate->is_node_on_side(n, s))
          sides.push_back(s);
 
      if (sides.empty())
        mooseError("Failed to find a side containing node");
 
      info.emplace_back(candidate, std::move(sides));
      return true;
    }
    // In the case of a less refined candidate, the node can be a hanging node. The candidate
    // will only ever have the hanging node if it is less refined.
    if (candidate->level() < elem->level() && candidate->contains_point(*node))
    {
      std::vector<unsigned short> sides;
      for (const auto s : candidate->side_index_range())
      {
        candidate->build_side_ptr(side_helper, s);
        if (side_helper->contains_point(*node))
          sides.push_back(s);
      }
 
      if (!sides.empty())
      {
        info.emplace_back(candidate, std::move(sides));
        return true;
      }
    }
 
    return false;
  };
 
  // Fill info for the element that was passed in
  contains_node(elem);
 
  findNeighbors(
      elem, neighbor_set, untested_set, next_untested_set, active_neighbor_children, contains_node);
 
#ifndef NDEBUG
  // In non-opt modes, verify that we found all of the correct neighbors
  // using the more expensive libMesh routine
  std::set<const Elem *> point_neighbors;
  elem->find_point_neighbors(*node, point_neighbors);
  for (const auto & point_neighbor : point_neighbors)
    for (const auto & neighbor_node : point_neighbor->node_ref_range())
      if (node == &neighbor_node && !neighbor_set.contains(point_neighbor) &&
          point_neighbor != elem)
        mooseError("Missed a node neighbor");
#endif
}

findPointNeighbors() [1/2]

void TraceRayTools::findPointNeighbors	(	const Elem *const	elem,
		const Point &	point,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	neighbor_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	untested_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	next_untested_set,
		std::vector< const Elem * >	active_neighbor_children,
		std::vector< NeighborInfo > &	info
	)

Rewrite of the find_point_neighbors function in libMesh, instead using a statically allocated set: returns the active point neighbors at p within elem.

Parameters

elem	The element
p	The point
neighbor_set	The set to fill the neighbors into
untested_set	Set for internal use
next_untested_set	Set for internal use
active_neighbor_children	Temporary vector for use in the search

Referenced by TraceRay::getPointNeighbors(), and TEST().

findPointNeighbors() [2/2]

void TraceRayTools::findPointNeighbors	(	const Elem *const	elem,
		const Point &	point,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	neighbor_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	untested_set,
		MooseUtils::StaticallyAllocatedSet< const Elem *, MAX_POINT_NEIGHBORS > &	next_untested_set,
		std::vector< const Elem * >	active_neighbor_children,
		std::vector< NeighborInfo > &	info
	)

Definition at line 118 of file TraceRayTools.C.

{
  mooseAssert(elem->contains_point(point), "Doesn't contain point");
 
  info.clear();
 
  // Helper for avoiding extraneous allocation when building side elements
  std::unique_ptr<const Elem> side_helper;
 
  auto contains_point = [&point, &info, &side_helper, &elem](const Elem * const candidate)
  {
    if (candidate->contains_point(point))
    {
      std::vector<unsigned short> sides;
      for (const auto s : candidate->side_index_range())
      {
        candidate->build_side_ptr(side_helper, s);
        if (side_helper->contains_point(point))
          sides.push_back(s);
      }
 
      // Dont add the local element
      if (!sides.empty() && candidate != elem)
      {
        info.emplace_back(candidate, std::move(sides));
        return true;
      }
    }
 
    return false;
  };
 
  // Fill info for the element that was passed in
  contains_point(elem);
 
  findNeighbors(elem,
                neighbor_set,
                untested_set,
                next_untested_set,
                active_neighbor_children,
                contains_point);
 
#ifndef NDEBUG
  // In non-opt modes, verify that we found all of the correct neighbors
  // using the more expensive libMesh routine
  std::set<const Elem *> point_neighbors;
  elem->find_point_neighbors(point, point_neighbors);
  for (const auto & point_neighbor : point_neighbors)
    if (!neighbor_set.contains(point_neighbor) && point_neighbor != elem)
      mooseError("Missed a point neighbor");
#endif
}

getActiveNeighbor() [1/2]

const Elem * TraceRayTools::getActiveNeighbor	(	const Elem *	elem,
		const unsigned short	side,
		const Point &	point
	)

Get the active neighbor on side of elem that contains point.

Parameters

elem	The element
side	The side of elem that point is on
point	The point on the side you want the neighbor for

Returns

The active neighbor that contains the point

Referenced by TraceRay::trace().

getActiveNeighbor() [2/2]

const Elem * TraceRayTools::getActiveNeighbor	(	const Elem *	elem,
		const unsigned short	side,
		const Point &	point
	)

Definition at line 355 of file TraceRayTools.C.

{
  const auto neighbor = elem->neighbor_ptr(side);
  if (!neighbor || neighbor->active())
    return neighbor;
 
  // There is adaptivity... need to find the active child that contains the point
  const auto neighbor_side = neighbor->which_neighbor_am_i(elem);
  return childContainingPointOnSide(neighbor, point, neighbor_side);
}

intersectQuad() [1/2]

bool TraceRayTools::intersectQuad	(	const Point &	start,
		const Point &	direction,
		const Elem *const	elem,
		const unsigned short	v00,
		const unsigned short	v10,
		const unsigned short	v11,
		const unsigned short	v01,
		Real &	intersection_distance,
		ElemExtrema &	intersected_extrema,
		const Real hmax #ifdef	DEBUG_RAY_INTERSECTIONS,
		const bool debug #	endif
	)

Checks for the intersection of a ray and a quadrilateral, numbered as such:

v01 v11 o-----—o | | | | o-----—o v00 v10

Uses intersectTriangle() to check the possible intersection with the two triangles that make up the quad

Parameters

start	Start point of the ray
direction	Direction of the ray
elem	The elem that contains the quad face (used to get the vertex points)
v00	Vertex index on elem that represents v00 in the method description
v10	Vertex index on elem that represents v10 in the method description
v11	Vertex index on elem that represents v11 in the method description
v01	Vertex index on elem that represents v01 in the method description
intersection_distance	If intersected, storage for the intersection distance
intersected_extrema	If a vertex/edge is intersected, will be filled with the intersection

Returns

Whether or not the ray intersected the quadrilateral

Referenced by sideIntersectedByLine().

intersectQuad() [2/2]

bool TraceRayTools::intersectQuad	(	const Point &	start,
		const Point &	direction,
		const Elem *const	elem,
		const unsigned short	v00,
		const unsigned short	v10,
		const unsigned short	v11,
		const unsigned short	v01,
		Real &	intersection_distance,
		ElemExtrema &	intersected_extrema,
		const Real hmax #ifdef	DEBUG_RAY_INTERSECTIONS,
		const bool debug #	endif
	)

Definition at line 476 of file TraceRayTools.C.

{
  mooseAssert(intersected_extrema.isInvalid(), "Should be invalid");
  debugRaySimple("intersectQuad() called:");
  debugRaySimple("  start = ", start);
  debugRaySimple("  direction = ", direction);
  debugRaySimple("  elem->id() = ", elem->id());
  debugRaySimple("  v00 = ", v00, " at ", elem->point(v00));
  debugRaySimple("  v10 = ", v10, " at ", elem->point(v10));
  debugRaySimple("  v11 = ", v11, " at ", elem->point(v11));
  debugRaySimple("  v01 = ", v01, " at ", elem->point(v01));
 
  // NOTE discovered by @GiudGiud: In the case that you have
  // a glancing intersection (the direction is within the plane
  // of the face), you could possibly miss a further intersection
  // on the second triangle. In reality, this should not be
  // a problem because we check all sides of the element, so
  // we would find a further intersection in the future.
 
  // First check the triangle contained by v00, v10, v11
  bool intersects = intersectTriangle(start,
                                      direction,
                                      elem,
                                      v00,
                                      v10,
                                      v11,
                                      intersection_distance,
                                      intersected_extrema,
                                      hmax
#ifdef DEBUG_RAY_INTERSECTIONS
                                      ,
                                      debug
#endif
  );
  // If no intersection, check the triangle contained by v11, v01, v00
  if (!intersects)
    intersects = intersectTriangle(start,
                                   direction,
                                   elem,
                                   v11,
                                   v01,
                                   v00,
                                   intersection_distance,
                                   intersected_extrema,
                                   hmax
#ifdef DEBUG_RAY_INTERSECTIONS
                                   ,
                                   debug
#endif
    );
 
  // Because we split the quad into two triangles, we could intersect the edge v00 - v11. However,
  // that really isn't an edge - it's a diagonal across the quad. If we intersect this edge, be sure
  // to invalidate it
  if (intersects && intersected_extrema.atEdge(v00, v11))
    intersected_extrema.invalidate();
 
  return intersects;
}

intersectTriangle() [1/2]

bool TraceRayTools::intersectTriangle	(	const Point &	start,
		const Point &	direction,
		const Elem *const	elem,
		const unsigned short	v0,
		const unsigned short	v1,
		const unsigned short	v2,
		Real &	intersection_distance,
		ElemExtrema &	intersected_extrema,
		const Real hmax #ifdef	DEBUG_RAY_INTERSECTIONS,
		const bool debug #	endif
	)

Checks for the intersection of a ray and a triangular face.

Adapted from: webserver2.tecgraf.puc-rio.br/~mgattass/cg/trbRR/Fast%20MinimumStorage%20RayTriangle%20Intersection.pdf

Parameters

start	Start point of the ray
direction	Direction of the ray
elem	The elem that contains the triangular face (used to get the vertex points)
v0	Vertex index on elem that is the zeroth vertex of the triangular face
v1	Vertex index on elem that is the first vertex of the triangular face
v2	Vertex index on elem that is the second vertex of the triangular face
intersection_distance	If intersected, storage for the intersection distance
intersected_extrema	If a vertex/edge is intersected, will be filled with the intersection

Returns

Whether or not the ray intersected the triangular face

Referenced by intersectQuad(), and sideIntersectedByLine().

intersectTriangle() [2/2]

bool TraceRayTools::intersectTriangle	(	const Point &	start,
		const Point &	direction,
		const Elem *const	elem,
		const unsigned short	v0,
		const unsigned short	v1,
		const unsigned short	v2,
		Real &	intersection_distance,
		ElemExtrema &	intersected_extrema,
		const Real hmax #ifdef	DEBUG_RAY_INTERSECTIONS,
		const bool debug #	endif
	)

Definition at line 367 of file TraceRayTools.C.

{
  debugRaySimple("intersectTriangle() called:");
  debugRaySimple("  start = ", start);
  debugRaySimple("  direction = ", direction);
  debugRaySimple("  elem->id() = ", elem->id());
  debugRaySimple("  v0 = ", v0, " at ", elem->point(v0));
  debugRaySimple("  v1 = ", v1, " at ", elem->point(v1));
  debugRaySimple("  v2 = ", v2, " at ", elem->point(v2));
  debugRaySimple("  hmax = ", hmax);
  mooseAssert(elem->is_vertex(v0), "Not a vertex");
  mooseAssert(elem->is_vertex(v1), "Not a vertex");
  mooseAssert(elem->is_vertex(v2), "Not a vertex");
 
  // We are scaling the whole element (start, v0, v1, v2) by 1 / hmax as an alternative to scaling
  // the tolerance by hmax. If an intersection is found, the resulting intersection distance is
  // then scaled by hmax to reverse the original scaling.
  const auto inv_hmax = 1.0 / hmax;
 
  const auto & v0_point = elem->point(v0);
 
  const auto edge1 = (elem->point(v1) - v0_point) * inv_hmax;
  const auto edge2 = (elem->point(v2) - v0_point) * inv_hmax;
 
  const auto pvec = direction.cross(edge2);
 
  auto det = edge1 * pvec;
  debugRaySimple("  det = ", det);
  if (det < TRACE_TOLERANCE)
  {
    debugRaySimple("intersectTriangle() did not intersect: det < tol");
    return false;
  }
 
  const auto tvec = (start - v0_point) * inv_hmax;
  const auto u = tvec * pvec;
  debugRaySimple("  u = ", u);
  debugRaySimple("  u / det = ", u / det);
  if (u < -TRACE_TOLERANCE || u > det + TRACE_TOLERANCE)
  {
    debugRaySimple("intersectTriangle() did not intersect: u out of range");
    return false;
  }
 
  const auto qvec = tvec.cross(edge1);
  const auto v = direction * qvec;
  debugRaySimple("  v = ", v);
  debugRaySimple("  v / det = ", v / det);
  debugRaySimple("  (u + v) / det = ", (u + v) / det);
  if (v < -TRACE_TOLERANCE || u + v > det + TRACE_TOLERANCE)
  {
    debugRaySimple("intersectTriangle() did not intersect: v out of range");
    return false;
  }
 
  const auto possible_distance = (edge2 * qvec) / det;
  debugRaySimple("  possible_distance = ", possible_distance);
  if (possible_distance <= TRACE_TOLERANCE)
  {
    debugRaySimple("intersectTriangle() did not intersect: distance too small");
    return false;
  }
 
  // Recall that the element was scaled by (1 / hmax), reverse this scaling by
  // scaling the intersection distance by hmax
  intersection_distance = possible_distance * hmax;
 
  // Here, u and v aren't truly u and v. The actual u and v are obtained with:
  // u = u / det and v = v / det -> move det to the RHS to avoid division
  if (u < TRACE_TOLERANCE * det)
  {
    if (v < TRACE_TOLERANCE * det) // u = 0, v = 0
      intersected_extrema.setVertex(v0);
    else if (v > (1.0 - TRACE_TOLERANCE) * det) // u = 0, v = 1
      intersected_extrema.setVertex(v2);
    else // u = 0
      intersected_extrema.setEdge(v0, v2);
  }
  else if (v < TRACE_TOLERANCE * det)
  {
    if (u > (1.0 - TRACE_TOLERANCE) * det) // u = 1, v = 0
      intersected_extrema.setVertex(v1);
    else // v = 0
      intersected_extrema.setEdge(v0, v1);
  }
  else if ((u + v > (1.0 - TRACE_TOLERANCE) * det)) // u + v = 1
    intersected_extrema.setEdge(v1, v2);
 
  debugRaySimple("intersectTriangle() intersected with:");
  debugRaySimple("  intersection_distance = ", intersection_distance);
  debugRaySimple("  intersected_extrema = ", intersected_extrema);
 
  return true;
}

isAdaptivityTraceableElem() [1/2]

bool TraceRayTools::isAdaptivityTraceableElem

(

const Elem *

elem

)

Returns

Whether or not the element is traceable with adaptivity

Referenced by RayTracingStudy::traceableMeshChecks().

isAdaptivityTraceableElem() [2/2]

bool TraceRayTools::isAdaptivityTraceableElem

(

const Elem *

elem

)

Definition at line 557 of file TraceRayTools.C.

{
  return ADAPTIVITY_TRACEABLE_ELEMTYPES.count(elem->type());
}

isTraceableElem() [1/2]

bool TraceRayTools::isTraceableElem

(

const Elem *

elem

)

Returns

Whether not the element is traceable

Referenced by RayTracingStudy::traceableMeshChecks().

isTraceableElem() [2/2]

bool TraceRayTools::isTraceableElem

(

const Elem *

elem

)

Definition at line 551 of file TraceRayTools.C.

{
  return TRACEABLE_ELEMTYPES.count(elem->type());
}

isWithinSegment() [1/4]

bool TraceRayTools::isWithinSegment	(	const Point &	segment1,
		const Point &	segment2,
		const Point &	point,
		const Real	tolerance
	)

Definition at line 779 of file TraceRayTools.C.

{
  mooseAssert(!segment1.absolute_fuzzy_equals(segment2, TRACE_TOLERANCE), "Same endpoints");
 
  const auto segment_length = (segment1 - segment2).norm();
  return isWithinSegment(segment1, segment2, segment_length, point, tolerance);
}

isWithinSegment() [2/4]

bool TraceRayTools::isWithinSegment	(	const Point &	segment1,
		const Point &	segment2,
		const Point &	point,
		const Real	tolerance = TRACE_TOLERANCE
	)

Checks whether or not a point is within a line segment.

Parameters

segment1	The first point on the segment
segment2	The second point on the segment
point	The point
tolerance	The tolerance to use

Returns

If point is within the segment defined by [segment1, segment2]

Referenced by findEdgeNeighborsWithinEdgeInternal(), TraceRay::getEdgeNeighbors(), BoundingBoxIntersectionHelper::intersection(), isWithinSegment(), TEST(), withinEdgeOnSideTempl(), and withinEdgeTempl().

isWithinSegment() [3/4]

bool TraceRayTools::isWithinSegment	(	const Point &	segment1,
		const Point &	segment2,
		const Real	segment_length,
		const Point &	point,
		const Real	tolerance
	)

Definition at line 791 of file TraceRayTools.C.

{
  mooseAssert(!segment1.absolute_fuzzy_equals(segment2, TRACE_TOLERANCE), "Same endpoints");
  mooseAssert(MooseUtils::absoluteFuzzyEqual((segment1 - segment2).norm(), segment_length),
              "Invalid segment length");
 
  const auto diff1 = point - segment1;
  const auto diff2 = point - segment2;
 
  if (diff1 * diff2 > tolerance * segment_length)
    return false;
 
  return std::abs(diff1.norm() + diff2.norm() - segment_length) < tolerance * segment_length;
}

isWithinSegment() [4/4]

bool TraceRayTools::isWithinSegment	(	const Point &	segment1,
		const Point &	segment2,
		const Real	segment_length,
		const Point &	point,
		const Real	tolerance = TRACE_TOLERANCE
	)

Checks whether or not a point is within a line segment.

Parameters

segment1	The first point on the segment
segment2	The second point on the segment
segment_length	The segment length (for optimization if it's already computed)
point	The point
tolerance	The tolerance to use

Returns

If point is within the segment defined by [segment1, segment2]

lineLineIntersect2D() [1/2]

bool TraceRayTools::lineLineIntersect2D	(	const Point &	start,
		const Point &	direction,
		const Real	length,
		const Point &	v0,
		const Point &	v1,
		Point &	intersection_point,
		Real &	intersection_distance,
		SegmentVertices &segment_vertex #ifdef	DEBUG_RAY_INTERSECTIONS,
		const bool debug #	endif
	)

Checks for the intersection of the line u0 -> u1 with the line v0 -> v1, where u0 = start and u1 = start + direction * length.

From: https://stackoverflow.com/a/565282

Returns

Whether or not the lines intersect

Parameters

start	The start point, u0
direction	The direction used to define u1
length	The length used to define u1
v0	The point v0
v1	The point v1
intersection_point	To be filled with the point of intersection
intersection_distance	To be filled with the distance of intersection
segment_vertex	To be filled with the intersected vertex, if any

Referenced by sideIntersectedByLine().

lineLineIntersect2D() [2/2]

bool TraceRayTools::lineLineIntersect2D	(	const Point &	start,
		const Point &	direction,
		const Real	length,
		const Point &	v0,
		const Point &	v1,
		Point &	intersection_point,
		Real &	intersection_distance,
		SegmentVertices &segment_vertex #ifdef	DEBUG_RAY_INTERSECTIONS,
		const bool debug #	endif
	)

Definition at line 48 of file TraceRayTools.C.

{
  // TODO: consider using hmax scaling here
  mooseAssert(segment_vertex == SEGMENT_VERTEX_NONE, "Vertex should be none");
  debugRaySimple("Called lineLineIntersect2D()");
  debugRaySimple("  start = ", start);
  debugRaySimple("  direction = ", direction);
  debugRaySimple("  length = ", length);
  debugRaySimple("  v0 = ", v0);
  debugRaySimple("  v1 = ", v1);
 
  const auto r = direction * length;
  const auto s = v1 - v0;
 
  const auto rxs = r(0) * s(1) - r(1) * s(0);
  debugRaySimple("  rxs = ", rxs);
 
  // Lines are parallel or colinear
  if (std::abs(rxs) < TRACE_TOLERANCE)
    return false;
 
  const auto v0mu0 = v0 - start;
 
  const auto t = (v0mu0(0) * s(1) - v0mu0(1) * s(0)) / rxs;
  debugRaySimple("  t = ", t);
  if (0 >= t + TRACE_TOLERANCE || t - TRACE_TOLERANCE > 1.0)
  {
    debugRaySimple("lineLineIntersect2D did not intersect: t out of range");
    return false;
  }
 
  const auto u = (v0mu0(0) * r(1) - v0mu0(1) * r(0)) / rxs;
  debugRaySimple("  u = ", u);
  if (0 < u + TRACE_TOLERANCE && u - TRACE_TOLERANCE <= 1.0)
  {
    intersection_point = start + r * t;
    intersection_distance = t * length;
 
    if (u < TRACE_TOLERANCE)
      segment_vertex = SEGMENT_VERTEX_0;
    else if (u > 1.0 - TRACE_TOLERANCE)
      segment_vertex = SEGMENT_VERTEX_1;
 
    debugRaySimple("lineLineIntersect2D intersected with:");
    debugRaySimple("  intersection_distance = ", intersection_point);
    debugRaySimple("  intersection_distance = ", intersection_distance);
    debugRaySimple("  segment_vertex = ", Utility::enum_to_string(segment_vertex));
 
    return true;
  }
 
  // Not parallel, but don't intersect
  debugRaySimple("lineLineIntersect2d() did not intersect: u out of range");
  return false;
}

nodesPerSide() [1/3]

template<typename T >

std::enable_if< std::is_base_of< Pyramid, T >::value, unsignedshort >::type TraceRayTools::nodesPerSide ( const unsigned short  side )

inline

Returns the number of nodes on a side on a Pyramid elem.

Definition at line 907 of file TraceRayTools.h.

{
  return T::nodes_per_side - (side != 4);
}

nodesPerSide() [2/3]

template<typename T >

std::enable_if< std::is_base_of< libMesh::Prism, T >::value, unsignedshort >::type TraceRayTools::nodesPerSide ( const unsigned short  side )

inline

Returns the number of nodes on a side on a Prism elem.

Definition at line 917 of file TraceRayTools.h.

{
  return T::nodes_per_side - (side == 0 || side == 4);
}

nodesPerSide() [3/3]

template<typename T >

std::enable_if<!std::is_base_of< libMesh::Pyramid, T >::value &&!std::is_base_of< libMesh::Prism, T >::value, unsignedshort >::type TraceRayTools::nodesPerSide ( const unsigned short  )

inline

Returns the number of nodes on a side for an Elem that is not a Pyramid or Prism.

Definition at line 897 of file TraceRayTools.h.

{
  return T::nodes_per_side;
}

onBoundingBoxBoundary() [1/2]

bool TraceRayTools::onBoundingBoxBoundary	(	const BoundingBox &	bbox,
		const Point &	point,
		const unsigned int	dim,
		const Real	tolerance
	)

Whether or not point is on the boundary (min/max) of bbox.

Checks dim dimensions.

Referenced by TraceRay::trace().

onBoundingBoxBoundary() [2/2]

bool TraceRayTools::onBoundingBoxBoundary	(	const BoundingBox &	bbox,
		const Point &	point,
		const unsigned int	dim,
		const Real	tolerance
	)

Definition at line 811 of file TraceRayTools.C.

{
  for (unsigned int d = 0; d < dim; ++d)
    if (MooseUtils::absoluteFuzzyEqual(point(d), bbox.min()(d), tolerance) ||
        MooseUtils::absoluteFuzzyEqual(point(d), bbox.max()(d), tolerance))
      return true;
 
  return false;
}

sideIntersectedByLine() [1/5]

template<typename T >

std::enable_if< std::is_base_of< libMesh::Face, T >::value, bool >::type TraceRayTools::sideIntersectedByLine	(	const Elem *	elem,
		const Point &	start_point,
		const Point &	direction,
		const unsigned short	side,
		const Real	max_length,
		Point &	intersection_point,
		Real &	intersection_distance,
		ElemExtrema &	intersected_extrema,
		const Real #ifdef	DEBUG_RAY_INTERSECTIONS,
		const bool debug #	endif
	)

SFINAE typed object for checking the intersection of a line segment with the face of a Face typed element, i.e., the intersection with the edge of a 2D element.

Parameters

elem	The element to check
start_point	Start point of the segment
direction	Direction of the segment
side	The side of elem to check
max_length	A length that is longer than the length of the line segment
intersection_point	If intersected, storage for the intersection point
intersection_distance	If intersected, storage for the intersection distance
intersected_extrema	If a vertex/edge is intersected, will be filled with the intersection

Returns

Whether or not the line segment intersected with the face

Definition at line 564 of file TraceRayTools.h.

{
  mooseAssert(intersection_point == RayTracingCommon::invalid_point, "Point should be invalid");
  mooseAssert(intersected_extrema.isInvalid(), "Should be invalid");
 
  SegmentVertices segment_vertex = SEGMENT_VERTEX_NONE;
 
  const bool intersected = lineLineIntersect2D(start_point,
                                               direction,
                                               max_length,
                                               elem->point(T::side_nodes_map[side][0]),
                                               elem->point(T::side_nodes_map[side][1]),
                                               intersection_point,
                                               intersection_distance,
                                               segment_vertex
#ifdef DEBUG_RAY_INTERSECTIONS
                                               ,
                                               debug
#endif
  );
 
  if (segment_vertex != SEGMENT_VERTEX_NONE)
  {
    intersected_extrema.setVertex(T::side_nodes_map[side][segment_vertex]);
    mooseAssert(
        intersected_extrema.vertexPoint(elem).absolute_fuzzy_equals(intersection_point,
                                                                    3 * TRACE_TOLERANCE),
        "Doesn't intersect vertex at: " + Moose::stringify(intersected_extrema.vertexPoint(elem)) +
            " tentative intersection point: " + Moose::stringify(intersection_point));
  }
 
  return intersected;
}

sideIntersectedByLine() [2/5]

template<typename T >

std::enable_if< std::is_base_of< Hex, T >::value, bool >::type TraceRayTools::sideIntersectedByLine	(	const Elem *	elem,
		const Point &	start_point,
		const Point &	direction,
		const unsigned short	side,
		const Real	,
		Point &	intersection_point,
		Real &	intersection_distance,
		ElemExtrema &	intersected_extrema,
		const Real hmax #ifdef	DEBUG_RAY_INTERSECTIONS,
		const bool debug #	endif
	)

SFINAE typed object for checking the intersection of a line segment with the face of a Hex typed element.

Parameters

elem	The element to check
start_point	Start point of the segment
direction	Direction of the segment
side	The side of elem to check
intersection_point	If intersected, storage for the intersection point
intersection_distance	If intersected, storage for the intersection distance
intersected_extrema	If a vertex/edge is intersected, will be filled with the intersection

Returns

Whether or not the line segment intersected with the face

Definition at line 625 of file TraceRayTools.h.

{
  mooseAssert(elem->first_order_equivalent_type(elem->type()) == HEX8, "Not a Hex");
  mooseAssert(intersection_point == RayTracingCommon::invalid_point, "Point should be invalid");
  mooseAssert(intersected_extrema.isInvalid(), "Should be invalid");
 
  const bool intersected = intersectQuad(start_point,
                                         direction,
                                         elem,
                                         T::side_nodes_map[side][3],
                                         T::side_nodes_map[side][2],
                                         T::side_nodes_map[side][1],
                                         T::side_nodes_map[side][0],
                                         intersection_distance,
                                         intersected_extrema,
                                         hmax
#ifdef DEBUG_RAY_INTERSECTIONS
                                         ,
                                         debug
#endif
  );
 
  if (intersected)
    intersection_point = start_point + intersection_distance * direction;
 
  return intersected;
}

sideIntersectedByLine() [3/5]

template<typename T >

std::enable_if< std::is_base_of< Tet, T >::value, bool >::type TraceRayTools::sideIntersectedByLine	(	const Elem *	elem,
		const Point &	start_point,
		const Point &	direction,
		const unsigned short	side,
		const Real	,
		Point &	intersection_point,
		Real &	intersection_distance,
		ElemExtrema &	intersected_extrema,
		const Real hmax #ifdef	DEBUG_RAY_INTERSECTIONS,
		const bool debug #	endif
	)

SFINAE typed object for checking the intersection of a line segment with the face of a Tet typed element.

Parameters

elem	The element to check
start_point	Start point of the segment
direction	Direction of the segment
side	The side of elem to check
max_length	A length that is longer than the length of the line segment
intersection_point	If intersected, storage for the intersection point
intersection_distance	If intersected, storage for the intersection distance
intersected_vertex	If a vertex is intersected, storage for said intersection
intersected_extrema	If a vertex/edge is intersected, will be filled with the intersection

Returns

Whether or not the line segment intersected with the face

Definition at line 682 of file TraceRayTools.h.

{
  mooseAssert(elem->first_order_equivalent_type(elem->type()) == TET4, "Not a Tet");
  mooseAssert(intersection_point == RayTracingCommon::invalid_point, "Point should be invalid");
  mooseAssert(intersected_extrema.isInvalid(), "Should be invalid");
 
  const bool intersected = intersectTriangle(start_point,
                                             direction,
                                             elem,
                                             T::side_nodes_map[side][2],
                                             T::side_nodes_map[side][1],
                                             T::side_nodes_map[side][0],
                                             intersection_distance,
                                             intersected_extrema,
                                             hmax
#ifdef DEBUG_RAY_INTERSECTIONS
                                             ,
                                             debug
#endif
  );
 
  if (intersected)
    intersection_point = start_point + intersection_distance * direction;
 
  return intersected;
}

sideIntersectedByLine() [4/5]

template<typename T >

std::enable_if< std::is_base_of< libMesh::Pyramid, T >::value, bool >::type TraceRayTools::sideIntersectedByLine	(	const Elem *	elem,
		const Point &	start_point,
		const Point &	direction,
		const unsigned short	side,
		const Real	,
		Point &	intersection_point,
		Real &	intersection_distance,
		ElemExtrema &	intersected_extrema,
		const Real hmax #ifdef	DEBUG_RAY_INTERSECTIONS,
		const bool debug #	endif
	)

SFINAE typed object for checking the intersection of a line segment with the face of a Pyramid typed element.

Parameters

elem	The element to check
start_point	Start point of the segment
direction	Direction of the segment
side	The side of elem to check
max_length	A length that is longer than the length of the line segment
intersection_point	If intersected, storage for the intersection point
intersection_distance	If intersected, storage for the intersection distance
intersected_vertex	If a vertex is intersected, storage for said intersection
intersected_extrema	If a vertex/edge is intersected, will be filled with the intersection

Returns

Whether or not the line segment intersected with the face

Definition at line 738 of file TraceRayTools.h.

{
  mooseAssert(elem->first_order_equivalent_type(elem->type()) == PYRAMID5, "Not a Pyramid");
  mooseAssert(intersection_point == RayTracingCommon::invalid_point, "Point should be invalid");
  mooseAssert(intersected_extrema.isInvalid(), "Should be invalid");
 
  const bool intersected = side < 4 ? intersectTriangle(start_point,
                                                        direction,
                                                        elem,
                                                        T::side_nodes_map[side][2],
                                                        T::side_nodes_map[side][1],
                                                        T::side_nodes_map[side][0],
                                                        intersection_distance,
                                                        intersected_extrema,
                                                        hmax
#ifdef DEBUG_RAY_INTERSECTIONS
                                                        ,
                                                        debug
#endif
                                                        )
                                    : intersectQuad(start_point,
                                                    direction,
                                                    elem,
                                                    T::side_nodes_map[side][3],
                                                    T::side_nodes_map[side][2],
                                                    T::side_nodes_map[side][1],
                                                    T::side_nodes_map[side][0],
                                                    intersection_distance,
                                                    intersected_extrema,
                                                    hmax
#ifdef DEBUG_RAY_INTERSECTIONS
                                                    ,
                                                    debug
#endif
                                      );
 
  if (intersected)
    intersection_point = start_point + intersection_distance * direction;
 
  return intersected;
}

sideIntersectedByLine() [5/5]

template<typename T >

std::enable_if< std::is_base_of< libMesh::Prism, T >::value, bool >::type TraceRayTools::sideIntersectedByLine	(	const Elem *	elem,
		const Point &	start_point,
		const Point &	direction,
		const unsigned short	side,
		const Real	,
		Point &	intersection_point,
		Real &	intersection_distance,
		ElemExtrema &	intersected_extrema,
		const Real hmax #ifdef	DEBUG_RAY_INTERSECTIONS,
		const bool debug #	endif
	)

SFINAE typed object for checking the intersection of a line segment with the face of a Prism typed element.

Parameters

elem	The element to check
start_point	Start point of the segment
direction	Direction of the segment
side	The side of elem to check
max_length	A length that is longer than the length of the line segment
intersection_point	If intersected, storage for the intersection point
intersection_distance	If intersected, storage for the intersection distance
intersected_vertex	If a vertex is intersected, storage for said intersection
intersected_extrema	If a vertex/edge is intersected, will be filled with the intersection

Returns

Whether or not the line segment intersected with the face

Definition at line 809 of file TraceRayTools.h.

{
  mooseAssert(elem->first_order_equivalent_type(elem->type()) == PRISM6, "Not a Prism");
  mooseAssert(intersection_point == RayTracingCommon::invalid_point, "Point should be invalid");
  mooseAssert(intersected_extrema.isInvalid(), "Should be invalid");
 
  const bool intersected = (side == 0 || side == 4) ? intersectTriangle(start_point,
                                                                        direction,
                                                                        elem,
                                                                        T::side_nodes_map[side][2],
                                                                        T::side_nodes_map[side][1],
                                                                        T::side_nodes_map[side][0],
                                                                        intersection_distance,
                                                                        intersected_extrema,
                                                                        hmax
#ifdef DEBUG_RAY_INTERSECTIONS
                                                                        ,
                                                                        debug
#endif
                                                                        )
                                                    : intersectQuad(start_point,
                                                                    direction,
                                                                    elem,
                                                                    T::side_nodes_map[side][3],
                                                                    T::side_nodes_map[side][2],
                                                                    T::side_nodes_map[side][1],
                                                                    T::side_nodes_map[side][0],
                                                                    intersection_distance,
                                                                    intersected_extrema,
                                                                    hmax
#ifdef DEBUG_RAY_INTERSECTIONS
                                                                    ,
                                                                    debug
#endif
                                                      );
 
  if (intersected)
    intersection_point = start_point + intersection_distance * direction;
 
  return intersected;
}

withinEdge() [1/2]

bool TraceRayTools::withinEdge	(	const Elem *	elem,
		const Point &	point,
		ElemExtrema &	extrema,
		const Real	tolerance
	)

Definition at line 595 of file TraceRayTools.C.

{
  switch (elem->type())
  {
    case HEX8:
    case HEX20:
    case HEX27:
      return withinEdgeTempl<Hex8>(elem, point, extrema, tolerance);
    case TET4:
    case TET10:
    case TET14:
      return withinEdgeTempl<Tet4>(elem, point, extrema, tolerance);
    case PYRAMID5:
    case PYRAMID13:
    case PYRAMID14:
      return withinEdgeTempl<Pyramid5>(elem, point, extrema, tolerance);
    case PRISM6:
    case PRISM15:
    case PRISM18:
      return withinEdgeTempl<Prism6>(elem, point, extrema, tolerance);
    default:
      mooseError("Element type ",
                 Utility::enum_to_string(elem->type()),
                 " not supported in TraceRayTools::withinEdge()");
  }
 
  return false;
}

withinEdge() [2/2]

bool TraceRayTools::withinEdge	(	const Elem *	elem,
		const Point &	point,
		ElemExtrema &	extrema,
		const Real	tolerance = TRACE_TOLERANCE
	)

Determines if a point is within an edge on an element.

Parameters

elem	The element
point	The point
extrema	To be filled with the local vertex IDs that contain the edge the point is within, if any
tolerance	The tolerance to use

Returns

If the point is within an edge of the element

Referenced by TEST(), TEST(), and TraceRay::trace().

withinEdgeOnSide() [1/2]

bool TraceRayTools::withinEdgeOnSide	(	const Elem *const	elem,
		const Point &	point,
		const unsigned short	side,
		ElemExtrema &	extrema
	)

Determines if a point is within an edge on the side of an element.

Parameters

elem	The element
point	The point
side	The side
extrema	To be filled with the local vertex IDs that contain the edge the point is within, if any

Returns

If the point is within an edge on the side of the element

Referenced by TEST(), TraceRay::trace(), and withinExtremaOnSide().

withinEdgeOnSide() [2/2]

bool TraceRayTools::withinEdgeOnSide	(	const Elem *const	elem,
		const Point &	point,
		const unsigned short	side,
		ElemExtrema &	extrema
	)

Definition at line 699 of file TraceRayTools.C.

{
  switch (elem->type())
  {
    case HEX8:
    case HEX20:
    case HEX27:
      return withinEdgeOnSideTempl<Hex8>(elem, point, side, extrema);
    case TET4:
    case TET10:
    case TET14:
      return withinEdgeOnSideTempl<Tet4>(elem, point, side, extrema);
    case PYRAMID5:
    case PYRAMID13:
    case PYRAMID14:
      return withinEdgeOnSideTempl<Pyramid5>(elem, point, side, extrema);
    case PRISM6:
    case PRISM15:
    case PRISM18:
      return withinEdgeOnSideTempl<Prism6>(elem, point, side, extrema);
    default:
      mooseError("Element type ",
                 Utility::enum_to_string(elem->type()),
                 " not supported in TraceRayTools::withinEdgeOnSide()");
  }
 
  return false;
}

withinEdgeOnSideTempl() [1/3]

template<typename T >

std::enable_if< std::is_base_of< libMesh::Cell, T >::value, bool >::type TraceRayTools::withinEdgeOnSideTempl	(	const Elem * const	elem,
		const Point &	point,
		const unsigned short	side,
		ElemExtrema &	extrema
	)

Determines if a point is within an edge on the side of an element.

SFINAE here makes this method available for only 3D elem types (Cell)

The template argument should be the first order type of the elem - this is used to access the vertex mappings for said element without calling any virtuals

Parameters

elem	The element
point	The point
side	The side
extrema	To be filled with the local vertex IDs that contain the edge the point is within, if any

Returns

If the point is within an edge on the side of the element

SFINAE here makes this method available for only 1D/2D elem types (not Cell), which do not have edges, therefore this function errors.

Definition at line 1045 of file TraceRayTools.h.

{
  mooseError("Should not call withinEdgeOnSideTempl() with a non-Cell derived Elem");
}

withinEdgeOnSideTempl() [2/3]

template<typename T >

std::enable_if< std::is_base_of< Cell, T >::value, bool >::type TraceRayTools::withinEdgeOnSideTempl	(	const Elem *const	elem,
		const Point &	point,
		const unsigned short	side,
		ElemExtrema &	extrema
	)

Definition at line 733 of file TraceRayTools.C.

{
  mooseAssert(side < elem->n_sides(), "Invalid side");
  mooseAssert(elem->side_ptr(side)->close_to_point(point, LOOSE_TRACE_TOLERANCE),
              "Side does not contain point");
  mooseAssert(extrema.isInvalid(), "Should be invalid");
 
  int last_n = T::side_nodes_map[side][nodesPerSide<T>(side) - 1];
 
  for (int side_v = 0; side_v < nodesPerSide<T>(side); ++side_v)
    if (isWithinSegment(elem->point(last_n), elem->point(T::side_nodes_map[side][side_v]), point))
    {
      extrema.setEdge(last_n, T::side_nodes_map[side][side_v]);
      mooseAssert(extrema.buildEdge(elem)->close_to_point(point, LOOSE_TRACE_TOLERANCE),
                  "Edge doesn't contain point");
      return true;
    }
    else
      last_n = T::side_nodes_map[side][side_v];
 
  return false;
}

withinEdgeOnSideTempl() [3/3]

template<typename T >

std::enable_if<!std::is_base_of< libMesh::Cell, T >::value, bool >::type TraceRayTools::withinEdgeOnSideTempl	(	const Elem * const	elem,
		const Point &	point,
		const unsigned short	side,
		ElemExtrema &	extrema
	)

Determines if a point is within an edge on the side of an element.

SFINAE here makes this method available for only 1D/2D elem types (not Cell), which do not have edges, therefore this function errors.

Definition at line 1045 of file TraceRayTools.h.

{
  mooseError("Should not call withinEdgeOnSideTempl() with a non-Cell derived Elem");
}

withinEdgeTempl() [1/2]

template<typename T >

bool TraceRayTools::withinEdgeTempl	(	const Elem *	elem,
		const Point &	point,
		ElemExtrema &	extrema,
		const Real	tolerance
	)

Definition at line 574 of file TraceRayTools.C.

{
  mooseAssert(extrema.isInvalid(), "Should be invalid");
 
  for (int e = 0; e < T::num_edges; ++e)
    if (isWithinSegment(elem->point(T::edge_nodes_map[e][0]),
                        elem->point(T::edge_nodes_map[e][1]),
                        point,
                        tolerance))
    {
      extrema.setEdge(T::edge_nodes_map[e][0], T::edge_nodes_map[e][1]);
      return true;
    }
 
  return false;
}

withinEdgeTempl() [2/2]

template<typename T >

bool TraceRayTools::withinEdgeTempl	(	const Elem *	elem,
		const Point &	point,
		ElemExtrema &	extrema,
		const Real	tolerance = TRACE_TOLERANCE
	)

Determines if a point is within edge on an element.

The template argument should be a derived element type that corresponds to the elem->type(), and is used to obtain edge/node mapping without using virtuals.

Parameters

elem	The element
point	The point
extrema	To be filled with the local vertex IDs that contain the edge the point is within, if any
tolerance	The tolerance to use

Returns

If the point is within an edge of the element

withinExtremaOnSide() [1/2]

bool TraceRayTools::withinExtremaOnSide	(	const Elem *const	elem,
		const Point &	point,
		const unsigned short	side,
		const unsigned int	dim,
		ElemExtrema &	extrema
	)

Determines if a point is within an Elem's extrema (at vertex/within edge) on a side.

Parameters

elem	The element
point	The point
side	The side
dim	The element dimension
extrema	To be filled with the extrema if any are found

Returns

If the point is at a vertex/within an edge on the side

Referenced by TraceRay::applyOnExternalBoundary(), TraceRay::applyOnInternalBoundary(), and TraceRay::findExternalBoundarySide().

withinExtremaOnSide() [2/2]

bool TraceRayTools::withinExtremaOnSide	(	const Elem *const	elem,
		const Point &	point,
		const unsigned short	side,
		const unsigned int	dim,
		ElemExtrema &	extrema
	)

Definition at line 760 of file TraceRayTools.C.

{
  mooseAssert(extrema.isInvalid(), "Extrema should be invalid");
  mooseAssert(dim == elem->dim(), "Incorrect dim");
 
  extrema.first = atVertexOnSide(elem, point, side);
  if (extrema.atVertex())
    return true;
  if (dim == 3 && withinEdgeOnSide(elem, point, side, extrema))
    return true;
 
  return false;
}

Variable Documentation

ADAPTIVITY_TRACEABLE_ELEMTYPES

const std::set< int > TraceRayTools::ADAPTIVITY_TRACEABLE_ELEMTYPES = {QUAD4, HEX8, TRI3, TET4, EDGE2}

The element types that are traceable with adaptivity.

Definition at line 45 of file TraceRayTools.C.

{QUAD4, HEX8, TRI3, TET4, EDGE2};

Referenced by isAdaptivityTraceableElem().

INVALID_INT

const int TraceRayTools::INVALID_INT = std::numeric_limits<int>::max()

Value for an invalid integer.

Definition at line 53 of file TraceRayTools.h.

LOOSE_TRACE_TOLERANCE

const Real TraceRayTools::LOOSE_TRACE_TOLERANCE = 1e-5

Looser tolerance for use in error checking in difficult situations.

Definition at line 50 of file TraceRayTools.h.

Referenced by atVertexOnSideTempl(), TraceRay::exitsElem(), TraceRay::getEdgeNeighbors(), TraceRay::moveThroughNeighbor(), TraceRay::onSegment(), TraceRay::onTrajectoryChanged(), TraceRay::trace(), and withinEdgeOnSideTempl().

TRACE_TOLERANCE

const Real TraceRayTools::TRACE_TOLERANCE = 1e-8

The standard tolerance to use in tracing.

Definition at line 48 of file TraceRayTools.h.

Referenced by TraceRay::applyOnExternalBoundary(), TraceRay::applyOnInternalBoundary(), atVertex(), atVertexOnSideTempl(), TraceRay::exitsElem(), TraceRay::findExternalBoundarySide(), TraceRay::getEdgeNeighbors(), intersectTriangle(), isWithinSegment(), isWithinSegment(), lineLineIntersect2D(), sideIntersectedByLine(), RayTracingStudy::sideIsIncoming(), and TraceRay::trace().

TRACEABLE_ELEMTYPES

const std::set< int > TraceRayTools::TRACEABLE_ELEMTYPES

Initial value:

= {
    HEX8, HEX20, HEX27, QUAD4, QUAD8,    QUAD9,     TET4,      TET10,  TET14,   TRI3,   TRI6,
    TRI7, EDGE2, EDGE3, EDGE4, PYRAMID5, PYRAMID13, PYRAMID14, PRISM6, PRISM15, PRISM18}

The element types that are traceable.

Definition at line 42 of file TraceRayTools.C.

                                        {
    HEX8, HEX20, HEX27, QUAD4, QUAD8,    QUAD9,     TET4,      TET10,  TET14,   TRI3,   TRI6,
    TRI7, EDGE2, EDGE3, EDGE4, PYRAMID5, PYRAMID13, PYRAMID14, PRISM6, PRISM15, PRISM18};

Referenced by isTraceableElem(), TEST(), TEST(), TEST(), TEST(), and TEST().