Ray.h File Reference

Go to the source code of this file.

Classes
class	Ray
	Basic datastructure for a ray that will traverse the mesh. More...
class	Ray::ChangeDirectionKey
	Class that is used as a parameter to changeDirection() that allows only RayBC methods to call changeDirection() More...
class	Ray::ChangeStartDirectionKey
	Class that is used as a parameter to changeStartDirection() that allows only RayKernelBase methods to call changeStartDirection() More...
class	Ray::ChangePointElemSideKey
	Class that is used as a parameter to changePointElem() that allows only PeriodicRayBC methods to call changeStartDirection() More...
class	Ray::ConstructRayKey
	Class that is used as a parameter to the public constructors/reset methods. More...
class	libMesh::Parallel::Packing< std::shared_ptr< Ray > >

Namespaces
namespace	libMesh
	The following methods are specializations for using the Parallel::packed_range_* routines for a vector of Rays.
namespace	MooseUtils
namespace	libMesh::Parallel

Typedefs
typedef unsigned long int	RayID
	Type for a Ray's ID.
typedef float	RayData
	Type for a Ray's data.
typedef unsigned int	RayDataIndex
	Type for the index into the data and aux data on a Ray.

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

Typedef Documentation

RayData

typedef libMesh::Real RayData

Type for a Ray's data.

Definition at line 47 of file Ray.h.

RayDataIndex

typedef unsigned int RayDataIndex

Type for the index into the data and aux data on a Ray.

Definition at line 52 of file Ray.h.

RayID

typedef unsigned long int RayID

Type for a Ray's ID.

Definition at line 44 of file Ray.h.

Function Documentation

dataLoad()

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

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
	)

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