Ray Class Reference

Basic datastructure for a ray that will traverse the mesh. More...

#include <Ray.h>

Classes
class	ChangeDirectionKey
	Class that is used as a parameter to changeDirection() that allows only RayBC methods to call changeDirection() More...
class	ChangeStartDirectionKey
	Class that is used as a parameter to changeStartDirection() that allows only RayKernelBase methods to call changeStartDirection() More...
class	ConstructRayKey
	Class that is used as a parameter to the public constructors/reset methods. More...

Public Member Functions
	Ray (RayTracingStudy *study, const RayID id, const std::size_t data_size, const std::size_t aux_data_size, const bool reset, const ConstructRayKey &)
	Ray constructor for internal use only. More...
void	reset (RayTracingStudy *study, const RayID id, const std::size_t data_size, const std::size_t aux_data_size, const bool reset, const ConstructRayKey &)
	Resets a Ray for internal use only. More...
	Ray (const Ray *const other, const ConstructRayKey &)
	Copy constructor for internal use only. More...
void	reset (const Ray *const other, const ConstructRayKey &)
	Resets a Ray from another Ray for internal use only. More...
Ray &	operator= (const Ray &)=delete
	Deleted copy operator. More...
	Ray ()=delete
	Deleted default constructor. More...
	Ray (const Ray &other)=delete
	Deleted copy constructor. More...
bool	operator== (const Ray &other) const
	Equality operator. More...
bool	operator!= (const Ray &other) const
	Non-equal operator. More...
RayID	id () const
	Gets the Ray's ID. More...
bool	invalidID () const
	Whether or not the Ray's ID is invalid. More...
const Point &	currentPoint () const
	Gets the point that the Ray is currently at. More...
bool	invalidCurrentPoint () const
	Whether or not the point that the Ray is currently at is valid. More...
void	changeDirection (const Point &direction, const ChangeDirectionKey)
	This method is for internal use only. More...
void	changeStartDirection (const Point &start, const Point &direction, const ChangeStartDirectionKey)
	This method is for internal use only. More...
const Point &	direction () const
	Gets the Ray's direction. More...
bool	invalidDirection () const
	Whether or not the Ray's direction is set to invalid. More...
std::vector< RayData > &	data ()
	Gets a writeable reference to the Ray's data. More...
const std::vector< RayData > &	data () const
	Gets a read only reference to the Ray's data. More...
RayData &	data (const std::size_t i)
	Gets a writeable reference to the Ray's data at an index. More...
const RayData &	data (const std::size_t i) const
	Gets a read only reference to the Ray's data at an index. More...
std::vector< RayData > &	auxData ()
	Gets a writeable reference to the Ray's auxilary data. More...
const std::vector< RayData > &	auxData () const
	Gets a read only reference to the Ray's auxilary data. More...
RayData &	auxData (const std::size_t i)
	Gets a writeable reference to a component of the Ray's auxilary data. More...
const RayData &	auxData (const std::size_t i) const
	Gets a read only reference to a component of the Ray's auxilary data. More...
void	setStart (const Point &starting_point, const Elem *starting_elem=nullptr, const unsigned short starting_incoming_side=RayTracingCommon::invalid_side)
	Sets the information pretaining to the start point for the Ray. More...
void	setStartingDirection (const Point &starting_direction)
	Sets the starting direction to starting_direction for a Ray. More...
void	setStartingEndPoint (const Point &starting_end_point)
	Sets the starting end point to starting_point for a Ray. More...
void	setStartingMaxDistance (const Real starting_max_distance)
	Sets the maximum distance this Ray should travel to starting_max_distance. More...
void	setStationary ()
	Sets the Ray to be stationary (max distance = 0). More...
void	invalidateStartingElem ()
	Invalidates a Ray's starting element. More...
void	invalidateStartingIncomingSide ()
	Invalidates a Ray's starting incoming side. More...
void	clearStartingInfo ()
	Clears the starting information set on the Ray: More...
void	resetCounters ()
	Clears the internal counters on the Ray so that the Ray can be traced again. More...
const Elem *	currentElem () const
	Gets the current element that the Ray is in. More...
unsigned short	currentIncomingSide () const
	Get a Ray's current incoming side. More...
bool	invalidCurrentIncomingSide () const
	Whether or not the Ray's current incoming side is invalid. More...
bool	endSet () const
	Whether or not the user has set an end point for this Ray. More...
bool	atEnd () const
	Whether or not the Ray is at the user-defined end point. More...
Point	endPoint () const
	Gets the user-set end point for the Ray, if set. More...
unsigned int	processorCrossings () const
	Gets the number of times this Ray has crossed a processor. More...
unsigned int	intersections () const
	Gets the number of intersections this Ray has done. More...
Real	distance () const
	Gets the distance this Ray has traveled. More...
Real	maxDistance () const
	Gets the max distance this Ray is allowed to travel. More...
bool	maxDistanceSet () const
	Whether or not the distance has been set via setStartingMaxDistance() More...
bool	stationary () const
bool	shouldContinue () const
	Whether or not this Ray should continue. More...
void	setShouldContinue (const bool should_continue)
	Sets whether or not this Ray should continue. More...
bool	trajectoryChanged () const
	Whether or not this Ray has had its trajectory changed. More...
unsigned int	trajectoryChanges () const
	Gets the number of trajectory changes this Ray has had. More...
std::string	getInfo () const
	Helper function for getting information about the Ray. More...
bool	hasTraced () const
	Whether or not a Ray has begun tracing. More...
const RayTracingStudy &	study () const
	Get the RayTracingStudy associated with this Ray. More...

Static Public Attributes
static const RayDataIndex	INVALID_RAY_DATA_INDEX = static_cast<RayDataIndex>(-1)
	Invalid index into a Ray's data. More...
static const RayID	INVALID_RAY_ID = static_cast<RayID>(-1)
	Invalid Ray ID. More...

Private Member Functions
void	changeID (const RayID id)
	Changes the Ray's ID. More...
void	invalidateCurrentElem ()
	Invalidates the Ray's current element. More...
void	setCurrentPoint (const Point &current_point)
	Sets the Ray's current point. More...
void	invalidateCurrentPoint ()
	Invalidates the Ray's current point. More...
void	setDirection (const Point &direction)
	Sets the Ray's direction. More...
void	invalidateDirection ()
	Invalidates the Ray's current direction. More...
void	setCurrentElem (const Elem *current_elem)
	Change a Ray's current elem. More...
void	setCurrentIncomingSide (const unsigned short current_incoming_side)
	Change a Ray's incoming side. More...
void	invalidateCurrentIncomingSide ()
	Invalidates the Ray's current incoming side. More...
void	setTrajectoryChanged (const bool trajectory_changed)
	Set whether or not this Ray has had its trajectory changed. More...
void	addProcessorCrossing ()
	Increment the Ray's processor crossing counter. More...
void	addIntersection ()
	Increment the Ray's intersection counter. More...
void	addTrajectoryChange ()
	Increment the Ray's trajectory change counter. More...
void	addDistance (const Real add_distance)
	Adds to the distance this Ray has traveled. More...
