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

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

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

Private Attributes
RayID	_id
	A unique ID for this Ray.
Point	_current_point
	Current point of the Ray.
Point	_direction
	Direction of the Ray.
const Elem *	_current_elem
	Current element that the Ray is in.
unsigned short	_current_incoming_side
	The side of _current_elem that the Ray is incoming on (if any).
bool	_trajectory_changed
	Whether or not this Ray had its trajectory changed (not sent in parallel)
bool	_end_set
	Whether or not the user has set an end point for this Ray (via limiting its distance with setStartingEndPoint())
bool	_should_continue
	Wether or not the Ray should continue to be traced (not sent in parallel)
unsigned int	_processor_crossings
	Number of times this Ray has been communicated.
unsigned int	_intersections
	Number of intersections done for this Ray.
unsigned int	_trajectory_changes
	Number of times this Ray has had its trajectory changed.
Real	_distance
	Total distance this Ray has traveled.
Real	_max_distance
	Maximum distance the Ray is allowed to travel.
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.
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.
RayTracingStudy &	_study
	The RayTracingStudy that owns this Ray (not sent in parallel)

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 57 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 638 of file Ray.h.

{ _distance += add_distance; }

addIntersection()

void Ray::addIntersection ( )

inlineprivate

Increment the Ray's intersection counter.

Definition at line 628 of file Ray.h.

{ ++_intersections; }

addProcessorCrossing()

void Ray::addProcessorCrossing ( )

inlineprivate

Increment the Ray's processor crossing counter.

Definition at line 623 of file Ray.h.

{ ++_processor_crossings; }

addTrajectoryChange()

void Ray::addTrajectoryChange ( )

inlineprivate

Increment the Ray's trajectory change counter.

Definition at line 633 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.

{
  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);
}

Referenced by getInfo().

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 451 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;
}

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

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 460 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 469 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 476 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 570 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 642 of file Ray.h.

{ _max_distance = max_distance; }

changePointElemSide()

void Ray::changePointElemSide	(	const Point &	point,
		const Elem &	elem,
		const unsigned int	side,
		const ChangePointElemSideKey
	)

This method is for internal use only.

It is intended to be called only by PeriodicRayBC::onBoundary().

ChangePointElemSideKey is constructable only by PeriodicRayBC objects on purpose to limit usage of this method.

Definition at line 219 of file Ray.C.

{
  mooseAssert(!_trajectory_changed, "Should not have already changed");
 
  _current_point = point;
  _current_elem = &elem;
  _current_incoming_side = side;
  _trajectory_changed = true;
}

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 367 of file Ray.C.

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

clearStartingInfoInternal()

void Ray::clearStartingInfoInternal ( )

private

Clears the starting information.

Definition at line 374 of file Ray.C.

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

Referenced by clearStartingInfo(), and reset().

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 449 of file Ray.h.

{ return _current_elem; }

Referenced by getInfo().

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 459 of file Ray.h.

{ return _current_incoming_side; }

Referenced by getInfo().

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 233 of file Ray.h.

{ return _current_point; }

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

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 417 of file Ray.C.

{
  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;
}

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

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 428 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 437 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 444 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 279 of file Ray.h.

{ return _direction; }

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

distance()

Real Ray::distance ( ) const

inline

Gets the distance this Ray has traveled.

Definition at line 512 of file Ray.h.

{ return _distance; }

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

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.

{
  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;
}

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

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 478 of file Ray.h.

{ return _end_set; }

Referenced by getInfo().

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.

{
  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 (_trajectory_changed != other._trajectory_changed)
    return !equal;
  if (_end_set != other._end_set)
    return !equal;
  if (_should_continue != other._should_continue)
    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 (!MooseUtils::absoluteFuzzyEqual(_distance, other._distance))
    return !equal;
  if (!MooseUtils::absoluteFuzzyEqual(_max_distance, other._max_distance))
    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;
}

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

errorIfTracing()

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

private

Produces a useful error if a Ray has started tracing.

Definition at line 385 of file Ray.C.

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

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

errorWhenInitializing()

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

private

Produces a useful error for use when initializing a Ray.

Definition at line 392 of file Ray.C.

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

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

getInfo()

std::string Ray::getInfo

(

)

const

Helper function for getting information about the Ray.

Definition at line 483 of file Ray.C.

{
  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();
}

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

hasTraced()

bool Ray::hasTraced ( ) const

inline

Whether or not a Ray has begun tracing.

Definition at line 556 of file Ray.h.

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

Referenced by errorIfTracing().

id()

RayID Ray::id ( ) const

inline

Gets the Ray's ID.

Definition at line 219 of file Ray.h.

{ return _id; }

Referenced by changeID(), and getInfo().

intersections()

unsigned int Ray::intersections ( ) const

inline

Gets the number of intersections this Ray has done.

Definition at line 507 of file Ray.h.

{ return _intersections; }

Referenced by getInfo().

invalidateCurrentElem()

void Ray::invalidateCurrentElem ( )

inlineprivate

Invalidates the Ray's current element.

Definition at line 575 of file Ray.h.

{ _current_elem = nullptr; }

Referenced by clearStartingInfoInternal(), and invalidateStartingElem().

invalidateCurrentIncomingSide()

void Ray::invalidateCurrentIncomingSide ( )

inlineprivate

Invalidates the Ray's current incoming side.

Definition at line 610 of file Ray.h.

{ _current_incoming_side = RayTracingCommon::invalid_side; }

Referenced by clearStartingInfoInternal(), and invalidateStartingIncomingSide().

invalidateCurrentPoint()

void Ray::invalidateCurrentPoint ( )

inlineprivate

Invalidates the Ray's current point.

Definition at line 584 of file Ray.h.