void	changeMaxDistance (const Real max_distance)
	Changes the Ray's max distance to be traveled. More...
void	invalidateMaxDistance ()
	Invalidates the Ray's max distance. More...
void	errorIfTracing (const std::string &reason) const
	Produces a useful error if a Ray has started tracing. More...
void	errorWhenInitializing (const std::string &reason) const
	Produces a useful error for use when initializing a Ray. More...
void	resetCountersInternal ()
	Reset all of the internal counters. More...
bool	equalityHelper (const Ray &other, const bool equal) const
	Helper for the equality operators. More...
void	clearStartingInfoInternal ()
	Clears the starting information. More...

Private Attributes
RayID	_id
	A unique ID for this Ray. More...
Point	_current_point
	Current point of the Ray. More...
Point	_direction
	Direction of the Ray. More...
const Elem *	_current_elem
	Current element that the Ray is in. More...
unsigned short	_current_incoming_side
	The side of _current_elem that the Ray is incoming on (if any). More...
bool	_end_set
	Whether or not the user has set an end point for this Ray (via limiting its distance with setStartingEndPoint()) More...
unsigned int	_processor_crossings
	Number of times this Ray has been communicated. More...
unsigned int	_intersections
	Number of intersections done for this Ray. More...
unsigned int	_trajectory_changes
	Number of times this Ray has had its trajectory changed. More...
bool	_trajectory_changed
	Whether or not this Ray had its trajectory changed (not sent in parallel) More...
Real	_distance
	Total distance this Ray has traveled. More...
Real	_max_distance
	Maximum distance the Ray is allowed to travel. More...
bool	_should_continue
	Wether or not the Ray should continue to be traced (not sent in parallel) More...
std::vector< RayData >	_data
	The data that is carried with the Ray This is mutable so that we can resize it if needed within const accessors. More...
std::vector< RayData >	_aux_data
	Auxiliary data that is carried with the ray This is mutable so that we can resize it if needed within const accessors. More...
RayTracingStudy &	_study
	The RayTracingStudy that owns this Ray (not sent in parallel) More...
long	padding [8]
	Extra padding to avoid false sharing. More...

Friends
class	TraceRay
class	Parallel::Packing< std::shared_ptr< Ray > >
class	TestRayLots
void	dataStore (std::ostream &stream, std::shared_ptr< Ray > &ray, void *context)
void	dataLoad (std::istream &stream, std::shared_ptr< Ray > &ray, void *context)

Detailed Description

Basic datastructure for a ray that will traverse the mesh.

Definition at line 56 of file Ray.h.

Constructor & Destructor Documentation

Ray() [1/4]

Ray::Ray	(	RayTracingStudy *	study,
		const RayID	id,
		const std::size_t	data_size,
		const std::size_t	aux_data_size,
		const bool	reset,
		const ConstructRayKey &
	)

Ray constructor for internal use only.

Even though this method is public, it in general CANNOT be used publicly. This is ONLY used internally and is protected by the ConstructRayKey. In order to construct a Ray as a user, use the RayTracingStudy::acquire{}() methods, such as RayTracingStudy::acquireRay().

Parameters

study	The study that owns the Ray
id	ID for the Ray
data_size	Size of data to initialize with zeros
aux_data_size	Size of aux data to initialize with zeros
reset	Whether or not to reset the Ray information

Definition at line 22 of file Ray.C.

  : _id(id),
    _current_point(RayTracingCommon::invalid_point),
    _direction(RayTracingCommon::invalid_point),
    _current_elem(nullptr),
    _current_incoming_side(RayTracingCommon::invalid_side),
    _end_set(false),
    _max_distance(std::numeric_limits<Real>::max()),
    _data(data_size, 0),
    _aux_data(aux_data_size, 0),
    _study(*study)
{
  resetCountersInternal();
}

Ray() [2/4]

Ray::Ray	(	const Ray *const	other,
		const ConstructRayKey &	key
	)

Copy constructor for internal use only.

Even though this method is public, it in general CANNOT be used publicly. This is ONLY used internally and is protected by the ConstructRayKey. In order to construct a Ray as a user, use the RayTracingStudy::acquire{}() methods, such as RayTracingStudy::acquireRay().

Resets the counters.

Definition at line 70 of file Ray.C.

  : Ray(&other->_study,
        other->_id,
        other->_data.size(),
        other->_aux_data.size(),
        /* reset = */ true,
        key)
{
  other->errorIfTracing("Cannot copy Ray");

  if (!other->invalidCurrentPoint())
    setStart(other->_current_point, other->_current_elem, other->_current_incoming_side);

  if (other->_end_set)
    setStartingEndPoint(other->endPoint());
  else
  {
    if (!other->invalidDirection())
      setStartingDirection(other->_direction);
    if (other->maxDistanceSet())
      _max_distance = other->_max_distance;
  }

  std::copy(other->_data.begin(), other->_data.end(), _data.begin());
  std::copy(other->_aux_data.begin(), other->_aux_data.end(), _aux_data.begin());
}

Ray() [3/4]

Ray::Ray ( )

delete

Deleted default constructor.

All Ray construction is handled internally within the RayTracingStudy via the RayTracingStudy::acquire{}() methods.

Ray() [4/4]

Ray::Ray ( const Ray &  other )

delete

Deleted copy constructor.

All Ray construction is handled internally within the RayTracingStudy via the RayTracingStudy::acquire{}() methods.

Member Function Documentation

addDistance()

void Ray::addDistance ( const Real  add_distance )

inlineprivate

Adds to the distance this Ray has traveled.

Definition at line 614 of file Ray.h.

{ _distance += add_distance; }

addIntersection()

void Ray::addIntersection ( )

inlineprivate

Increment the Ray's intersection counter.

Definition at line 604 of file Ray.h.

{ ++_intersections; }

addProcessorCrossing()

void Ray::addProcessorCrossing ( )

inlineprivate

Increment the Ray's processor crossing counter.

Definition at line 599 of file Ray.h.

{ ++_processor_crossings; }

addTrajectoryChange()

void Ray::addTrajectoryChange ( )

inlineprivate

Increment the Ray's trajectory change counter.

Definition at line 609 of file Ray.h.

{ ++_trajectory_changes; }

atEnd()

bool Ray::atEnd

(

)

const

Whether or not the Ray is at the user-defined end point.

This is only valid when the user set the trajectory of the Ray with setStartingEndPoint(), which internally set its maximum distance to the straight-line distance between start and end and set endSet() == true.

Definition at line 176 of file Ray.C.

Referenced by getInfo().

{
  if (!_end_set)
    mooseError("Cannot use Ray::atEnd() for a Ray that does not have an end set\n\n", getInfo());
  mooseAssert(_distance <= _max_distance + TOLERANCE * TOLERANCE, "Distance past max distance");

  return MooseUtils::absoluteFuzzyEqual(_distance, _max_distance);
}

auxData() [1/4]

std::vector< RayData > & Ray::auxData

(

)

Gets a writeable reference to the Ray's auxilary data.

If the aux data is not sized to the size as required by the study, this will resize the aux data.

Definition at line 437 of file Ray.C.

Referenced by auxData(), TestRayDataStudy::auxDataValue(), TestRayDataStudy::dataValue(), getInfo(), and TestRayDataStudy::onCompleteRay().

{
  mooseAssert(_aux_data.size() == 0 || _aux_data.size() == _study.rayAuxDataSize(),
              "Ray data size is not zero or the size required by study");
  _aux_data.resize(_study.rayAuxDataSize());
  return _aux_data;
}

auxData() [2/4]

const std::vector< RayData > & Ray::auxData

(

)

const

Gets a read only reference to the Ray's auxilary data.

If the aux data is not sized to the size as required by the study, this will resize the aux data.

Definition at line 446 of file Ray.C.

{
  mooseAssert(_aux_data.size() == 0 || _aux_data.size() == _study.rayAuxDataSize(),
              "Ray data size is not zero or the size required by study");
  _aux_data.resize(_study.rayAuxDataSize());
  return _aux_data;
}

auxData() [3/4]

RayData & Ray::auxData

(

const std::size_t

i

)

Gets a writeable reference to a component of the Ray's auxilary data.

If the aux data is not sized to the size as required by the study, this will resize the aux data.

Definition at line 455 of file Ray.C.

{
  mooseAssert(_study.rayAuxDataSize() > i, "Accessing Ray data out of range");
  return auxData()[i];
}

auxData() [4/4]

const RayData & Ray::auxData

(

const std::size_t

i

)

const

Gets a read only reference to a component of the Ray's auxilary data.

If the aux data is not sized to the size as required by the study, this will resize the aux data.

Definition at line 462 of file Ray.C.

{
  mooseAssert(_study.rayAuxDataSize() > i, "Accessing Ray data out of range");
  return auxData()[i];
}

changeDirection()

void Ray::changeDirection	(	const Point &	direction,
		const ChangeDirectionKey
	)

This method is for internal use only.

It is intended to be called only by RayBoundaryConditionBase::changeRayDirection().

If you wish to change a Ray's direction mid-trace in a RayBC, see RayBoundaryConditionBase::changeRayDirection() instead.

ChangeDirectionKey is constructable only by RayBC objects on purpose to limit usage of this method.

Definition at line 196 of file Ray.C.

{
  if (direction.absolute_fuzzy_equals(Point(0, 0, 0)))
    mooseError("Cannot set zero vector direction for a Ray\n\n", getInfo());

  _direction = direction.unit();
  _trajectory_changed = true;
}

changeID()

void Ray::changeID ( const RayID  id )

inlineprivate

Changes the Ray's ID.

Definition at line 546 of file Ray.h.

{ _id = id; }

changeMaxDistance()

void Ray::changeMaxDistance ( const Real  max_distance )

inlineprivate

Changes the Ray's max distance to be traveled.

Definition at line 618 of file Ray.h.

{ _max_distance = max_distance; }

changeStartDirection()

void Ray::changeStartDirection	(	const Point &	start,
		const Point &	direction,
		const ChangeStartDirectionKey
	)

This method is for internal use only.

It is intended to be called only by RayKernelBase::changeRay().

If you wish to change a Ray's direction mid-trace in a RayKernel, see RayKernelBase::changeRay() instead.

ChangeStartDirectionKey is constructable only by RayKernelBase objects on purpose to limit usage of this method.

Definition at line 206 of file Ray.C.

{
  if (direction.absolute_fuzzy_equals(Point(0, 0, 0)))
    mooseError("Cannot set zero vector direction for a Ray\n\n", getInfo());

  _current_point = start;
  _direction = direction.unit();
  _trajectory_changed = true;
}

clearStartingInfo()

void Ray::clearStartingInfo

(

)

Clears the starting information set on the Ray:

• Starting point
• Starting element
• Starting incoming side
• Starting direction
• Starting maximum distance

This can only be called before a Ray has begun tracing.

Definition at line 353 of file Ray.C.

{
  errorIfTracing("Cannot use Ray::clearStartingInfo()");
  clearStartingInfoInternal();
}

clearStartingInfoInternal()

void Ray::clearStartingInfoInternal ( )

private

Clears the starting information.

Definition at line 360 of file Ray.C.

Referenced by clearStartingInfo(), and reset().

{
  invalidateCurrentPoint();
  invalidateCurrentElem();
  invalidateCurrentIncomingSide();
  invalidateDirection();
  invalidateMaxDistance();
  _end_set = false;
}

currentElem()

const Elem* Ray::currentElem ( ) const

inline

Gets the current element that the Ray is in.

Before tracing, this is the starting element for the Ray.

During tracing:

• It is valid within RayKernels, because a Ray can only operate on a single element per segment.
• When used on boundaries (RayBCs), it is the element that the Ray actually traced through. When on a boundary, a RayBC may be applied to multiple elements when hitting a vertex or edge. Therefore, this will be only one of said elements.

Definition at line 425 of file Ray.h.

Referenced by getInfo().

{ return _current_elem; }

currentIncomingSide()

unsigned short Ray::currentIncomingSide ( ) const

inline

Get a Ray's current incoming side.

Before tracing, this is the starting incoming side (if any).

During and after tracing, this is ONLY guaranteed to be valid while executing RayKernels!

Definition at line 435 of file Ray.h.

Referenced by getInfo().

{ return _current_incoming_side; }

currentPoint()

const Point& Ray::currentPoint ( ) const

inline

Gets the point that the Ray is currently at.

Before a Ray is traced, this is the starting point of the Ray. While a Ray is being traced, this is the furthest point that the Ray has travelled. During RayKernel execution, this is the end of the segment. After a Ray has been traced, this is the point where the Ray was killed.

Definition at line 221 of file Ray.h.

Referenced by getInfo(), and TestPICRayStudy::maxDistance().

{ return _current_point; }

data() [1/4]

std::vector< RayData > & Ray::data

(

)

Gets a writeable reference to the Ray's data.

If the data is not sized to the size as required by the study, this will resize the data.

Definition at line 403 of file Ray.C.

Referenced by data(), getInfo(), and TestRayDataStudy::onCompleteRay().

{
  mooseAssert(_data.size() == 0 || _data.size() == _study.rayDataSize(),
              "Ray data size of " + std::to_string(_data.size()) +
                  " is not zero or the size required by the study of " +
                  std::to_string(_study.rayDataSize()));
  _data.resize(_study.rayDataSize());
  return _data;
}

data() [2/4]

const std::vector< RayData > & Ray::data

(

)

const

Gets a read only reference to the Ray's data.

If the data is not sized to the size as required by the study, this will resize the data.

Definition at line 414 of file Ray.C.

{
  mooseAssert(_data.size() == 0 || _data.size() == _study.rayDataSize(),
              "Ray data size is not zero or the size required by study");
  _data.resize(_study.rayDataSize());
  return _data;
}

data() [3/4]

RayData & Ray::data

(

const std::size_t

i

)

Gets a writeable reference to the Ray's data at an index.

If the data is not sized to the size as required by the study, this will resize the data.

Definition at line 423 of file Ray.C.

{
  mooseAssert(_study.rayDataSize() > i, "Accessing Ray data out of range");
  return data()[i];
}

data() [4/4]

const RayData & Ray::data

(

const std::size_t

i

)