{ _current_point = RayTracingCommon::invalid_point; }

Referenced by clearStartingInfoInternal().

invalidateDirection()

void Ray::invalidateDirection ( )

inlineprivate

Invalidates the Ray's current direction.

Definition at line 593 of file Ray.h.

{ _direction = RayTracingCommon::invalid_point; }

Referenced by clearStartingInfoInternal().

invalidateMaxDistance()

void Ray::invalidateMaxDistance ( )

inlineprivate

Invalidates the Ray's max distance.

Definition at line 646 of file Ray.h.

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

Referenced by clearStartingInfoInternal().

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 353 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 360 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 468 of file Ray.h.

  {
    return _current_incoming_side == RayTracingCommon::invalid_side;
  }

Referenced by getInfo(), and setStart().

invalidCurrentPoint()

bool Ray::invalidCurrentPoint ( ) const

inline

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

Definition at line 237 of file Ray.h.

{ return _current_point == RayTracingCommon::invalid_point; }

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

invalidDirection()

bool Ray::invalidDirection ( ) const

inline

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

Definition at line 283 of file Ray.h.

{ return _direction == RayTracingCommon::invalid_point; }

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

invalidID()

bool Ray::invalidID ( ) const

inline

Whether or not the Ray's ID is invalid.

Definition at line 223 of file Ray.h.

{ return _id == INVALID_RAY_ID; }

Referenced by getInfo().

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 519 of file Ray.h.

{ return _max_distance; }

Referenced by getInfo().

maxDistanceSet()

bool Ray::maxDistanceSet ( ) const

inline

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

Definition at line 523 of file Ray.h.

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

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

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 209 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 203 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 502 of file Ray.h.

{ return _processor_crossings; }

Referenced by getInfo().

reset() [1/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;
}

reset() [2/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

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 398 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 406 of file Ray.C.

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

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

setCurrentElem()

void Ray::setCurrentElem ( const Elem *  current_elem )

inlineprivate

Change a Ray's current elem.

Definition at line 598 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 603 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 580 of file Ray.h.

{ _current_point = current_point; }

setDirection()

void Ray::setDirection ( const Point &  direction )

inlineprivate

Sets the Ray's direction.

Definition at line 589 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 537 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 233 of file Ray.C.

{
  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.");
  }
}

Referenced by Ray(), and reset().

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 282 of file Ray.C.

{
  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();
}

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

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 299 of file Ray.C.

{
  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;
}

Referenced by Ray(), and reset().

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 324 of file Ray.C.

{
  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;
}

Referenced by setStartingEndPoint().

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 339 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 615 of file Ray.h.

  {
    _trajectory_changed = trajectory_changed;
  }

shouldContinue()

bool Ray::shouldContinue ( ) const

inline

Whether or not this Ray should continue.

Definition at line 533 of file Ray.h.

{ return _should_continue; }

Referenced by getInfo().

stationary()

bool Ray::stationary ( ) const

inline

Returns

Whether or not the Ray is set to be stationary

Definition at line 758 of file Ray.h.

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

Referenced by setStationary().

study()

const RayTracingStudy & Ray::study ( ) const

inline

Get the RayTracingStudy associated with this Ray.

Definition at line 564 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 542 of file Ray.h.

{ return _trajectory_changed; }

Referenced by getInfo().

trajectoryChanges()

unsigned int Ray::trajectoryChanges ( ) const

inline

Gets the number of trajectory changes this Ray has had.

Definition at line 546 of file Ray.h.

{ return _trajectory_changes; }

Referenced by getInfo().

Friends And Related Symbol Documentation

dataLoad

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

friend

Definition at line 738 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->_trajectory_changed, context);
  loadHelper(stream, ray->_end_set, context);
  loadHelper(stream, ray->_should_continue, context);
  loadHelper(stream, ray->_processor_crossings, context);
  loadHelper(stream, ray->_intersections, context);
  loadHelper(stream, ray->_trajectory_changes, context);
  loadHelper(stream, ray->_distance, context);
  loadHelper(stream, ray->_max_distance, 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 713 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->_trajectory_changed, context);
  storeHelper(stream, ray->_end_set, context);
  storeHelper(stream, ray->_should_continue, context);
  storeHelper(stream, ray->_processor_crossings, context);
  storeHelper(stream, ray->_intersections, context);
  storeHelper(stream, ray->_trajectory_changes, context);
  storeHelper(stream, ray->_distance, context);
  storeHelper(stream, ray->_max_distance, 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 747 of file Ray.h.

TestRayLots

friend class TestRayLots

friend

Definition at line 751 of file Ray.h.

TraceRay

friend class TraceRay

friend

Definition at line 747 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 741 of file Ray.h.

Referenced by auxData(), 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 701 of file Ray.h.

Referenced by changePointElemSide(), 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 711 of file Ray.h.

Referenced by changePointElemSide(), 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 683 of file Ray.h.

Referenced by changePointElemSide(), 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 737 of file Ray.h.

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

_direction

Point Ray::_direction

private

Direction of the Ray.

Definition at line 686 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 731 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 717 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 673 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 725 of file Ray.h.

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

_max_distance

Real Ray::_max_distance

private

Maximum distance the Ray is allowed to travel.

Definition at line 733 of file Ray.h.

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

_processor_crossings

unsigned int Ray::_processor_crossings

private

Number of times this Ray has been communicated.

Definition at line 722 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 719 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 744 of file Ray.h.

Referenced by auxData(), auxData(), auxData(), auxData(), data(), data(), data(), 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 714 of file Ray.h.

Referenced by changeDirection(), changePointElemSide(), 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 728 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 212 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 214 of file Ray.h.

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

---

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

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