const

Gets a read only reference to the Ray's data at an index.

If the data is not sized to the size as required by the study, this will resize the data.

Definition at line 430 of file Ray.C.

{
  mooseAssert(_study.rayDataSize() > i, "Accessing Ray data out of range");
  return data()[i];
}

direction()

const Point& Ray::direction ( ) const

inline

Gets the Ray's direction.

Definition at line 255 of file Ray.h.

Referenced by changeDirection(), changeStartDirection(), getInfo(), and setDirection().

{ return _direction; }

distance()

Real Ray::distance ( ) const

inline

Gets the distance this Ray has traveled.

Definition at line 488 of file Ray.h.

Referenced by TestRayDataStudy::dataValue(), and getInfo().

{ return _distance; }

endPoint()

Point Ray::endPoint

(

)

const

Gets the user-set end point for the Ray, if set.

Internally, we do not keep track of the end point. Instead, we set a maximum straight-line distance the Ray can travel until it hits its endpoint. With the current point, the distance, the maximum distance, and the direction, we can infer the user-set end point.

Definition at line 186 of file Ray.C.

Referenced by getInfo(), Ray(), and reset().

{
  if (!_end_set)
    mooseError("Cannot use Ray::endPoint() for a Ray that does not have an end set\n\n", getInfo());
  mooseAssert(_distance <= _max_distance + TOLERANCE * TOLERANCE, "Distance past max distance");

  return _current_point + (_max_distance - _distance) * _direction;
}

endSet()

bool Ray::endSet ( ) const

inline

Whether or not the user has set an end point for this Ray.

This is done by limiting the distance of the Ray in its set direction.

Definition at line 454 of file Ray.h.

Referenced by getInfo().

{ return _end_set; }

equalityHelper()

bool Ray::equalityHelper ( const Ray &  other, const bool  equal  ) const

private

Helper for the equality operators.

Definition at line 126 of file Ray.C.

Referenced by operator!=(), and operator==().

{
  if (this == &other)
    return equal;

  if (_id != other._id)
    return !equal;
  if (invalidCurrentPoint() != other.invalidCurrentPoint() ||
      !_current_point.absolute_fuzzy_equals(other._current_point))
    return !equal;
  if (invalidDirection() != other.invalidDirection() ||
      !_direction.absolute_fuzzy_equals(other._direction))
    return !equal;
  if (_current_elem != other._current_elem)
    return !equal;
  if (_current_incoming_side != other._current_incoming_side)
    return !equal;
  if (_end_set != other._end_set)
    return !equal;
  if (_processor_crossings != other._processor_crossings)
    return !equal;
  if (_intersections != other._intersections)
    return !equal;
  if (_trajectory_changes != other._trajectory_changes)
    return !equal;
  if (_trajectory_changed != other._trajectory_changed)
    return !equal;
  if (!MooseUtils::absoluteFuzzyEqual(_distance, other._distance))
    return !equal;
  if (!MooseUtils::absoluteFuzzyEqual(_max_distance, other._max_distance))
    return !equal;
  if (_should_continue != other._should_continue)
    return !equal;
  if (_data.size() != other._data.size())
    return !equal;
  for (std::size_t i = 0; i < _data.size(); ++i)
    if (!MooseUtils::absoluteFuzzyEqual(_data[i], other._data[i]))
      return !equal;
  if (_aux_data.size() != other._aux_data.size())
    return !equal;
  for (std::size_t i = 0; i < _aux_data.size(); ++i)
    if (!MooseUtils::absoluteFuzzyEqual(_aux_data[i], other._aux_data[i]))
      return !equal;
  if (&_study != &other._study)
    return !equal;

  return equal;
}

errorIfTracing()

void Ray::errorIfTracing ( const std::string &  reason ) const

private

Produces a useful error if a Ray has started tracing.

Definition at line 371 of file Ray.C.

Referenced by clearStartingInfo(), invalidateStartingElem(), invalidateStartingIncomingSide(), Ray(), reset(), setStart(), setStartingDirection(), setStartingEndPoint(), setStartingMaxDistance(), and setStationary().

{
  if (hasTraced())
    mooseError(reason, " after it has started tracing\n\n", getInfo());
}

errorWhenInitializing()

void Ray::errorWhenInitializing ( const std::string &  reason ) const

private

Produces a useful error for use when initializing a Ray.

Definition at line 378 of file Ray.C.

Referenced by setStart(), setStartingDirection(), setStartingEndPoint(), setStartingMaxDistance(), and setStationary().

{
  mooseError("While initializing starting information for a Ray:\n\n", reason, "\n\n", getInfo());
}

getInfo()

std::string Ray::getInfo

(

)

const

Helper function for getting information about the Ray.

Definition at line 469 of file Ray.C.

Referenced by atEnd(), changeDirection(), changeStartDirection(), endPoint(), errorIfTracing(), errorWhenInitializing(), resetCounters(), and RepeatableRayStudyBase::verifyReplicatedRays().

{
  std::ostringstream oss;

  oss << "Ray information with " << _study.type() << " '" << _study.name() << "' on pid "
      << _study.comm().rank() << "\n";
  oss << "  this = " << this << "\n";
  oss << "  id() = " << id() << "\n";
  if (_study.useRayRegistration() && !invalidID())
    oss << "  _study.registeredRayName(id()) = " << _study.registeredRayName(id()) << "\n";
  oss << "  currentPoint() = ";
  if (invalidCurrentPoint())
    oss << "invalid point\n";
  else
    oss << currentPoint() << "\n";
  oss << "  direction() = ";
  if (invalidDirection())
    oss << "invalid point\n";
  else
    oss << direction() << "\n";
  oss << "  currentIncomingSide() = ";
  if (invalidCurrentIncomingSide())
    oss << "invalid side\n";
  else
    oss << currentIncomingSide() << "\n";
  oss << "  endSet() = " << (endSet() ? "true" : "false") << "\n";
  if (endSet())
  {
    oss << "  endPoint() = " << endPoint() << "\n";
    oss << "  atEnd() = " << (atEnd() ? "true" : "false") << "\n";
  }
  oss << "  distance() = " << distance() << "\n";
  oss << "  maxDistance() = " << maxDistance() << "\n";
  if (currentElem())
  {
    oss << "  currentElem()->id() = " << currentElem()->id() << "\n";
    oss << "  currentElem()->processor_id() = " << currentElem()->processor_id() << "\n";
  }
  else
    oss << "  currentElem()->id() = invalid\n";
  oss << "  processorCrossings() = " << processorCrossings() << "\n";
  oss << "  intersections() = " << intersections() << "\n";
  oss << "  trajectoryChanges() = " << trajectoryChanges() << "\n";
  oss << "  shouldContinue() = " << (shouldContinue() ? "true" : "false") << "\n";
  oss << "  trajectoryChanged() = " << (trajectoryChanged() ? "true" : "false") << "\n";
  oss << "  data() = ";
  for (std::size_t i = 0; i < data().size(); ++i)
    oss << "\n    '" << _study.getRayDataName(i) << "' = " << data(i);
  oss << "\n";
  oss << "  auxData() = ";
  for (std::size_t i = 0; i < auxData().size(); ++i)
    oss << "\n    '" << _study.getRayAuxDataName(i) << "' = " << auxData(i);
  oss << "\n";

  return oss.str();
}

hasTraced()

bool Ray::hasTraced ( ) const

inline

Whether or not a Ray has begun tracing.

Definition at line 532 of file Ray.h.

Referenced by errorIfTracing().

  {
    return (bool)_distance || (bool)_processor_crossings || (bool)_intersections;
  }

id()

RayID Ray::id ( ) const

inline

Gets the Ray's ID.

Definition at line 207 of file Ray.h.

Referenced by changeID(), and getInfo().

{ return _id; }

intersections()

unsigned int Ray::intersections ( ) const

inline

Gets the number of intersections this Ray has done.

Definition at line 483 of file Ray.h.

Referenced by getInfo().

{ return _intersections; }

invalidateCurrentElem()

void Ray::invalidateCurrentElem ( )

inlineprivate

Invalidates the Ray's current element.

Definition at line 551 of file Ray.h.

Referenced by clearStartingInfoInternal(), and invalidateStartingElem().

{ _current_elem = nullptr; }

invalidateCurrentIncomingSide()

void Ray::invalidateCurrentIncomingSide ( )

inlineprivate

Invalidates the Ray's current incoming side.

Definition at line 586 of file Ray.h.

Referenced by clearStartingInfoInternal(), and invalidateStartingIncomingSide().

{ _current_incoming_side = RayTracingCommon::invalid_side; }

invalidateCurrentPoint()

void Ray::invalidateCurrentPoint ( )

inlineprivate

Invalidates the Ray's current point.

Definition at line 560 of file Ray.h.

Referenced by clearStartingInfoInternal().

{ _current_point = RayTracingCommon::invalid_point; }

invalidateDirection()

void Ray::invalidateDirection ( )

inlineprivate

Invalidates the Ray's current direction.

Definition at line 569 of file Ray.h.

Referenced by clearStartingInfoInternal().

{ _direction = RayTracingCommon::invalid_point; }

invalidateMaxDistance()

void Ray::invalidateMaxDistance ( )

inlineprivate

Invalidates the Ray's max distance.

Definition at line 622 of file Ray.h.

Referenced by clearStartingInfoInternal().

{ _max_distance = std::numeric_limits<Real>::max(); }

invalidateStartingElem()

void Ray::invalidateStartingElem

(

)

Invalidates a Ray's starting element.

This is useful after the mesh has changed due to adaptivity, in which the starting element may no longer be valid.

This can only be called before a Ray has begun tracing.

Definition at line 339 of file Ray.C.

{
  errorIfTracing("Cannot use Ray::invalidateStartingElem()");
  invalidateCurrentElem();
}

invalidateStartingIncomingSide()

void Ray::invalidateStartingIncomingSide

(

)

Invalidates a Ray's starting incoming side.

This is useful after the mesh has changed due to adaptivity, in which the incoming side may no longer be valid.

This can only be called before a Ray has begun tracing.

Definition at line 346 of file Ray.C.

{
  errorIfTracing("Cannot use Ray::invalidateStartingIncomingSide()");
  invalidateCurrentIncomingSide();
}

invalidCurrentIncomingSide()

bool Ray::invalidCurrentIncomingSide ( ) const

inline

Whether or not the Ray's current incoming side is invalid.

Before tracing, this is the starting incoming side (if any).

During and after tracing, this is ONLY guaranteed to be valid while executing RayKernels!

Definition at line 444 of file Ray.h.

Referenced by getInfo(), and setStart().

  {
    return _current_incoming_side == RayTracingCommon::invalid_side;
  }

invalidCurrentPoint()

bool Ray::invalidCurrentPoint ( ) const

inline

Whether or not the point that the Ray is currently at is valid.

Definition at line 225 of file Ray.h.

Referenced by equalityHelper(), getInfo(), Ray(), reset(), setStart(), setStartingDirection(), setStartingEndPoint(), setStartingMaxDistance(), and setStationary().

{ return _current_point == RayTracingCommon::invalid_point; }

invalidDirection()

bool Ray::invalidDirection ( ) const

inline

Whether or not the Ray's direction is set to invalid.

Definition at line 259 of file Ray.h.

Referenced by equalityHelper(), getInfo(), Ray(), reset(), setStartingDirection(), setStartingEndPoint(), and setStationary().

{ return _direction == RayTracingCommon::invalid_point; }

invalidID()

bool Ray::invalidID ( ) const

inline

Whether or not the Ray's ID is invalid.

Definition at line 211 of file Ray.h.

Referenced by getInfo().

{ return _id == INVALID_RAY_ID; }

maxDistance()

Real Ray::maxDistance ( ) const

inline

Gets the max distance this Ray is allowed to travel.

This may be set internally to || end - start || in the case that the user initialized the Ray with setStartingEndPoint().

Definition at line 495 of file Ray.h.

Referenced by getInfo().

{ return _max_distance; }

maxDistanceSet()

bool Ray::maxDistanceSet ( ) const

inline

Whether or not the distance has been set via setStartingMaxDistance()

Definition at line 499 of file Ray.h.

Referenced by Ray(), reset(), and setStartingEndPoint().

{ return _max_distance != std::numeric_limits<Real>::max(); }

operator!=()

bool Ray::operator!= ( const Ray &  other ) const

inline

Non-equal operator.

This will perform "fuzzy" equals checks on the points and data.

Definition at line 197 of file Ray.h.

{ return equalityHelper(other, false); }

operator=()

Ray& Ray::operator= ( const Ray &  )

delete

Deleted copy operator.

General Ray modification is handled internally within the RayTracingStudy via the RayTracingStudy::acquire{}() methods.

operator==()

bool Ray::operator== ( const Ray &  other ) const

inline

Equality operator.

This will perform "fuzzy" equals checks on the points and data.

Definition at line 191 of file Ray.h.

{ return equalityHelper(other, true); }

processorCrossings()

unsigned int Ray::processorCrossings ( ) const

inline

Gets the number of times this Ray has crossed a processor.

Definition at line 478 of file Ray.h.

Referenced by getInfo().

{ return _processor_crossings; }

reset() [1/2]

void Ray::reset	(	RayTracingStudy *	study,
		const RayID	id,
		const std::size_t	data_size,
		const std::size_t	aux_data_size,
		const bool	reset,
		const ConstructRayKey &
	)

Resets a Ray for internal use only.

Used by the SharedPool to reset a Ray with these forwarded arguments.

Even though this method is public, it in general CANNOT be used publicly. This is ONLY used internally and is protected by the ConstructRayKey. In order to construct a Ray as a user, use the RayTracingStudy::acquire{}() methods, such as RayTracingStudy::acquireRay().

Parameters

study	The study that owns the Ray
id	ID for the Ray
data_size	Size of data to initialize with zeros
aux_data_size	Size of aux data to initialize with zeros
reset	Whether or not to reset the Ray information

reset() [2/2]

void Ray::reset	(	const Ray *const	other,
		const ConstructRayKey &
	)

Resets a Ray from another Ray for internal use only.

Used by the SharedPool to reset a Ray from another.

Even though this method is public, it in general CANNOT be used publicly. This is ONLY used internally and is protected by the ConstructRayKey. In order to construct a Ray as a user, use the RayTracingStudy::acquire{}() methods, such as RayTracingStudy::acquireRay().

Resets the counters.

Definition at line 98 of file Ray.C.

{
  other->errorIfTracing("Cannot copy Ray");
  mooseAssert(&other->_study == &_study, "Cannot copy Ray from different study");

  clearStartingInfoInternal();
  resetCountersInternal();

  _id = other->_id;

  if (!other->invalidCurrentPoint())
    setStart(other->_current_point, other->_current_elem, other->_current_incoming_side);

  if (other->_end_set)
    setStartingEndPoint(other->endPoint());
  else
  {
    if (!other->invalidDirection())
      setStartingDirection(other->_direction);
    if (other->maxDistanceSet())
      _max_distance = other->_max_distance;
  }

  _data = other->_data;
  _aux_data = other->_aux_data;
}

resetCounters()

void Ray::resetCounters

(

)

Clears the internal counters on the Ray so that the Ray can be traced again.

Can only be used within generateRays().

Definition at line 384 of file Ray.C.

{
  if (!_study.currentlyGenerating())
    mooseError("Ray::resetCounters() can only be used during generateRays()\n\n", getInfo());
  resetCountersInternal();
}

resetCountersInternal()

void Ray::resetCountersInternal ( )

private

Reset all of the internal counters.

Definition at line 392 of file Ray.C.

Referenced by Ray(), reset(), and resetCounters().

{
  _processor_crossings = 0;
  _intersections = 0;
  _trajectory_changes = 0;
  _distance = 0;
  _trajectory_changed = false;
  _should_continue = true;
}

setCurrentElem()

void Ray::setCurrentElem ( const Elem *  current_elem )

inlineprivate

Change a Ray's current elem.

Definition at line 574 of file Ray.h.

{ _current_elem = current_elem; }

setCurrentIncomingSide()

void Ray::setCurrentIncomingSide ( const unsigned short  current_incoming_side )

inlineprivate

Change a Ray's incoming side.

Definition at line 579 of file Ray.h.

  {
    _current_incoming_side = current_incoming_side;
  }

setCurrentPoint()

void Ray::setCurrentPoint ( const Point &  current_point )

inlineprivate

Sets the Ray's current point.

Definition at line 556 of file Ray.h.

{ _current_point = current_point; }

setDirection()

void Ray::setDirection ( const Point &  direction )

inlineprivate

Sets the Ray's direction.

Definition at line 565 of file Ray.h.

{ _direction = direction; }

setShouldContinue()

void Ray::setShouldContinue ( const bool  should_continue )

inline

Sets whether or not this Ray should continue.

Definition at line 513 of file Ray.h.

{ _should_continue = should_continue; }

setStart()

void Ray::setStart	(	const Point &	starting_point,
		const Elem *	starting_elem = nullptr,
		const unsigned short	starting_incoming_side = RayTracingCommon::invalid_side
	)

Sets the information pretaining to the start point for the Ray.

This MUST be called before setStartingDirection(), setStartingEndPoint(), or setStartingMaxDistance(). It cannot be called after a Ray has begun tracing.

Parameters

starting_point	The starting point
starting_elem	The starting element (if known)
starting_incoming_side	The starting incoming side (if known and if the Ray starts on a side of starting_elem

Definition at line 219 of file Ray.C.

Referenced by Ray(), and reset().

{
  mooseAssert(starting_point != RayTracingCommon::invalid_point, "Invalid point");
  errorIfTracing("Cannot use Ray::setStart()");
  if (!invalidCurrentPoint() && !_current_point.absolute_fuzzy_equals(starting_point))
    errorWhenInitializing("Starting point was already set via Ray::setStart() and is being changed."
                          "\n\nYou may only call Ray::setStart() after it has been called once to"
                          "\nchange the starting element and starting incoming side."
                          "\n\nYou may also clear the starting info via Ray::clearStartingInfo().");

  _current_point = starting_point;
  _current_elem = starting_elem;
  _current_incoming_side = starting_incoming_side;

  if (_study.verifyRays())
  {
    if (!_study.looseBoundingBox().contains_point(starting_point))
      errorWhenInitializing("Mesh does not contain starting point.");
    if (starting_elem)
    {
      mooseAssert(_study.meshBase().query_elem_ptr(starting_elem->id()) == starting_elem,
                  "Element is not owned by the mesh");
      if (!starting_elem->active())
        errorWhenInitializing("Starting element is not active.");
    }

    bool non_planar_start = false;

    if (!invalidCurrentIncomingSide())
    {
      if (!starting_elem)
        errorWhenInitializing("Starting incoming side is set but starting element is not set.");
      if (starting_elem->n_sides() < starting_incoming_side)
        errorWhenInitializing("Starting incoming side is not valid for its starting element.");

      non_planar_start = _study.sideIsNonPlanar(starting_elem, starting_incoming_side);
      if (!non_planar_start &&
          !starting_elem->build_side_ptr(starting_incoming_side)->contains_point(starting_point))
        errorWhenInitializing("Starting incoming side does not contain the starting point.");
    }

    if (starting_elem && !non_planar_start && !starting_elem->contains_point(starting_point))
      errorWhenInitializing("Starting element does not contain the starting point.");
  }
}

setStartingDirection()

void Ray::setStartingDirection

(

const Point &

starting_direction

)

Sets the starting direction to starting_direction for a Ray.

This MUST be called after setStart(). It cannot be used with setStartingEndPoint(), which sets the direction internally. It cannot be called after a Ray has begun tracing.

Definition at line 268 of file Ray.C.

Referenced by Ray(), reset(), and setStartingEndPoint().

{
  errorIfTracing("Cannot use Ray::setStartingDirection()");
  if (invalidCurrentPoint())
    errorWhenInitializing("Cannot use Ray::setStartingDirection() before Ray::setStart().");
  if (!invalidDirection())
    errorWhenInitializing(
        "Cannot change a Ray's starting direction using Ray::setStartingDirection()"
        "\nafter it has already been set."
        "\n\nYou must first clear the starting info using Ray::clearStartingInfo().");
  if (starting_direction.absolute_fuzzy_equals(Point(0, 0, 0)))
    errorWhenInitializing("Starting direction in Ray::setStartingDirection() is the zero vector.");

  _direction = starting_direction.unit();
}

setStartingEndPoint()

void Ray::setStartingEndPoint

(

const Point &

starting_end_point

)

Sets the starting end point to starting_point for a Ray.

This MUST be called after setStart(). It cannot be used with setStartingDirection(). It cannot be called after a Ray has begun tracing.

Internally, this sets the direction to be currentPoint() -> starting_direction, and sets the maximum distance to || starting_direction - currentPoint() ||.

Definition at line 285 of file Ray.C.

Referenced by Ray(), and reset().

{
  errorIfTracing("Cannot use Ray::setStartingEndPoint()");
  if (invalidCurrentPoint())
    errorWhenInitializing("Cannot use Ray::setStartingEndPoint() before Ray::setStart().");
  if (_current_point.absolute_fuzzy_equals(starting_end_point))
    errorWhenInitializing("End point is equal to the start point in Ray::setStartingEndPoint().");
  if (!invalidDirection())
    errorWhenInitializing("Cannot use Ray::setStartingEndPoint() after Ray::setStartingDirection()."
                          "\n\nClear the starting information with Ray::clearStartingInfo().");
  if (maxDistanceSet())
    errorWhenInitializing(
        "Cannot use Ray::setStartingEndPoint() after Ray::setStartingMaxDistance().");

  if (_study.verifyRays() && !_study.looseBoundingBox().contains_point(starting_end_point))
    errorWhenInitializing("End point is not within the mesh for Ray::setStartingEndPoint().");

  Point difference = starting_end_point;
  difference -= _current_point;
  setStartingMaxDistance(difference.norm());
  setStartingDirection(difference);
  _end_set = true;
}

setStartingMaxDistance()

void Ray::setStartingMaxDistance

(

const Real

starting_max_distance

)

Sets the maximum distance this Ray should travel to starting_max_distance.

This MUST be called after setStart(). It cannot be used with setStartingEndPoint(). It cannot be called after a Ray has begun tracing.

If setting a Ray's trajectory with setStartingEndPoint(), the max distance is set internally to be || end - start ||.

Can only be called before a Ray has started to be traced!

Definition at line 310 of file Ray.C.

Referenced by setStartingEndPoint().

{
  errorIfTracing("Cannot use Ray::setStartingMaxDistance()");
  if (invalidCurrentPoint())
    errorWhenInitializing("Cannot use Ray::setStartingMaxDistance() before Ray::setStart().");
  if (starting_max_distance <= 0)
    errorWhenInitializing("Starting max distance is <= 0 in Ray::setStartingMaxDistance().");
  if (_end_set)
    errorWhenInitializing(
        "Cannot use Ray::setStartingMaxDistance() after Ray::setStartingEndPoint().");

  _max_distance = starting_max_distance;
}

setStationary()

void Ray::setStationary

(

)

Sets the Ray to be stationary (max distance = 0).

This MUST be called after setStart(). It cannot be used with setStartingEndPoint(). It cannot be called after a Ray has begun tracing.

Can only be called before a Ray has started to be traced!

Definition at line 325 of file Ray.C.

{
  errorIfTracing("Cannot use Ray::setStationary()");
  if (invalidCurrentPoint())
    errorWhenInitializing("Cannot use Ray::setStationary() before Ray::setStart()");
  if (_end_set)
    errorWhenInitializing("Cannot use Ray::setStationary() after Ray::setStartingEndPoint()");
  if (!invalidDirection())
    errorWhenInitializing("Cannot use Ray::setStationary() with Ray::setStartingDirection()");
  _max_distance = 0;
  mooseAssert(stationary(), "Stationary not set");
}

setTrajectoryChanged()

void Ray::setTrajectoryChanged ( const bool  trajectory_changed )

inlineprivate

Set whether or not this Ray has had its trajectory changed.

Definition at line 591 of file Ray.h.

  {
    _trajectory_changed = trajectory_changed;
  }

shouldContinue()

bool Ray::shouldContinue ( ) const

inline

Whether or not this Ray should continue.

Definition at line 509 of file Ray.h.

Referenced by getInfo().

{ return _should_continue; }

stationary()

bool Ray::stationary ( ) const

inline

Returns

Whether or not the Ray is set to be stationary

Definition at line 738 of file Ray.h.

Referenced by setStationary().

{
  const bool stationary = _max_distance == 0;
  if (stationary)
    mooseAssert(_intersections == 0, "Should be zero");
  return stationary;
}

study()

const RayTracingStudy& Ray::study ( ) const

inline

Get the RayTracingStudy associated with this Ray.

Definition at line 540 of file Ray.h.

{ return _study; }

trajectoryChanged()

bool Ray::trajectoryChanged ( ) const

inline

Whether or not this Ray has had its trajectory changed.

Definition at line 518 of file Ray.h.

Referenced by getInfo().

{ return _trajectory_changed; }

trajectoryChanges()

unsigned int Ray::trajectoryChanges ( ) const

inline

Gets the number of trajectory changes this Ray has had.

Definition at line 522 of file Ray.h.

Referenced by getInfo().

{ return _trajectory_changes; }

Friends And Related Function Documentation

dataLoad

void dataLoad ( std::istream &  stream, std::shared_ptr< Ray > &  ray, void *  context  )

friend

Definition at line 724 of file Ray.C.

{
  mooseAssert(context, "Missing RayTracingStudy context");
  RayTracingStudy * study = static_cast<RayTracingStudy *>(context);

  RayID id;
  loadHelper(stream, id, context);
  ray = study->acquireRayInternal(id,
                                  /* data_size = */ 0,
                                  /* aux_data_size = */ 0,
                                  /* reset = */ true,
                                  RayTracingStudy::AcquireRayInternalKey());

  loadHelper(stream, ray->_current_point, context);
  loadHelper(stream, ray->_direction, context);
  dof_id_type current_elem_id;
  loadHelper(stream, current_elem_id, context);
  ray->_current_elem = study->meshBase().query_elem_ptr(current_elem_id);
  loadHelper(stream, ray->_current_incoming_side, context);
  loadHelper(stream, ray->_end_set, context);
  loadHelper(stream, ray->_processor_crossings, context);
  loadHelper(stream, ray->_intersections, context);
  loadHelper(stream, ray->_trajectory_changes, context);
  loadHelper(stream, ray->_trajectory_changed, context);
  loadHelper(stream, ray->_distance, context);
  loadHelper(stream, ray->_max_distance, context);
  loadHelper(stream, ray->_should_continue, context);
  loadHelper(stream, ray->_data, context);
  loadHelper(stream, ray->_aux_data, context);

  if (ray->hasTraced())
    mooseAssert(!study->currentlyGenerating() && !study->currentlyPropagating(),
                "Cannot not load a Ray that has already traced during generation or propagation; "
                "reset the Ray first");
}

dataStore

void dataStore ( std::ostream &  stream, std::shared_ptr< Ray > &  ray, void *  context  )

friend

Definition at line 699 of file Ray.C.

{
  mooseAssert(ray, "Null ray");
  mooseAssert(context, "Missing RayTracingStudy context");
  mooseAssert(static_cast<RayTracingStudy *>(context) == &ray->study(), "Different study");

  storeHelper(stream, ray->_id, context);
  storeHelper(stream, ray->_current_point, context);
  storeHelper(stream, ray->_direction, context);
  auto current_elem_id = ray->currentElem() ? ray->currentElem()->id() : DofObject::invalid_id;
  storeHelper(stream, current_elem_id, context);
  storeHelper(stream, ray->_current_incoming_side, context);
  storeHelper(stream, ray->_end_set, context);
  storeHelper(stream, ray->_processor_crossings, context);
  storeHelper(stream, ray->_intersections, context);
  storeHelper(stream, ray->_trajectory_changes, context);
  storeHelper(stream, ray->_trajectory_changed, context);
  storeHelper(stream, ray->_distance, context);
  storeHelper(stream, ray->_max_distance, context);
  storeHelper(stream, ray->_should_continue, context);
  storeHelper(stream, ray->_data, context);
  storeHelper(stream, ray->_aux_data, context);
}

Parallel::Packing< std::shared_ptr< Ray > >

friend class Parallel::Packing< std::shared_ptr< Ray > >

friend

Definition at line 729 of file Ray.h.

TestRayLots

friend class TestRayLots

friend

Definition at line 731 of file Ray.h.

TraceRay

friend class TraceRay

friend

Definition at line 727 of file Ray.h.

Member Data Documentation

_aux_data

std::vector<RayData> Ray::_aux_data

mutableprivate

Auxiliary data that is carried with the ray This is mutable so that we can resize it if needed within const accessors.

Definition at line 718 of file Ray.h.

Referenced by auxData(), equalityHelper(), Ray(), and reset().

_current_elem

const Elem* Ray::_current_elem

private

Current element that the Ray is in.

Before tracing, this is the starting element for the Ray.

During tracing:

• It is valid within RayKernels, because a Ray can only operate on a single element per segment.
• When used on boundaries (RayBCs), it is the element that the Ray actually traced through. When on a boundary, a RayBC may be applied to multiple elements when hitting a vertex or edge. Therefore, this will be only one of said elements.

Definition at line 677 of file Ray.h.

Referenced by currentElem(), equalityHelper(), invalidateCurrentElem(), Ray(), reset(), setCurrentElem(), and setStart().

_current_incoming_side

unsigned short Ray::_current_incoming_side

private

The side of _current_elem that the Ray is incoming on (if any).

Before tracing, this is the starting incoming side (if any).

During tracing, this is ONLY guaranteed to be valid during the execution of RayKernels!

Definition at line 687 of file Ray.h.

Referenced by currentIncomingSide(), equalityHelper(), invalidateCurrentIncomingSide(), invalidCurrentIncomingSide(), Ray(), reset(), setCurrentIncomingSide(), and setStart().

_current_point

Point Ray::_current_point

private

Current point of the Ray.

Before tracing, this is the starting point for the Ray. During tracing, this is the furthest ahead that a Ray has traced. For example, when on a segment in a RayKernel, this will be end of said segment. After tracing, this is where the Ray ended.

Definition at line 659 of file Ray.h.

Referenced by changeStartDirection(), currentPoint(), endPoint(), equalityHelper(), invalidateCurrentPoint(), invalidCurrentPoint(), Ray(), reset(), setCurrentPoint(), setStart(), and setStartingEndPoint().

_data

std::vector<RayData> Ray::_data

mutableprivate

The data that is carried with the Ray This is mutable so that we can resize it if needed within const accessors.

Definition at line 714 of file Ray.h.

Referenced by data(), equalityHelper(), Ray(), and reset().

_direction

Point Ray::_direction

private

Direction of the Ray.

Definition at line 662 of file Ray.h.

Referenced by changeDirection(), changeStartDirection(), direction(), endPoint(), equalityHelper(), invalidateDirection(), invalidDirection(), Ray(), reset(), setDirection(), and setStartingDirection().

_distance

Real Ray::_distance

private

Total distance this Ray has traveled.

Definition at line 705 of file Ray.h.

Referenced by addDistance(), atEnd(), distance(), endPoint(), equalityHelper(), hasTraced(), and resetCountersInternal().

_end_set

bool Ray::_end_set

private

Whether or not the user has set an end point for this Ray (via limiting its distance with setStartingEndPoint())

Definition at line 691 of file Ray.h.

Referenced by atEnd(), clearStartingInfoInternal(), endPoint(), endSet(), equalityHelper(), Ray(), reset(), setStartingEndPoint(), setStartingMaxDistance(), and setStationary().

_id

RayID Ray::_id

private

A unique ID for this Ray.

Definition at line 649 of file Ray.h.

Referenced by changeID(), equalityHelper(), id(), invalidID(), and reset().

_intersections

unsigned int Ray::_intersections

private

Number of intersections done for this Ray.

Definition at line 697 of file Ray.h.

Referenced by addIntersection(), equalityHelper(), hasTraced(), intersections(), resetCountersInternal(), and stationary().

_max_distance

Real Ray::_max_distance

private

Maximum distance the Ray is allowed to travel.

Definition at line 707 of file Ray.h.

Referenced by atEnd(), changeMaxDistance(), endPoint(), equalityHelper(), invalidateMaxDistance(), maxDistance(), maxDistanceSet(), Ray(), reset(), setStartingMaxDistance(), setStationary(), and stationary().

_processor_crossings

unsigned int Ray::_processor_crossings

private

Number of times this Ray has been communicated.

Definition at line 694 of file Ray.h.

Referenced by addProcessorCrossing(), equalityHelper(), hasTraced(), processorCrossings(), and resetCountersInternal().

_should_continue

bool Ray::_should_continue

private

Wether or not the Ray should continue to be traced (not sent in parallel)

Definition at line 710 of file Ray.h.

Referenced by equalityHelper(), resetCountersInternal(), setShouldContinue(), and shouldContinue().

_study

RayTracingStudy& Ray::_study

private

The RayTracingStudy that owns this Ray (not sent in parallel)

Definition at line 721 of file Ray.h.

Referenced by auxData(), data(), equalityHelper(), getInfo(), reset(), resetCounters(), setStart(), setStartingEndPoint(), and study().

_trajectory_changed

bool Ray::_trajectory_changed

private

Whether or not this Ray had its trajectory changed (not sent in parallel)

Definition at line 702 of file Ray.h.

Referenced by changeDirection(), changeStartDirection(), equalityHelper(), resetCountersInternal(), setTrajectoryChanged(), and trajectoryChanged().

_trajectory_changes

unsigned int Ray::_trajectory_changes

private

Number of times this Ray has had its trajectory changed.

Definition at line 700 of file Ray.h.

Referenced by addTrajectoryChange(), equalityHelper(), resetCountersInternal(), and trajectoryChanges().

INVALID_RAY_DATA_INDEX

const RayDataIndex Ray::INVALID_RAY_DATA_INDEX = static_cast<RayDataIndex>(-1)

static

Invalid index into a Ray's data.

Definition at line 200 of file Ray.h.

Referenced by RayTracingStudy::getRayDataIndexInternal(), RayDataValue::initialize(), ChangeRayRayBCTest::onBoundary(), ChangeRayRayKernelTest::onSegment(), and RayTracingMeshOutput::setupEquationSystem().

INVALID_RAY_ID

const RayID Ray::INVALID_RAY_ID = static_cast<RayID>(-1)

static

Invalid Ray ID.

Definition at line 202 of file Ray.h.

Referenced by RayDataValue::getValue(), RayIntegralValue::initialize(), invalidID(), RayTracingStudy::registeredRayID(), RayTracingStudy::registeredRaySetup(), and TraceData::TraceData().

padding

long Ray::padding[8]

private

Extra padding to avoid false sharing.

Definition at line 724 of file Ray.h.

---

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

• ray_tracing/include/raytracing/Ray.h
• ray_tracing/src/raytracing/Ray.C