RepeatableRayStudyDefineNoClaimTest Class Reference

#include <RepeatableRayStudyBaseTest.h>

Inheritance diagram for RepeatableRayStudyDefineNoClaimTest:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	RepeatableRayStudyDefineNoClaimTest (const InputParameters &params)
virtual void	initialSetup () override
virtual void	residualSetup () override
virtual void	jacobianSetup () override
virtual void	timestepSetup () override
virtual void	initialize () override
virtual void	finalize () override
virtual void	execute () override
	Executes the study (generates and propagates Rays)
virtual void	segmentSubdomainSetup (const SubdomainID subdomain, const THREAD_ID tid, const RayID ray_id)
	Setup for on subdomain change or subdomain AND ray change during ray tracing.
virtual void	reinitSegment (const Elem *elem, const Point &start, const Point &end, const Real length, THREAD_ID tid)
	Reinitialize objects for a Ray segment for ray tracing.
virtual void	postOnSegment (const THREAD_ID tid, const std::shared_ptr< Ray > &ray)
	Called at the end of a Ray segment.
virtual void	preTrace (const THREAD_ID, const std::shared_ptr< Ray > &)
	Called at the beginning of a trace for a ray.
void	executeStudy ()
	Method for executing the study so that it can be called out of the standard UO execute()
unsigned long long int	endingProcessorCrossings () const
	Total number of processor crossings for Rays that finished on this processor.
unsigned int	endingMaxProcessorCrossings () const
	Max number of total processor crossings for Rays that finished on this processor.
unsigned long long int	totalProcessorCrossings () const
	Total number of processor crossings.
unsigned int	maxProcessorCrossings () const
	Max number of processor crossings for all Rays.
unsigned long long int	endingIntersections () const
	Total number of Ray/element intersections for Rays that finished on this processor.
unsigned int	endingMaxIntersections () const
	Max number of intersections for Rays that finished on this processor.
unsigned long long int	totalIntersections () const
	Total number of Ray/element intersections.
unsigned int	maxIntersections () const
	Max number of intersections for a Ray.
unsigned int	maxTrajectoryChanges () const
	Max number of trajectory changes for a Ray.
Real	endingDistance () const
	Total amount of distance traveled by the rays that end on this processor.
Real	totalDistance () const
	Total distance traveled by all Rays.
unsigned long long int	localTraceRayResult (const int result) const
const ParallelRayStudy &	parallelRayStudy () const
Real	rayMaxDistance () const
	Max distance any Ray can travel.
Real	executionTime ()
	Duration for execute() in seconds.
Real	executionTimeNano ()
	Duration for execute() in nanoseconds.
Real	generationTime () const
	Duration for creation of all Rays in seconds.
Real	propagationTime () const
	Duration for creation of all Rays in seconds.
bool	tolerateFailure () const
	Whether or not to tolerate failure.
bool	bankRaysOnCompletion () const
	Whether or not to bank Rays on completion.
bool	rayDependentSubdomainSetup () const
	Whether or not to use Ray dependent subdomain setup.
RayDataIndex	registerRayData (const std::string &name)
	Register a value to be filled in the data on a Ray with a given name.
std::vector< RayDataIndex >	registerRayData (const std::vector< std::string > &names)
	Register values to be filled in the data on a Ray with a given name.
RayDataIndex	getRayDataIndex (const std::string &name, const bool graceful=false) const
	Gets the index associated with a registered value in the Ray data.
std::vector< RayDataIndex >	getRayDataIndices (const std::vector< std::string > &names, const bool graceful=false) const
	Gets the indices associated with registered values in the Ray data.
const std::string &	getRayDataName (const RayDataIndex index) const
	Gets the name associated with a registered value in the Ray data.
std::vector< std::string >	getRayDataNames (const std::vector< RayDataIndex > &indices) const
	Gets the names associated with registered values in the Ray data.
std::size_t	rayDataSize () const
	The registered size of values in the Ray data.
bool	hasRayData () const
	Whether or not any Ray data are registered.
const std::vector< std::string > &	rayDataNames () const
	The Ray data names.
RayDataIndex	registerRayAuxData (const std::string &name)
	Register a value to be filled in the aux data on a Ray with a given name.
std::vector< RayDataIndex >	registerRayAuxData (const std::vector< std::string > &names)
	Register values to be filled in the aux data on a Ray with a given name.
RayDataIndex	getRayAuxDataIndex (const std::string &name, const bool graceful=false) const
	Gets the index associated with a registered value in the Ray aux data.
std::vector< RayDataIndex >	getRayAuxDataIndices (const std::vector< std::string > &names, const bool graceful=false) const
	Gets the indices associated with registered values in the Ray aux data.
const std::string &	getRayAuxDataName (const RayDataIndex index) const
	Gets the name associated with a registered value in the Ray aux data.
std::vector< std::string >	getRayAuxDataNames (const std::vector< RayDataIndex > &indices) const
	Gets the names associated with registered values in the Ray aux data.
std::size_t	rayAuxDataSize () const
	The registered size of values in the Ray aux data.
bool	hasRayAuxData () const
	Whether or not any Ray aux data are registered.
const std::vector< std::string > &	rayAuxDataNames () const
	The Ray aux data names.
bool	hasRayKernels (const THREAD_ID tid)
	Whether or not there are currently any active RayKernel objects.
void	getRayKernels (std::vector< RayKernelBase * > &result, SubdomainID id, THREAD_ID tid)
	Fills the active RayKernels associated with this study and a block into result.
template<typename T >
void	getRayKernels (std::vector< T * > &result, THREAD_ID tid)
	Fills the active RayKernels associated with this study into result.
void	getRayKernels (std::vector< RayKernelBase * > &result, SubdomainID id, THREAD_ID tid, RayID ray_id)
	Fills the active RayKernels associeted with this study, block, and potentially Ray into result.
void	getRayBCs (std::vector< RayBoundaryConditionBase * > &result, BoundaryID id, THREAD_ID tid)
	Fills the active RayBCs associated with this study and a boundary into result.
template<typename T >
void	getRayBCs (std::vector< T * > &result, const std::vector< BoundaryID > &ids, THREAD_ID tid)
	Fills the active RayBCs associated with this study and boundaries result.
template<typename T >
void	getRayBCs (std::vector< T * > &result, THREAD_ID tid)
	Fills the active RayBCs associated with this study into result.
virtual void	getRayBCs (std::vector< RayBoundaryConditionBase * > &result, const std::vector< TraceRayBndElement > &bnd_elems, THREAD_ID tid, RayID ray_id)
	Fills the active RayBCs associated with thie study, boundary elements, and potentially Ray into result.
const std::vector< RayKernelBase * > &	currentRayKernels (THREAD_ID tid) const
	Gets the current RayKernels for a thread, which are set in segmentSubdomainSetup()
const BoundingBox &	boundingBox () const
	Get the nodal bounding box for the domain.
const BoundingBox &	looseBoundingBox () const
	Get the loose nodal bounding box for the domain.
Real	domainMaxLength () const
	Get the inflated maximum length across the domain.
Real	totalVolume () const
	Get the current total volume of the domain.
bool	isRectangularDomain () const
	Whether or not the domain is rectangular (if it is prefectly encompassed by its bounding box)
bool	hasInternalSidesets () const
	Whether or not the local mesh has internal sidesets that have RayBCs on them.
const std::vector< std::vector< BoundaryID > > &	getInternalSidesets (const Elem *elem) const
	Get the internal sidesets (that have RayBC(s)) for each side for a given element.
const std::set< BoundaryID > &	getInternalSidesets () const
	Gets the internal sidesets (that have RayBCs) within the local domain.
bool	sideIsNonPlanar (const Elem *elem, const unsigned short s) const
	Whether or not the side \s on elem elem is non-planar.
bool	hasSameLevelActiveElems () const
	Whether or not the mesh has active elements of the same level.
void	moveRayToBufferDuringTrace (std::shared_ptr< Ray > &ray, const THREAD_ID tid, const AcquireMoveDuringTraceKey &)
	INTERNAL method for moving a Ray into the buffer during tracing.
MeshBase &	meshBase () const
	Access to the libMesh MeshBase.
MooseMesh &	mesh ()
virtual const Point &	getSideNormal (const Elem *elem, const unsigned short side, const THREAD_ID tid)
	Get the outward normal for a given element side.
virtual const Point *	getElemNormals (const Elem *, const THREAD_ID)
	Gets the outward normals for a given element.
RayData	getBankedRayData (const RayID ray_id, const RayDataIndex index) const
	Gets the data value for a banked ray with a given ID.
RayData	getBankedRayAuxData (const RayID ray_id, const RayDataIndex index) const
	Gets the data value for a banked ray with a given ID.
RayID	registeredRayID (const std::string &name, const bool graceful=false) const
	Gets the ID of a registered ray.
const std::string &	registeredRayName (const RayID ray_id) const
	Gets the name of a registered ray.
bool	useRayRegistration () const
	Whether or not ray registration is being used.
bool	dataOnCacheTraces () const
	Whether or not to store the Ray data on the cached Ray traces.
bool	auxDataOnCacheTraces () const
	Whether or not to store the Ray aux data on the cached Ray traces.
bool	segmentsOnCacheTraces () const
	Whether or not to cache individual element segments when _cache_traces = true.
virtual bool	shouldCacheTrace (const std::shared_ptr< Ray > &) const
	Virtual that allows for selection in if a Ray should be cached or not (only used when _cache_traces).
TraceData &	initThreadedCachedTrace (const std::shared_ptr< Ray > &ray, THREAD_ID tid)
	Initialize a Ray in the threaded cached trace map to be filled with segments.
const std::vector< TraceData > &	getCachedTraces () const
	Get the cached trace data structure.
Real	subdomainHmax (const SubdomainID subdomain_id) const
	Get the cached hmax for all elements in a subdomain.
virtual void	onCompleteRay (const std::shared_ptr< Ray > &ray)
	Entry point for acting on a ray when it is completed (shouldContinue() == false)
void	verifyUniqueRayIDs (const std::vector< std::shared_ptr< Ray > >::const_iterator begin, const std::vector< std::shared_ptr< Ray > >::const_iterator end, const bool global, const std::string &error_suffix) const
	Verifies that the Rays in the given range have unique Ray IDs.
void	verifyUniqueRays (const std::vector< std::shared_ptr< Ray > >::const_iterator begin, const std::vector< std::shared_ptr< Ray > >::const_iterator end, const std::string &error_suffix)
	Verifies that the Rays in the given range are unique.
bool	currentlyPropagating () const
	Whether or not the study is propagating (tracing Rays)
bool	currentlyGenerating () const
	Whether or not the study is generating.
bool	verifyRays () const
	Whether or not to verify if Rays have valid information before being traced.
bool	verifyTraceIntersections () const
	Whether or not trace verification is enabled in devel/dbg modes.
bool	sideIsIncoming (const Elem *const elem, const unsigned short side, const Point &direction, const THREAD_ID tid)
	Whether or not side is incoming on element elem in direction direction.
bool	warnNonPlanar () const
	Whether or not to produce a warning when interacting with a non-planar mesh.
ParallelStudy< std::shared_ptr< Ray >, Ray > *	parallelStudy ()
	The underlying parallel study: used for the context for calling the packed range routines.
const libMesh::Elem &	elemSide (const libMesh::Elem &elem, const unsigned int s, const THREAD_ID tid=0)
	Get an element's side pointer without excessive memory allocation.
virtual Real	spatialValue (const Point &) const
virtual const std::vector< Point >	spatialPoints () const
void	setPrimaryThreadCopy (UserObject *primary)
UserObject *	primaryThreadCopy ()
SubProblem &	getSubProblem () const
bool	shouldDuplicateInitialExecution () const
void	gatherSum (T &value)
void	gatherMax (T &value)
void	gatherMin (T &value)
void	gatherProxyValueMax (T1 &proxy, T2 &value)
void	gatherProxyValueMin (T1 &proxy, T2 &value)
std::set< UserObjectName >	getDependObjects () const
const std::set< std::string > &	getRequestedItems () override
const std::set< std::string > &	getSuppliedItems () override
unsigned int	systemNumber () const
virtual bool	needThreadedCopy () const
virtual bool	enabled () const
std::shared_ptr< MooseObject >	getSharedPtr ()
std::shared_ptr< const MooseObject >	getSharedPtr () const
bool	isKokkosObject () const
MooseApp &	getMooseApp () const
const std::string &	type () const
const std::string &	name () const
std::string	typeAndName () const
MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const
MooseObjectName	uniqueName () const
const InputParameters &	parameters () const
const hit::Node *	getHitNode () const
bool	hasBase () const
const std::string &	getBase () const
const T &	getParam (const std::string &name) const
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
const T *	queryParam (const std::string &name) const
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
bool	isParamValid (const std::string &name) const
bool	isParamSetByUser (const std::string &name) const
void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
void	paramError (const std::string &param, Args... args) const
void	paramWarning (const std::string &param, Args... args) const
void	paramWarning (const std::string &param, Args... args) const
void	paramInfo (const std::string &param, Args... args) const
std::string	messagePrefix (const bool hit_prefix=true) const
std::string	errorPrefix (const std::string &) const
void	mooseError (Args &&... args) const
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
void	mooseErrorNonPrefixed (Args &&... args) const
void	mooseWarning (Args &&... args) const
void	mooseWarning (Args &&... args) const
void	mooseWarningNonPrefixed (Args &&... args) const
void	mooseWarningNonPrefixed (Args &&... args) const
void	mooseDeprecated (Args &&... args) const
void	mooseDeprecated (Args &&... args) const
void	mooseDeprecatedNoTrace (Args &&... args) const
void	mooseInfo (Args &&... args) const
void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
std::string	getDataFileName (const std::string &param) const
std::string	getDataFileNameByName (const std::string &relative_path) const
std::string	getDataFilePath (const std::string &relative_path) const
virtual void	customSetup (const ExecFlagType &)
const ExecFlagEnum &	getExecuteOnEnum () const
UserObjectName	getUserObjectName (const std::string &param_name) const
const T &	getUserObject (const std::string &param_name, bool is_dependency=true) const
const T &	getUserObjectByName (const UserObjectName &object_name, bool is_dependency=true) const
const UserObjectBase &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const
const UserObjectBase &	getUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) const
const std::vector< MooseVariableScalar * > &	getCoupledMooseScalarVars ()
const std::set< TagID > &	getScalarVariableCoupleableVectorTags () const
const std::set< TagID > &	getScalarVariableCoupleableMatrixTags () const
const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, MaterialData &material_data, const unsigned int state=0)
const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, const unsigned int state=0)
const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, const unsigned int state=0)
const MaterialProperty< T > &	getMaterialProperty (const std::string &name, MaterialData &material_data, const unsigned int state=0)
const MaterialProperty< T > &	getMaterialProperty (const std::string &name, const unsigned int state=0)
const MaterialProperty< T > &	getMaterialProperty (const std::string &name, const unsigned int state=0)
const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name, MaterialData &material_data)
const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name)
const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name)
const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name, MaterialData &material_data)
const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name)
const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name)
const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name, MaterialData &material_data)
const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name)
const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name)
const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data, const unsigned int state)
const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)
const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)
const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data, const unsigned int state=0)
const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)
const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)
const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data)
const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name)
const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name)
const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name, MaterialData &material_data)
const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name)
const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name)
const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name, MaterialData &material_data)
const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name)
const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name)
Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyByName (const std::string &prop_name_in)
Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOldByName (const std::string &prop_name)
Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOlderByName (const std::string &prop_name)
Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialProperty (const std::string &name)
Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOld (const std::string &name)
Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOlder (const std::string &name)
std::pair< const MaterialProperty< T > *, std::set< SubdomainID > >	getBlockMaterialProperty (const MaterialPropertyName &name)
std::pair< Moose::Kokkos::MaterialProperty< T, dimension >, std::set< SubdomainID > >	getKokkosBlockMaterialProperty (const MaterialPropertyName &name)
const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty (const std::string &name)
const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty ()
const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialPropertyByName (const std::string &prop_name)
const MaterialProperty< T > &	getZeroMaterialProperty (Ts... args)
std::set< SubdomainID >	getMaterialPropertyBlocks (const std::string &name)
std::vector< SubdomainName >	getMaterialPropertyBlockNames (const std::string &name)
std::set< BoundaryID >	getMaterialPropertyBoundaryIDs (const std::string &name)
std::vector< BoundaryName >	getMaterialPropertyBoundaryNames (const std::string &name)
void	checkBlockAndBoundaryCompatibility (std::shared_ptr< MaterialBase > discrete)
std::unordered_map< SubdomainID, std::vector< MaterialBase * > >	buildRequiredMaterials (bool allow_stateful=true)
void	statefulPropertiesAllowed (bool)
virtual bool	getMaterialPropertyCalled () const
virtual const std::unordered_set< unsigned int > &	getMatPropDependencies () const
virtual void	resolveOptionalProperties ()
const GenericMaterialProperty< T, is_ad > &	getPossiblyConstantGenericMaterialPropertyByName (const MaterialPropertyName &prop_name, MaterialData &material_data, const unsigned int state)
bool	isImplicit ()
Moose::StateArg	determineState () const
virtual void	threadJoin (const UserObject &) override
virtual void	threadJoin (const UserObject &) override
virtual void	subdomainSetup () override
virtual void	subdomainSetup () override
bool	hasUserObject (const std::string &param_name) const
bool	hasUserObject (const std::string &param_name) const
bool	hasUserObject (const std::string &param_name) const
bool	hasUserObject (const std::string &param_name) const
bool	hasUserObjectByName (const UserObjectName &object_name) const
bool	hasUserObjectByName (const UserObjectName &object_name) const
bool	hasUserObjectByName (const UserObjectName &object_name) const
bool	hasUserObjectByName (const UserObjectName &object_name) const
const GenericOptionalMaterialProperty< T, is_ad > &	getGenericOptionalMaterialProperty (const std::string &name, const unsigned int state=0)
const GenericOptionalMaterialProperty< T, is_ad > &	getGenericOptionalMaterialProperty (const std::string &name, const unsigned int state=0)
const OptionalMaterialProperty< T > &	getOptionalMaterialProperty (const std::string &name, const unsigned int state=0)
const OptionalMaterialProperty< T > &	getOptionalMaterialProperty (const std::string &name, const unsigned int state=0)
const OptionalADMaterialProperty< T > &	getOptionalADMaterialProperty (const std::string &name)
const OptionalADMaterialProperty< T > &	getOptionalADMaterialProperty (const std::string &name)
const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOld (const std::string &name)
const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOld (const std::string &name)
const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOlder (const std::string &name)
const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOlder (const std::string &name)
MaterialBase &	getMaterial (const std::string &name)
MaterialBase &	getMaterial (const std::string &name)
MaterialBase &	getMaterialByName (const std::string &name, bool no_warn=false)
MaterialBase &	getMaterialByName (const std::string &name, bool no_warn=false)
bool	hasMaterialProperty (const std::string &name)
bool	hasMaterialProperty (const std::string &name)
bool	hasMaterialPropertyByName (const std::string &name)
bool	hasMaterialPropertyByName (const std::string &name)
bool	hasADMaterialProperty (const std::string &name)
bool	hasADMaterialProperty (const std::string &name)
bool	hasADMaterialPropertyByName (const std::string &name)
bool	hasADMaterialPropertyByName (const std::string &name)
bool	hasKokkosMaterialProperty (const std::string &name)
bool	hasKokkosMaterialProperty (const std::string &name)
bool	hasKokkosMaterialPropertyByName (const std::string &name)
bool	hasKokkosMaterialPropertyByName (const std::string &name)
bool	hasGenericMaterialProperty (const std::string &name)
bool	hasGenericMaterialProperty (const std::string &name)
bool	hasGenericMaterialPropertyByName (const std::string &name)
bool	hasGenericMaterialPropertyByName (const std::string &name)
const Function &	getFunction (const std::string &name) const
const Function &	getFunctionByName (const FunctionName &name) const
bool	hasFunction (const std::string &param_name) const
bool	hasFunctionByName (const FunctionName &name) const
Moose::Kokkos::Function	getKokkosFunction (const std::string &name) const
const T &	getKokkosFunction (const std::string &name) const
Moose::Kokkos::Function	getKokkosFunctionByName (const FunctionName &name) const
const T &	getKokkosFunctionByName (const FunctionName &name) const
bool	hasKokkosFunction (const std::string &param_name) const
bool	hasKokkosFunctionByName (const FunctionName &name) const
bool	isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) const
bool	hasPostprocessorByName (const PostprocessorName &name) const
std::size_t	coupledPostprocessors (const std::string &param_name) const
const PostprocessorName &	getPostprocessorName (const std::string &param_name, const unsigned int index=0) const
const VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const
const VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const
const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const
const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const
const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const
const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const
const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const
const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const
const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const
const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const
const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const
const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const
bool	hasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const
bool	hasVectorPostprocessor (const std::string &param_name) const
bool	hasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const
bool	hasVectorPostprocessorByName (const VectorPostprocessorName &name) const
const VectorPostprocessorName &	getVectorPostprocessorName (const std::string &param_name) const
T &	getSampler (const std::string &name)
Sampler &	getSampler (const std::string &name)
T &	getSamplerByName (const SamplerName &name)
Sampler &	getSamplerByName (const SamplerName &name)
virtual void	meshDisplaced ()
PerfGraph &	perfGraph ()
const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const
const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const
const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const
const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const
virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const
virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const
const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const
const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const
const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const
const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const
bool	isVectorPostprocessorDistributed (const std::string &param_name) const
bool	isVectorPostprocessorDistributed (const std::string &param_name) const
bool	isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const
bool	isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const
const Distribution &	getDistribution (const std::string &name) const
const T &	getDistribution (const std::string &name) const
const Distribution &	getDistribution (const std::string &name) const
const T &	getDistribution (const std::string &name) const
const Distribution &	getDistributionByName (const DistributionName &name) const
const T &	getDistributionByName (const std::string &name) const
const Distribution &	getDistributionByName (const DistributionName &name) const
const T &	getDistributionByName (const std::string &name) const
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
std::shared_ptr< Ray >	acquireRayDuringTrace (const THREAD_ID tid, const AcquireMoveDuringTraceKey &)
	INTERNAL methods for acquiring a Ray during a trace in RayKernels and RayBCs.
std::shared_ptr< Ray >	acquireRayInternal (const RayID id, const std::size_t data_size, const std::size_t aux_data_size, const bool reset, const AcquireRayInternalKey &)
TraceRay &	traceRay (const THREAD_ID tid)
	Gets the threaded TraceRay object for tid.
const TraceRay &	traceRay (const THREAD_ID tid) const

Static Public Member Functions
static InputParameters	validParams ()
static void	callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node, const bool show_trace=true)
static void	sort (typename std::vector< T > &vector)
static void	sortDFS (typename std::vector< T > &vector)
static void	cyclicDependencyError (CyclicDependencyException< T2 > &e, const std::string &header, NameFunc &&name_func)
static void	cyclicDependencyError (CyclicDependencyException< T2 > &e, const std::string &header)

Public Attributes
	usingCombinedWarningSolutionWarnings
const ConsoleStream	_console

Static Public Attributes
static const std::string	type_param
static const std::string	name_param
static const std::string	unique_name_param
static const std::string	app_param
static const std::string	moose_base_param
static const std::string	kokkos_object_param
static constexpr PropertyValue::id_type	default_property_id
static constexpr PropertyValue::id_type	zero_property_id
static constexpr auto	SYSTEM
static constexpr auto	NAME

Protected Member Functions
void	defineRays () override
	Entry point for the user to create Rays.
virtual void	meshChanged () override
virtual void	generateRays () override
	Subclasses should override this to determine how to generate Rays.
virtual void	preExecuteStudy ()
	Entry point before study execution.
virtual void	postExecuteStudy ()
	Entry point after study execution.
Real	computeTotalVolume ()
	Helper function for computing the total domain volume.
std::vector< RayKernelBase * > &	currentRayKernelsWrite (THREAD_ID tid)
	Gets the writeable current RayKernels for a thread.
void	reserveRayBuffer (const std::size_t size)
	Reserve size entires in the Ray buffer.
bool	sameLevelActiveElems () const
	Determine whether or not the mesh currently has active elements that are all the same level.
virtual void	buildSegmentQuadrature (const Point &start, const Point &end, const Real length, std::vector< Point > &points, std::vector< Real > &weights) const
	Builds quadrature points for a given segment using the _segment_qrule.
const std::vector< std::shared_ptr< Ray > > &	rayBank () const
	Get the Ray bank.
std::shared_ptr< Ray >	getBankedRay (const RayID ray_id) const
	Gets the Ray with the ID ray_id from the Ray bank.
void	resetUniqueRayIDs ()
	Resets the generation of unique RayIDs via generateUniqueRayID() to the beginning of the range.
void	resetReplicatedRayIDs ()
	Resets the generation of unique replicated RayIDs accessed via generateReplicatedRayID().
std::vector< RayTracingObject * >	getRayTracingObjects ()
	Gets all of the currently active RayTracingObjects.
virtual RayID	generateUniqueRayID (const THREAD_ID tid)
	Generates a unique RayID to be used for a Ray.
RayID	generateReplicatedRayID ()
	Generates a Ray ID that is replicated across all processors.
void	moveRayToBuffer (std::shared_ptr< Ray > &ray)
	Moves a ray to the buffer to be traced during generateRays().
void	moveRaysToBuffer (std::vector< std::shared_ptr< Ray > > &rays)
	Moves rays to the buffer to be traced during generateRays().
virtual void	addPostprocessorDependencyHelper (const PostprocessorName &name) const override
virtual void	addVectorPostprocessorDependencyHelper (const VectorPostprocessorName &name) const override
virtual void	addUserObjectDependencyHelper (const UserObjectBase &uo) const override
void	addReporterDependencyHelper (const ReporterName &reporter_name) override
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const
const ReporterContextBase &	getReporterContextBaseByName (const ReporterName &reporter_name) const
const ReporterName &	getReporterName (const std::string &param_name) const
T &	declareRestartableData (const std::string &data_name, Args &&... args)
ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
const T &	getRestartableData (const std::string &data_name) const
T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
T &	declareRecoverableData (const std::string &data_name, Args &&... args)
T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)
T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)
std::string	restartableName (const std::string &data_name) const
const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)
const T &	getMeshProperty (const std::string &data_name)
bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const
bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const
bool	hasMeshProperty (const std::string &data_name) const
bool	hasMeshProperty (const std::string &data_name) const
std::string	meshPropertyName (const std::string &data_name) const
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
std::string	timedSectionName (const std::string &section_name) const
bool	isCoupledScalar (const std::string &var_name, unsigned int i=0) const
unsigned int	coupledScalarComponents (const std::string &var_name) const
unsigned int	coupledScalar (const std::string &var_name, unsigned int comp=0) const
libMesh::Order	coupledScalarOrder (const std::string &var_name, unsigned int comp=0) const
const VariableValue &	coupledScalarValue (const std::string &var_name, unsigned int comp=0) const
const ADVariableValue &	adCoupledScalarValue (const std::string &var_name, unsigned int comp=0) const
const GenericVariableValue< is_ad > &	coupledGenericScalarValue (const std::string &var_name, unsigned int comp=0) const
const GenericVariableValue< false > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const
const GenericVariableValue< true > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const
const VariableValue &	coupledVectorTagScalarValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const
const VariableValue &	coupledMatrixTagScalarValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const
const VariableValue &	coupledScalarValueOld (const std::string &var_name, unsigned int comp=0) const
const VariableValue &	coupledScalarValueOlder (const std::string &var_name, unsigned int comp=0) const
const VariableValue &	coupledScalarDot (const std::string &var_name, unsigned int comp=0) const
const ADVariableValue &	adCoupledScalarDot (const std::string &var_name, unsigned int comp=0) const
const VariableValue &	coupledScalarDotDot (const std::string &var_name, unsigned int comp=0) const
const VariableValue &	coupledScalarDotOld (const std::string &var_name, unsigned int comp=0) const
const VariableValue &	coupledScalarDotDotOld (const std::string &var_name, unsigned int comp=0) const
const VariableValue &	coupledScalarDotDu (const std::string &var_name, unsigned int comp=0) const
const VariableValue &	coupledScalarDotDotDu (const std::string &var_name, unsigned int comp=0) const
Moose::Kokkos::VariableValue	kokkosCoupledVectorTagScalarValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const
Moose::Kokkos::VariableValue	kokkosCoupledVectorTagScalarValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const
Moose::Kokkos::VariableValue	kokkosCoupledScalarValue (const std::string &var_name, unsigned int comp=0) const
Moose::Kokkos::VariableValue	kokkosCoupledScalarValueOld (const std::string &var_name, unsigned int comp=0) const
Moose::Kokkos::VariableValue	kokkosCoupledScalarValueOlder (const std::string &var_name, unsigned int comp=0) const
Moose::Kokkos::VariableValue	kokkosCoupledScalarDot (const std::string &var_name, unsigned int comp=0) const
Moose::Kokkos::Scalar< const Real >	kokkosCoupledScalarDotDu (const std::string &var_name, unsigned int comp=0) const
const MooseVariableScalar *	getScalarVar (const std::string &var_name, unsigned int comp) const
virtual void	checkMaterialProperty (const std::string &name, const unsigned int state)
virtual void	getKokkosMaterialPropertyHook (const std::string &, const unsigned int)
void	markMatPropRequested (const std::string &)
MaterialPropertyName	getMaterialPropertyName (const std::string &name) const
void	checkExecutionStage ()
const T &	getReporterValue (const std::string &param_name, const std::size_t time_index=0)
const T &	getReporterValue (const std::string &param_name, ReporterMode mode, const std::size_t time_index=0)
const T &	getReporterValue (const std::string &param_name, const std::size_t time_index=0)
const T &	getReporterValue (const std::string &param_name, ReporterMode mode, const std::size_t time_index=0)
const T &	getReporterValueByName (const ReporterName &reporter_name, const std::size_t time_index=0)
const T &	getReporterValueByName (const ReporterName &reporter_name, ReporterMode mode, const std::size_t time_index=0)
const T &	getReporterValueByName (const ReporterName &reporter_name, const std::size_t time_index=0)
const T &	getReporterValueByName (const ReporterName &reporter_name, ReporterMode mode, const std::size_t time_index=0)
bool	hasReporterValue (const std::string &param_name) const
bool	hasReporterValue (const std::string &param_name) const
bool	hasReporterValue (const std::string &param_name) const
bool	hasReporterValue (const std::string &param_name) const
bool	hasReporterValueByName (const ReporterName &reporter_name) const
bool	hasReporterValueByName (const ReporterName &reporter_name) const
bool	hasReporterValueByName (const ReporterName &reporter_name) const
bool	hasReporterValueByName (const ReporterName &reporter_name) const
const GenericMaterialProperty< T, is_ad > *	defaultGenericMaterialProperty (const std::string &name)
const GenericMaterialProperty< T, is_ad > *	defaultGenericMaterialProperty (const std::string &name)
const MaterialProperty< T > *	defaultMaterialProperty (const std::string &name)
const MaterialProperty< T > *	defaultMaterialProperty (const std::string &name)
const ADMaterialProperty< T > *	defaultADMaterialProperty (const std::string &name)
const ADMaterialProperty< T > *	defaultADMaterialProperty (const std::string &name)
std::shared_ptr< Ray >	acquireRay ()
	User APIs for constructing Rays within the RayTracingStudy.
std::shared_ptr< Ray >	acquireUnsizedRay ()
	Acquire a Ray from the pool of Rays within generateRays(), without resizing the data (sizes the data to zero).
std::shared_ptr< Ray >	acquireReplicatedRay ()
	Acquire a Ray from the pool of Rays within generateRays() in a replicated fashion.
std::shared_ptr< Ray >	acquireCopiedRay (const Ray &ray)
	Acquires a Ray that that is copied from another Ray within generateRays().
std::shared_ptr< Ray >	acquireRegisteredRay (const std::string &name)
	Acquires a Ray with a given name within generateRays().

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
const std::vector< std::string >	_names
	The Ray names.
const std::vector< Point >	_start_points
	The points to start the Rays from.
const std::vector< Point > *const	_end_points
	The Ray end points (if defined)
const std::vector< Point > *const	_directions
	The Ray directions (if defined)
const std::vector< Real > *const	_max_distances
	The Ray max distances (if defined)
const std::vector< RayDataIndex >	_ray_data_indices
	The Ray data indices (if defined)
const std::vector< std::vector< Real > > *const	_initial_ray_data
	The initial Ray data to set (if defined)
const std::vector< RayDataIndex >	_ray_aux_data_indices
	The Ray aux data indices (if defined)
const std::vector< std::vector< Real > > *const	_initial_ray_aux_data
	The initial Ray data to set (if defined)
std::vector< std::shared_ptr< Ray > > &	_rays
	Vector of Rays that the user will fill into in defineRays() (restartable)
const bool	_define_rays_replicated
	Whether or not the Rays filled into _rays are replicated across all processors.
const bool	_claim_after_define_rays
	Whether or not Rays need to be claimed after defineRays()
bool &	_should_define_rays
	Whether or not we should call defineRays() on the next generateRays() Can be set to true in derived classes if they wish to redefine the rays after they have been defined once.
MooseMesh &	_mesh
	The Mesh.
const Parallel::Communicator &	_comm
	The Communicator.
const processor_id_type	_pid
	The rank of this processor (this actually takes time to lookup - so just do it once)
const bool	_ray_kernel_coverage_check
	Whether or not to perform coverage checks on RayKernels.
const bool	_warn_non_planar
	Whether not to warn if non-planar faces are found.
const bool	_use_ray_registration
	Whether or not to use Ray registration.
const bool	_use_internal_sidesets
	Whether or not to use the internal sidesets in ray tracing.
const bool	_tolerate_failure
	Whether or not to tolerate a Ray Tracing failure.
const bool	_bank_rays_on_completion
	Whether or not to bank rays on completion.
const bool	_ray_dependent_subdomain_setup
	Whether or not subdomain setup is dependent on the Ray.
bool	_always_cache_traces
	Whether or not to cache traces on every trace execution.
const bool	_data_on_cache_traces
	Whether or not to store the Ray data on the cache traces.
const bool	_aux_data_on_cache_traces
	Whether or not to store the Ray aux data on the cache traces.
const bool	_segments_on_cache_traces
	Whether or not to cache individual element segments when caching.
const Real	_ray_max_distance
	Max distance a Ray can travel before being killed (can change)
const bool	_verify_rays
	Whether or not to verify if Rays have valid information before being traced.
const bool	_verify_trace_intersections
	Whether or not to verify the trace intersections in devel and dbg modes.
const Moose::CoordinateSystemType &	_coord_sys
const THREAD_ID	_tid
SubProblem &	_subproblem
FEProblemBase &	_fe_problem
SystemBase &	_sys
Assembly &	_assembly
const bool	_duplicate_initial_execution
std::set< std::string >	_depend_uo
const bool &	_enabled
MooseApp &	_app
Factory &	_factory
ActionFactory &	_action_factory
const std::string &	_type
const std::string &	_name
const InputParameters &	_pars
const ExecFlagEnum &	_execute_enum
const ExecFlagType &	_current_execute_flag
MooseApp &	_restartable_app
const std::string	_restartable_system_name
const THREAD_ID	_restartable_tid
const bool	_restartable_read_only
FEProblemBase &	_mci_feproblem
FEProblemBase &	_mdi_feproblem
MooseApp &	_pg_moose_app
const std::string	_prefix
FEProblemBase &	_sc_fe_problem
const THREAD_ID	_sc_tid
const Real &	_real_zero
const VariableValue &	_scalar_zero
const Point &	_point_zero
const InputParameters &	_mi_params
const std::string	_mi_name
const MooseObjectName	_mi_moose_object_name
FEProblemBase &	_mi_feproblem
SubProblem &	_mi_subproblem
const THREAD_ID	_mi_tid
const bool	_is_kokkos_object
const Moose::MaterialDataType	_material_data_type
MaterialData &	_material_data
bool	_stateful_allowed
bool	_get_material_property_called
std::vector< std::unique_ptr< PropertyValue > >	_default_properties
std::unordered_set< unsigned int >	_material_property_dependencies
const MaterialPropertyName	_get_suffix
const bool	_use_interpolated_state
const InputParameters &	_ti_params
FEProblemBase &	_ti_feproblem
bool	_is_implicit
Real &	_t
const Real &	_t_old
int &	_t_step
Real &	_dt
Real &	_dt_old
bool	_is_transient
const Parallel::Communicator &	_communicator

Static Protected Attributes
static const std::string	_interpolated_old
static const std::string	_interpolated_older

Private Member Functions
void	claimRaysInternal ()
void	defineRaysInternal ()
void	verifyReplicatedRays ()
	Verifies that the Rays in _rays are replicated across processors.
void	coverageChecks ()
	Perform coverage checks (coverage of RayMaterials and RayKernels, if enabled)
void	dependencyChecks ()
	Perform checks to see if the listed dependencies in the RayTracingObjects exist.
void	verifyDependenciesExist (const std::vector< RayTracingObject * > &rtos)
	Verifies that the dependencies exist for a set of RayTracingObjects.
void	traceableMeshChecks ()
	Check for if all of the element types in the mesh are supported by ray tracing.
void	periodicBoundaryChecks ()
	Check for overlapping PeriodicRayBC boundaries and check for cases in which ghosting may not be sufficient with distributed mesh for overlapping periodic boundaries.
void	internalSidesetSetup ()
	Does the setup for internal sidesets.
void	nonPlanarSideSetup ()
	Sets up the caching of whether or not each element side is non-planar, which is stored in _non_planar_sides.
void	localElemIndexSetup ()
	Sets up the _elem_index_helper, which is used for obtaining a contiguous index for all elements that this processor knows about.
void	registeredRaySetup ()
	Sets up the maps from Ray to associated RayTracingObjects if _use_ray_registration.
void	zeroAuxVariables ()
	Zero the AuxVariables that the registered AuxRayKernels contribute to.
void	subdomainHMaxSetup ()
	Caches the hmax for all elements in each subdomain.
RayDataIndex	registerRayDataInternal (const std::string &name, const bool aux)
	Internal method for registering Ray data or Ray aux data with a name.
std::vector< RayDataIndex >	registerRayDataInternal (const std::vector< std::string > &names, const bool aux)
	Internal method for registering Ray data or Ray aux data with names.
RayDataIndex	getRayDataIndexInternal (const std::string &name, const bool aux, const bool graceful) const
	Internal method for getting the index of Ray data or Ray aux data.
std::vector< RayDataIndex >	getRayDataIndicesInternal (const std::vector< std::string > &names, const bool aux, const bool graceful) const
	Internal method for getting the indicies of Ray data or Ray aux data.
const std::string &	getRayDataNameInternal (const RayDataIndex index, const bool aux) const
	Internal method for getting the name of Ray data or Ray aux data.
RayData	getBankedRayDataInternal (const RayID ray_id, const RayDataIndex index, const bool aux) const
	Internal method for getting the value (replicated across all processors) in a Ray's data or aux data from the Ray banks.
RayID	registerRay (const std::string &name)
	Registers a Ray with a given name.
const Moose::FunctionBase *	getKokkosFunctionByNameHelper (const FunctionName &name) const
const UserObjectBase &	getUserObjectFromFEProblem (const UserObjectName &object_name, const THREAD_ID tid=0) const
const T &	castUserObject (const UserObjectBase &uo_base, const std::string &param_name="") const
void	mooseObjectError (const std::string &param_name, std::stringstream &oss) const
const std::string &	userObjectType (const UserObjectBase &uo) const
const std::string &	userObjectName (const UserObjectBase &uo) const
const PostprocessorName &	getPostprocessorNameInternal (const std::string &param_name, const unsigned int index, const bool allow_default_value=true) const
bool	isDefaultPostprocessorValueByName (const PostprocessorName &name) const
PostprocessorValue	getDefaultPostprocessorValueByName (const PostprocessorName &name) const
void	checkParam (const std::string &param_name, const unsigned int index=std::numeric_limits< unsigned int >::max()) const
bool	postprocessorsAdded () const
const VectorPostprocessorValue &	getVectorPostprocessorByNameHelper (const VectorPostprocessorName &name, const std::string &vector_name, bool broadcast, std::size_t t_index) const
const VectorPostprocessorContext< VectorPostprocessorValue > &	getVectorPostprocessorContextByNameHelper (const VectorPostprocessorName &name, const std::string &vector_name) const
bool	vectorPostprocessorsAdded () const
bool	reportersAdded () const
void	possiblyCheckHasReporter (const ReporterName &reporter_name, const std::string &param_name="") const
RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const
void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)
RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const
virtual std::string	meshPropertyPrefix (const std::string &data_name) const
const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const
void	mooseErrorInternal (Args &&... args) const
const VariableValue *	getDefaultValue (const std::string &var_name) const
const ADVariableValue *	getADDefaultValue (const std::string &var_name) const
void	checkVar (const std::string &var_name) const
void	validateExecutionerType (const std::string &name, const std::string &fn_name) const
Moose::Kokkos::Variable	kokkosCoupledVectorTagScalarVariable (const std::string &var_name, const std::string &tag_name, unsigned int comp) const
Moose::MaterialDataType	getMaterialDataType (const std::set< BoundaryID > &boundary_ids) const
unsigned int	getMaxQps () const
void	addConsumedPropertyName (const MooseObjectName &obj_name, const std::string &prop_name)
const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const
const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const
const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const
const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const
void	possiblyCheckHasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const
void	possiblyCheckHasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const
void	possiblyCheckHasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const
void	possiblyCheckHasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)
static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
std::vector< std::shared_ptr< Ray > > &	_local_rays
	Storage for all of the Rays this processor is responsible for (restartable)
ClaimRays	_claim_rays
	The object used to claim Rays.
bool &	_should_claim_rays
	Whether or not we should call claimRays() on the next generateRays() (restartable)
std::vector< libMesh::ElemSideBuilder >	_threaded_elem_side_builders
	Threaded helpers for building element sides without extraneous allocation.
std::chrono::steady_clock::time_point	_execution_start_time
	Timing.
std::chrono::steady_clock::duration	_execution_time
std::chrono::steady_clock::duration	_generation_time
std::chrono::steady_clock::duration	_propagation_time
std::unordered_map< std::string, RayDataIndex >	_ray_data_map
	The map from Ray data names to index.
std::unordered_map< std::string, RayDataIndex >	_ray_aux_data_map
	The map from Ray aux data names to index.
std::vector< std::string >	_ray_data_names
	The names for each Ray data entry.
std::vector< std::string >	_ray_aux_data_names
	The names for each Ray aux data entry.
std::unordered_map< std::string, RayID > &	_registered_ray_map
	Map from registered Ray name to ID.
std::vector< std::string > &	_reverse_registered_ray_map
	Map from registered Ray ID to name.
std::vector< TraceData >	_cached_traces
	Storage for the cached traces.
std::vector< std::vector< TraceData > >	_threaded_cached_traces
	The threaded storage for cached traces.
std::vector< std::size_t >	_num_cached
	Number of currently cached objects for Jacobian/residual for each thread.
std::set< BoundaryID >	_internal_sidesets
	The BoundaryIDs on the local mesh that have internal RayBCs.
std::vector< std::vector< std::vector< BoundaryID > > >	_internal_sidesets_map
	Internal sideset data, if internal sidesets exist (indexed with getLocalElemIndex())
bool	_has_non_planar_sides
	Whether or not the local mesh has elements with non-planar sides.
std::vector< std::vector< unsigned short > >	_non_planar_sides
	Non planar side data, which is for quick checking if an elem side is non-planar We use unsigned short here to avoid a std::vector<bool>; 0 = false, otherwise true.
bool	_has_same_level_active_elems
	Whether or not the mesh has active elements of the same level.
libMesh::BoundingBox	_b_box
	Nodal bounding box for the domain.
libMesh::BoundingBox	_loose_b_box
	Loose nodal bounding box for the domain.
Real	_domain_max_length
	An inflated max distance for the domain.
Real	_total_volume
	The total volume of the domain.
std::vector< TheWarehouse::QueryCache< AttribSubdomains > >	_threaded_cache_ray_kernel
	Threaded cached subdomain query for RayKernelBase objects pertaining to this study.
std::vector< TheWarehouse::QueryCache< AttribBoundaries > >	_threaded_cache_ray_bc
	Threaded cached boundary query for RayBC objects pertaining to this study.
std::vector< std::vector< std::set< const RayTracingObject * > > >	_threaded_ray_object_registration
	Threaded storage for all of the RayTracingObjects associated with a single Ray.
std::vector< std::vector< RayKernelBase * > >	_threaded_current_ray_kernels
	The current RayKernel objects for each thread.
std::vector< std::shared_ptr< TraceRay > >	_threaded_trace_ray
	The TraceRay objects for each thread (they do the physical tracing)
std::vector< std::unique_ptr< libMesh::FEBase > >	_threaded_fe_face
	Face FE used for computing face normals for each thread.
std::vector< std::unique_ptr< libMesh::QBase > >	_threaded_q_face
	Face quadrature used for computing face normals for each thread.
std::vector< std::unordered_map< std::pair< const Elem *, unsigned short >, Point > >	_threaded_cached_normals
	Threaded cache for side normals that have been computed already during tracing.
std::vector< std::shared_ptr< Ray > >	_ray_bank
	Cumulative Ray bank - stored only when _bank_rays_on_completion.
std::vector< RayID >	_threaded_next_ray_id
	Storage for the next available unique RayID, obtained via generateUniqueRayID()
RayID	_replicated_next_ray_id
	Storage for the next available replicated RayID, obtained via generateReplicatedRayID()
const std::unique_ptr< ParallelRayStudy >	_parallel_ray_study
	The study that used is to actually execute (trace) the Rays.
std::unique_ptr< libMesh::QBase >	_segment_qrule
	Quadrature rule for laying points across a 1D ray segment.
unsigned long long int	_ending_processor_crossings
	Total number of processor crossings for Rays that finished on this processor.
unsigned int	_ending_max_processor_crossings
	Max number of total processor crossings for Rays that finished on this processor.
unsigned long long int	_total_processor_crossings
	Total number of processor crossings.
unsigned int	_max_processor_crossings
	Max number of processor crossings for all Rays.
unsigned long long int	_ending_intersections
	Total number of Ray/element intersections for Rays that finished on this processor.
unsigned int	_ending_max_intersections
	Max number of intersections for Rays that finished on this processor.
unsigned int	_ending_max_trajectory_changes
	Max number of trajectory changes for Rays that finished on this processor.
unsigned long long int	_total_intersections
	Total number of Ray/element intersections.
unsigned int	_max_intersections
	Max number of intersections for a single Ray.
unsigned int	_max_trajectory_changes
	Max number of trajectory changes for a single Ray.
Real	_ending_distance
	Total distance traveled by Rays that end on this processor.
Real	_total_distance
	Total distance traveled by all Rays.
std::vector< unsigned long long int >	_local_trace_ray_results
	Cumulative results on this processor from the threaded TraceRay objects.
std::unordered_map< SubdomainID, Real >	_subdomain_hmax
	The cached hmax for all elements in a subdomain.
bool	_called_initial_setup
	Whether or not we've called initial setup - used to stop from late registration.
ElemIndexHelper	_elem_index_helper
	Helper for defining a local contiguous index for each element.
Threads::spin_mutex	_spin_mutex
	Spin mutex object for locks.
UserObject *	_primary_thread_copy
std::set< std::string >	_supplied_uo
const ParallelParamObject &	_parent
const MooseBase &	_si_moose_base
const FEProblemBase *	_si_problem
ExecFlagEnum	_empty_execute_enum
const MooseObject &	_fni_object
const InputParameters &	_fni_params
FEProblemBase &	_fni_feproblem
const THREAD_ID	_fni_tid
const MooseObject &	_uoi_moose_object
const FEProblemBase &	_uoi_feproblem
const THREAD_ID	_uoi_tid
const MooseObject &	_ppi_moose_object
const InputParameters &	_ppi_params
const FEProblemBase &	_ppi_feproblem
std::map< PostprocessorName, std::unique_ptr< PostprocessorValue > >	_default_values
const bool	_broadcast_by_default
const MooseObject &	_vpi_moose_object
const FEProblemBase &	_vpi_feproblem
const THREAD_ID	_vpi_tid
const InputParameters &	_ri_params
FEProblemBase &	_ri_fe_problem_base
const ReporterData &	_ri_reporter_data
const MooseObject &	_ri_moose_object
const InputParameters &	_dni_params
FEProblemBase &	_dni_feproblem
const MooseObject *const	_dni_moose_object_ptr
const InputParameters &	_si_params
FEProblemBase &	_si_feproblem
THREAD_ID	_si_tid
const RestartableDataMapName	_metaname
std::string	_restartable_name
MooseApp &	_meta_data_app
const MooseObject *const	_meta_data_object
const InputParameters &	_sc_parameters
const std::string &	_sc_name
const bool	_sc_is_implicit
std::unordered_map< std::string, std::vector< MooseVariableScalar * > >	_coupled_scalar_vars
std::unordered_map< std::string, std::unique_ptr< VariableValue > >	_default_value
std::unordered_map< std::string, std::unique_ptr< ADVariableValue > >	_dual_default_value
std::vector< MooseVariableScalar * >	_coupled_moose_scalar_vars
std::unordered_map< std::string, std::vector< MooseVariableFieldBase * > >	_sc_coupled_vars
std::set< TagID >	_sc_coupleable_vector_tags
std::set< TagID >	_sc_coupleable_matrix_tags
const MooseObject &	_mi_moose_object
const bool	_mi_boundary_restricted
const std::set< SubdomainID > &	_mi_block_ids
const std::set< BoundaryID > &	_mi_boundary_ids
std::vector< std::unique_ptr< OptionalMaterialPropertyProxyBase< MaterialPropertyInterface > > >	_optional_property_proxies
const std::string	_ti_name

Detailed Description

Definition at line 25 of file RepeatableRayStudyBaseTest.h.

Constructor & Destructor Documentation

RepeatableRayStudyDefineNoClaimTest()

RepeatableRayStudyDefineNoClaimTest::RepeatableRayStudyDefineNoClaimTest

(

const InputParameters &

params

)

Definition at line 55 of file RepeatableRayStudyBaseTest.C.

  : RepeatableRayStudy(parameters)
{
}

Member Function Documentation

acquireCopiedRay()

std::shared_ptr< Ray > RayTracingStudy::acquireCopiedRay ( const Ray &  ray )

protectedinherited

Acquires a Ray that that is copied from another Ray within generateRays().

All of the information is copied except for the counters (intersections, processor crossings, etc), which are reset.

Definition at line 1842 of file RayTracingStudy.C.

{
  mooseAssert(currentlyGenerating(), "Can only use during generateRays()");
  return _parallel_ray_study->acquireParallelData(
      /* tid = */ 0, &ray, Ray::ConstructRayKey());
}

Referenced by RepeatableRayStudyBaseTest::defineRays(), RepeatableRayStudyBase::generateRays(), and RayTracingStudyTest::generateRays().

acquireRay()

std::shared_ptr< Ray > RayTracingStudy::acquireRay ( )

protectedinherited

User APIs for constructing Rays within the RayTracingStudy.

Rays can ONLY be constructed by users within the RayTracingStudy via the following methods. Acquire a Ray from the pool of Rays within generateRays().

A unique ID is generated and assigned to the acquired Ray. The data and aux data sizes are set according to the sizes required by the RayTracingStudy.

Definition at line 1778 of file RayTracingStudy.C.

{
  mooseAssert(currentlyGenerating(), "Can only use during generateRays()");
 
  return _parallel_ray_study->acquireParallelData(
      /* tid = */ 0,
      this,
      generateUniqueRayID(/* tid = */ 0),
      rayDataSize(),
      rayAuxDataSize(),
      /* reset = */ true,
      Ray::ConstructRayKey());
}

Referenced by LotsOfRaysRayStudy::defineRay(), ViewFactorRayStudy::generateRays(), RayTracingStudyTest::generateRays(), StationaryRayStudyTest::generateRays(), TestReuseRaysStudy::generateRays(), TestTransientRaysStudy::generateRays(), and TestRay::generateRays().

acquireRayDuringTrace()

std::shared_ptr< Ray > RayTracingStudy::acquireRayDuringTrace ( const THREAD_ID  tid, const AcquireMoveDuringTraceKey &    )

inherited

INTERNAL methods for acquiring a Ray during a trace in RayKernels and RayBCs.

You should not use these APIs directly. If you wish to acquire a Ray during generation during generateRays()), use the protected RayTracingStudy::acquire{}Ray() methods. If you wish to acquire a Ray during propagation in RayKernels and RayBC, use the protected RayKernelBase::acquireRay() and RayBoundaryConditionBase::acquireRay(), respectively.

Definition at line 1850 of file RayTracingStudy.C.

{
  mooseAssert(currentlyPropagating(), "Can only use during propagation");
  return _parallel_ray_study->acquireParallelData(tid,
                                                  this,
                                                  generateUniqueRayID(tid),
                                                  rayDataSize(),
                                                  rayAuxDataSize(),
                                                  /* reset = */ true,
                                                  Ray::ConstructRayKey());
}

Referenced by RayBoundaryConditionBase::acquireRay(), and RayKernelBase::acquireRay().

acquireRayInternal()

std::shared_ptr< Ray > RayTracingStudy::acquireRayInternal ( const RayID  id, const std::size_t  data_size, const std::size_t  aux_data_size, const bool  reset, const AcquireRayInternalKey &    )

inlineinherited

Definition at line 489 of file RayTracingStudy.h.

  {
    return _parallel_ray_study->acquireParallelData(
        0, this, id, data_size, aux_data_size, reset, Ray::ConstructRayKey());
  }

Referenced by libMesh::Parallel::Packing< std::shared_ptr< Ray > >::unpack().

acquireRegisteredRay()

std::shared_ptr< Ray > RayTracingStudy::acquireRegisteredRay ( const std::string &  name )

protectedinherited

Acquires a Ray with a given name within generateRays().

Used when ray registration is enabled, that is, the private paramater '_use_ray_registration' == true.

This method must be called on all processors at the same time with the same name. This method can only be called on thread 0, which is why there is no thread argument.

Definition at line 1823 of file RayTracingStudy.C.

{
  mooseAssert(currentlyGenerating(), "Can only use during generateRays()");
 
  // Either register a Ray or get an already registered Ray id
  const RayID id = registerRay(name);
 
  // Acquire a Ray with the properly sized data initialized to zero
  return _parallel_ray_study->acquireParallelData(
      /* tid = */ 0,
      this,
      id,
      rayDataSize(),
      rayAuxDataSize(),
      /* reset = */ true,
      Ray::ConstructRayKey());
}

Referenced by RepeatableRayStudy::defineRays(), RepeatableRayStudyBaseTest::defineRays(), and RayTracingStudyTest::generateRays().

acquireReplicatedRay()

std::shared_ptr< Ray > RayTracingStudy::acquireReplicatedRay ( )

protectedinherited

Acquire a Ray from the pool of Rays within generateRays() in a replicated fashion.

That is, this method must be called on all processors at the same time and the ID of the resulting Ray is the same across all processors.

The data and aux data sizes are set according to the sizes required by the RayTracingStudy.

Definition at line 1807 of file RayTracingStudy.C.

{
  mooseAssert(currentlyGenerating(), "Can only use during generateRays()");
  libmesh_parallel_only(comm());
 
  return _parallel_ray_study->acquireParallelData(
      /* tid = */ 0,
      this,
      generateReplicatedRayID(),
      rayDataSize(),
      rayAuxDataSize(),
      /* reset = */ true,
      Ray::ConstructRayKey());
}

Referenced by ConeRayStudy::defineRays(), and TestPICRayStudy::generateRays().

acquireUnsizedRay()

std::shared_ptr< Ray > RayTracingStudy::acquireUnsizedRay ( )

protectedinherited

Acquire a Ray from the pool of Rays within generateRays(), without resizing the data (sizes the data to zero).

A unique ID is generated and assigned to the acquired Ray.

Definition at line 1793 of file RayTracingStudy.C.

{
  mooseAssert(currentlyGenerating(), "Can only use during generateRays()");
 
  return _parallel_ray_study->acquireParallelData(/* tid = */ 0,
                                                  this,
                                                  generateUniqueRayID(/* tid = */ 0),
                                                  /* data_size = */ 0,
                                                  /* aux_data_size = */ 0,
                                                  /* reset = */ true,
                                                  Ray::ConstructRayKey());
}

Referenced by LotsOfRaysRayStudy::defineRay().

auxDataOnCacheTraces()

bool RayTracingStudy::auxDataOnCacheTraces ( ) const

inlineinherited

Whether or not to store the Ray aux data on the cached Ray traces.

Definition at line 573 of file RayTracingStudy.h.

{ return _aux_data_on_cache_traces; }

Referenced by TraceRay::continueTraceOffProcessor(), TraceRay::onCompleteTrace(), TraceRay::onContinueTrace(), TraceRay::onTrajectoryChanged(), RayTracingMeshOutput::RayTracingMeshOutput(), and TraceRay::trace().

bankRaysOnCompletion()

bool RayTracingStudy::bankRaysOnCompletion ( ) const

inlineinherited

Whether or not to bank Rays on completion.

Definition at line 214 of file RayTracingStudy.h.

{ return _bank_rays_on_completion; }

Referenced by RayIntegralValue::initialize(), and RayDataValue::RayDataValue().

boundingBox()

const BoundingBox & RayTracingStudy::boundingBox ( ) const

inlineinherited

Get the nodal bounding box for the domain.

Definition at line 422 of file RayTracingStudy.h.

{ return _b_box; }

Referenced by TestRayDataStudy::auxDataValue(), TestRayDataStudy::dataValue(), LotsOfRaysRayStudy::defineRays(), and TraceRay::trace().

buildSegmentQuadrature()

void RayTracingStudy::buildSegmentQuadrature ( const Point &  start, const Point &  end, const Real  length, std::vector< Point > &  points, std::vector< Real > &  weights  ) const

protectedvirtualinherited

Builds quadrature points for a given segment using the _segment_qrule.

Parameters

start	Start point of the segment
end	End point of the segment
length	The lengh of the start -> end segment
points	Points to fill into (should be sized ahead of time)
weights	Weights to fill into (should be sized ahead of time)

Definition at line 821 of file RayTracingStudy.C.

{
  points.resize(_segment_qrule->n_points());
  weights.resize(_segment_qrule->n_points());
 
  const Point diff = end - start;
  const Point sum = end + start;
  mooseAssert(MooseUtils::absoluteFuzzyEqual(length, diff.norm()), "Invalid length");
 
  // The standard quadrature rule should be on x = [-1, 1]
  // To scale the points, you...
  //  - Scale to size of the segment in 3D
  //    initial_scaled_qp = x_qp * 0.5 * (end - start) = 0.5 * x_qp * diff
  //  - Shift quadrature midpoint to segment midpoint
  //    final_qp = initial_scaled_qp + 0.5 * (end - start) = initial_scaled_qp + 0.5 * sum
  //             = 0.5 * (x_qp * diff + sum)
  for (unsigned int qp = 0; qp < _segment_qrule->n_points(); ++qp)
  {
    points[qp] = 0.5 * (_segment_qrule->qp(qp)(0) * diff + sum);
    weights[qp] = 0.5 * _segment_qrule->w(qp) * length;
  }
}

Referenced by RayTracingStudy::reinitSegment().

claimRaysInternal()

void RepeatableRayStudyBase::claimRaysInternal ( )

privateinherited

Definition at line 138 of file RepeatableRayStudyBase.C.

{
  TIME_SECTION("claimRaysInternal", 2, "Claiming Rays");
 
  _claim_rays.claim();
}

Referenced by RepeatableRayStudyBase::generateRays().

computeTotalVolume()

Real RayTracingStudy::computeTotalVolume ( )

protectedinherited

Helper function for computing the total domain volume.

Definition at line 1498 of file RayTracingStudy.C.

{
  Real volume = 0;
  for (const auto & elem : *_mesh.getActiveLocalElementRange())
    volume += elem->volume();
  _communicator.sum(volume);
  return volume;
}

coverageChecks()

void RayTracingStudy::coverageChecks ( )

privateinherited

Perform coverage checks (coverage of RayMaterials and RayKernels, if enabled)

Definition at line 326 of file RayTracingStudy.C.

{
  // Check for coverage of RayKernels on domain
  if (_ray_kernel_coverage_check)
  {
    std::vector<RayKernelBase *> ray_kernels;
    getRayKernels(ray_kernels, 0);
 
    std::set<SubdomainID> ray_kernel_blocks;
    for (const auto & rk : ray_kernels)
      ray_kernel_blocks.insert(rk->blockIDs().begin(), rk->blockIDs().end());
 
    std::set<SubdomainID> missing;
    std::set_difference(_mesh.meshSubdomains().begin(),
                        _mesh.meshSubdomains().end(),
                        ray_kernel_blocks.begin(),
                        ray_kernel_blocks.end(),
                        std::inserter(missing, missing.begin()));
 
    if (!missing.empty() && !ray_kernel_blocks.count(Moose::ANY_BLOCK_ID))
    {
      std::ostringstream error;
      error << "Subdomains { ";
      std::copy(missing.begin(), missing.end(), std::ostream_iterator<SubdomainID>(error, " "));
      error << "} do not have RayKernels defined!";
 
      mooseError(error.str());
    }
  }
}

Referenced by RayTracingStudy::initialSetup().

currentlyGenerating()

bool RayTracingStudy::currentlyGenerating ( ) const

inlineinherited

Whether or not the study is generating.

Definition at line 641 of file RayTracingStudy.h.

{ return _parallel_ray_study->currentlyPreExecuting(); }

Referenced by RayTracingStudy::acquireCopiedRay(), RayTracingStudy::acquireRay(), RayTracingStudy::acquireRegisteredRay(), RayTracingStudy::acquireReplicatedRay(), RayTracingStudy::acquireUnsizedRay(), RayTracingStudy::moveRaysToBuffer(), RayTracingStudy::moveRayToBuffer(), RayTracingStudy::rayBank(), RayTracingStudy::reserveRayBuffer(), Ray::resetCounters(), RayTracingStudy::resetReplicatedRayIDs(), and RayTracingStudy::resetUniqueRayIDs().

currentlyPropagating()

bool RayTracingStudy::currentlyPropagating ( ) const

inlineinherited

Whether or not the study is propagating (tracing Rays)

Definition at line 637 of file RayTracingStudy.h.

{ return _parallel_ray_study->currentlyExecuting(); }

Referenced by RayBoundaryConditionBase::acquireRay(), RayKernelBase::acquireRay(), RayTracingStudy::acquireRayDuringTrace(), ViewFactorRayStudy::addToViewFactorInfo(), RayKernelBase::changeRayStartDirection(), RayTracingStudy::initThreadedCachedTrace(), RayBoundaryConditionBase::moveRayToBuffer(), RayKernelBase::moveRayToBuffer(), RayTracingStudy::moveRayToBufferDuringTrace(), RayTracingStudy::onCompleteRay(), RayTracingStudy::postOnSegment(), RayTracingStudy::rayBank(), RayTracingStudy::reinitSegment(), RayTracingStudy::resetReplicatedRayIDs(), RayTracingStudy::resetUniqueRayIDs(), RayTracingStudy::segmentSubdomainSetup(), and TraceRay::trace().

currentRayKernels()

const std::vector< RayKernelBase * > & RayTracingStudy::currentRayKernels ( THREAD_ID  tid ) const

inlineinherited

Gets the current RayKernels for a thread, which are set in segmentSubdomainSetup()

Definition at line 414 of file RayTracingStudy.h.

  {
    return _threaded_current_ray_kernels[tid];
  }

Referenced by TraceRay::onCompleteTrace(), TraceRay::onSegment(), TraceRay::onSubdomainChanged(), RayTracingStudy::reinitSegment(), and TraceRay::trace().

currentRayKernelsWrite()

std::vector< RayKernelBase * > & RayTracingStudy::currentRayKernelsWrite ( THREAD_ID  tid )

inlineprotectedinherited

Gets the writeable current RayKernels for a thread.

Allows for other ray studies to fill the current ray kernels in a custom manner

Definition at line 721 of file RayTracingStudy.h.

  {
    return _threaded_current_ray_kernels[tid];
  }

dataOnCacheTraces()

bool RayTracingStudy::dataOnCacheTraces ( ) const

inlineinherited

Whether or not to store the Ray data on the cached Ray traces.

Definition at line 569 of file RayTracingStudy.h.

{ return _data_on_cache_traces; }

Referenced by TraceRay::continueTraceOffProcessor(), TraceRay::onCompleteTrace(), TraceRay::onContinueTrace(), TraceRay::onTrajectoryChanged(), RayTracingMeshOutput::RayTracingMeshOutput(), and TraceRay::trace().

defineRays()

void RepeatableRayStudyDefineNoClaimTest::defineRays ( )

inlineoverrideprotectedvirtual

Entry point for the user to create Rays.

Users must override this function to fill _rays.

See the comments in RepeatableRayStudyBase::generateRays() for more information.

Reimplemented from RepeatableRayStudy.

Definition at line 33 of file RepeatableRayStudyBaseTest.h.

{}

defineRaysInternal()

void RepeatableRayStudyBase::defineRaysInternal ( )

privateinherited

Definition at line 146 of file RepeatableRayStudyBase.C.

{
  {
    TIME_SECTION("defineRaysInternal", 2, "Defining Rays");
 
    _rays.clear();
    _local_rays.clear();
 
    defineRays();
  }
 
  // Do we actually have Rays
  auto num_rays = _rays.size();
  _communicator.sum(num_rays);
  if (!num_rays)
    mooseError("No Rays were moved to _rays in defineRays()");
  for (const auto & ray : _rays)
    if (!ray)
      mooseError("A nullptr Ray was found in _rays after defineRays().");
 
  // The Rays in _rays are ready to go as is: they have their starting element
  // set, their incoming set (if any), and are on the processor that owns said
  // starting element. Therefore, we move them right into _local_rays and
  // set that we don't need to claim.
  if (!_claim_after_define_rays)
  {
    _local_rays.reserve(_rays.size());
    for (const std::shared_ptr<Ray> & ray : _rays)
      _local_rays.emplace_back(ray);
 
    _should_claim_rays = false;
  }
  // Claiming is required after defining. The Rays in _rays should not
  // have their starting elems or incoming sides set - verify that.
  else
  {
    for (const std::shared_ptr<Ray> & ray : _rays)
      if (ray->currentElem() || !ray->invalidCurrentIncomingSide())
        mooseError(
            "A Ray was found in _rays after defineRays() that has a starting element or "
            "incoming side set.\n\n",
            "With the mode in which the private param '_claim_after_define_rays' == true,",
            "\nthe defined Rays at this point should not have their starting elem/side set.\n",
            "\nTheir starting information will be set internally using a claiming process.\n\n",
            ray->getInfo());
  }
 
  // Sanity checks on if the Rays are actually replicated
  if (_define_rays_replicated && verifyRays())
    verifyReplicatedRays();
}

Referenced by RepeatableRayStudyBase::generateRays().

dependencyChecks()

void RayTracingStudy::dependencyChecks ( )

privateinherited

Perform checks to see if the listed dependencies in the RayTracingObjects exist.

Definition at line 358 of file RayTracingStudy.C.

{
  std::vector<RayTracingObject *> ray_tracing_objects;
 
  getRayKernels(ray_tracing_objects, 0);
  verifyDependenciesExist(ray_tracing_objects);
 
  getRayBCs(ray_tracing_objects, 0);
  verifyDependenciesExist(ray_tracing_objects);
}

Referenced by RayTracingStudy::initialSetup().

domainMaxLength()

Real RayTracingStudy::domainMaxLength ( ) const

inlineinherited

Get the inflated maximum length across the domain.

Definition at line 433 of file RayTracingStudy.h.

{ return _domain_max_length; }

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

elemSide()

const libMesh::Elem & RayTracingStudy::elemSide ( const libMesh::Elem &  elem, const unsigned int  s, const THREAD_ID  tid = 0  )

inlineinherited

Get an element's side pointer without excessive memory allocation.

Parameters

elem	The element to build a side for
s	The side to build
tid	The thread id

Returns

A pointer to the side element

Definition at line 689 of file RayTracingStudy.h.

  {
    return _threaded_elem_side_builders[tid](elem, s);
  }

Referenced by LotsOfRaysRayStudy::defineRays(), StationaryRayStudyTest::generateRays(), RayTracingStudy::nonPlanarSideSetup(), and ClaimRays::postClaimRay().

endingDistance()

Real RayTracingStudy::endingDistance ( ) const

inlineinherited

Total amount of distance traveled by the rays that end on this processor.

Definition at line 168 of file RayTracingStudy.h.

{ return _ending_distance; }

endingIntersections()

unsigned long long int RayTracingStudy::endingIntersections ( ) const

inlineinherited

Total number of Ray/element intersections for Rays that finished on this processor.

Definition at line 147 of file RayTracingStudy.h.

{ return _ending_intersections; }

endingMaxIntersections()

unsigned int RayTracingStudy::endingMaxIntersections ( ) const

inlineinherited

Max number of intersections for Rays that finished on this processor.

Definition at line 151 of file RayTracingStudy.h.

{ return _ending_max_intersections; }

endingMaxProcessorCrossings()

unsigned int RayTracingStudy::endingMaxProcessorCrossings ( ) const

inlineinherited

Max number of total processor crossings for Rays that finished on this processor.

Definition at line 134 of file RayTracingStudy.h.

{ return _ending_max_processor_crossings; }

endingProcessorCrossings()

unsigned long long int RayTracingStudy::endingProcessorCrossings ( ) const

inlineinherited

Total number of processor crossings for Rays that finished on this processor.

Definition at line 130 of file RayTracingStudy.h.

{ return _ending_processor_crossings; }

execute()

void RayTracingStudy::execute ( )

overridevirtualinherited

Executes the study (generates and propagates Rays)

Implements GeneralUserObject.

Reimplemented in SingleTraceLineSourceTest.

Definition at line 320 of file RayTracingStudy.C.

{
  executeStudy();
}

Referenced by SingleTraceLineSourceTest::execute().

executeStudy()

void RayTracingStudy::executeStudy ( )

inherited

Method for executing the study so that it can be called out of the standard UO execute()

Definition at line 882 of file RayTracingStudy.C.

{
  TIME_SECTION("executeStudy", 2, "Executing Study");
 
  mooseAssert(_called_initial_setup, "Initial setup not called");
 
  // Reset ray start/complete timers
  _total_intersections = 0;
  _max_intersections = 0;
  _max_trajectory_changes = 0;
 
  // Reset physical tracing stats
  for (auto & val : _local_trace_ray_results)
    val = 0;
 
  // Reset crossing and intersection
  _ending_processor_crossings = 0;
  _total_processor_crossings = 0;
  _ending_max_processor_crossings = 0;
  _ending_intersections = 0;
  _ending_max_intersections = 0;
  _ending_max_trajectory_changes = 0;
  _ending_distance = 0;
  _total_distance = 0;
 
  // Zero the AuxVariables that our AuxRayKernels contribute to before they accumulate
  zeroAuxVariables();
 
  preExecuteStudy();
  for (auto & rto : getRayTracingObjects())
    rto->preExecuteStudy();
 
  _ray_bank.clear();
 
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
  {
    _threaded_trace_ray[tid]->preExecute();
    _threaded_cached_normals[tid].clear();
  }
 
  _communicator.barrier();
  _execution_start_time = std::chrono::steady_clock::now();
 
  _parallel_ray_study->preExecute();
 
  {
    {
      auto generation_start_time = std::chrono::steady_clock::now();
 
      TIME_SECTION("generateRays", 2, "Generating Rays");
 
      generateRays();
 
      _generation_time = std::chrono::steady_clock::now() - generation_start_time;
    }
 
    // At this point, nobody is working so this is good time to make sure
    // Rays are unique across all processors in the working buffer
    if (verifyRays())
    {
      verifyUniqueRays(_parallel_ray_study->workBuffer().begin(),
                       _parallel_ray_study->workBuffer().end(),
                       /* error_suffix = */ "after generateRays()");
 
      verifyUniqueRayIDs(_parallel_ray_study->workBuffer().begin(),
                         _parallel_ray_study->workBuffer().end(),
                         /* global = */ true,
                         /* error_suffix = */ "after generateRays()");
    }
 
    registeredRaySetup();
 
    {
      TIME_SECTION("propagateRays", 2, "Propagating Rays");
 
      const auto propagation_start_time = std::chrono::steady_clock::now();
 
      _parallel_ray_study->execute();
 
      _propagation_time = std::chrono::steady_clock::now() - propagation_start_time;
    }
  }
 
  _execution_time = std::chrono::steady_clock::now() - _execution_start_time;
 
  if (verifyRays())
  {
    verifyUniqueRays(_parallel_ray_study->workBuffer().begin(),
                     _parallel_ray_study->workBuffer().end(),
                     /* error_suffix = */ "after tracing completed");
 
#ifndef NDEBUG
    // Outside of debug, _ray_bank always holds all of the Rays that have ended on this processor
    // We can use this as a global point to check for unique IDs for every Ray that has traced
    verifyUniqueRayIDs(_ray_bank.begin(),
                       _ray_bank.end(),
                       /* global = */ true,
                       /* error_suffix = */ "after tracing completed");
#endif
  }
 
  // Update counters from the threaded trace objects
  for (const auto & tr : _threaded_trace_ray)
    for (std::size_t i = 0; i < _local_trace_ray_results.size(); ++i)
      _local_trace_ray_results[i] += tr->results()[i];
 
  // Update local ending counters
  _total_processor_crossings = _ending_processor_crossings;
  _max_processor_crossings = _ending_max_processor_crossings;
  _total_intersections = _ending_intersections;
  _max_intersections = _ending_max_intersections;
  _max_trajectory_changes = _ending_max_trajectory_changes;
  _total_distance = _ending_distance;
  // ...and communicate the global values
  _communicator.sum(_total_processor_crossings);
  _communicator.max(_max_processor_crossings);
  _communicator.sum(_total_intersections);
  _communicator.max(_max_intersections);
  _communicator.max(_max_trajectory_changes);
  _communicator.sum(_total_distance);
 
  // Throw a warning with the number of failed (tolerated) traces
  if (_tolerate_failure)
  {
    auto failures = _local_trace_ray_results[TraceRay::FAILED_TRACES];
    _communicator.sum(failures);
    if (failures)
      mooseWarning(
          type(), " '", name(), "': ", failures, " ray tracing failures were tolerated.\n");
  }
 
  // Clear the current RayKernels
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
    _threaded_current_ray_kernels[tid].clear();
 
  // Move the threaded cache trace information into the full cached trace vector
  // Here, we only clear the cached vectors so that we might not have to
  // reallocate on future traces
  std::size_t num_entries = 0;
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
    num_entries += _threaded_cached_traces[tid].size();
  _cached_traces.clear();
  _cached_traces.reserve(num_entries);
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
  {
    for (const auto & entry : _threaded_cached_traces[tid])
      _cached_traces.emplace_back(std::move(entry));
    _threaded_cached_traces[tid].clear();
  }
 
  // Add any stragglers that contribute to the Jacobian or residual
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
    if (_num_cached[tid] != 0)
    {
      mooseAssert(_fe_problem.currentlyComputingJacobian() ||
                      _fe_problem.currentlyComputingResidual(),
                  "Should not have cached values without Jacobian/residual computation");
 
      if (_fe_problem.currentlyComputingJacobian())
        _fe_problem.addCachedJacobian(tid);
      else
        _fe_problem.addCachedResidual(tid);
 
      _num_cached[tid] = 0;
    }
 
  // AuxRayKernels may have modified AuxVariables
  _fe_problem.getAuxiliarySystem().solution().close();
  _fe_problem.getAuxiliarySystem().update();
 
  // Clear FE
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
  {
    _fe_problem.clearActiveElementalMooseVariables(tid);
    _fe_problem.clearActiveMaterialProperties(tid);
  }
 
  postExecuteStudy();
  for (auto & rto : getRayTracingObjects())
    rto->postExecuteStudy();
}

Referenced by RayTracingStudy::execute().

executionTime()

Real RayTracingStudy::executionTime ( )

inlineinherited

Duration for execute() in seconds.

Definition at line 189 of file RayTracingStudy.h.

{ return std::chrono::duration<Real>(_execution_time).count(); }

executionTimeNano()

Real RayTracingStudy::executionTimeNano ( )

inlineinherited

Duration for execute() in nanoseconds.

Definition at line 193 of file RayTracingStudy.h.

  {
    return std::chrono::duration<Real, std::nano>(_execution_time).count();
  }

finalize()

virtual void RayTracingStudy::finalize ( )

inlineoverridevirtualinherited

Implements GeneralUserObject.

Definition at line 81 of file RayTracingStudy.h.

{}

generateRays()

void RepeatableRayStudyBase::generateRays ( )

overrideprotectedvirtualinherited

Subclasses should override this to determine how to generate Rays.

This will be called within execute() and makes up the "generation phase" of the algorithm.

Implements RayTracingStudy.

Definition at line 57 of file RepeatableRayStudyBase.C.

{
  // Initially, the user is to define the Rays that they want to trace by overriding
  // defineRays() and filling into _rays within this method. These Rays are not
  // the Rays that will actually be traced, they just serve as a template for
  // Rays that will be put into the tracer to be traced.
  //
  // If the private parameter '_claim_after_define_rays' == true, it is assumed
  // that the Rays that were filled into _rays from the overridden defineRays()
  // do not have their starting element and incoming sides set. The Rays in _rays
  // will be "claimed" later and communicated to the processors that will start them
  // with their starting element set and incoming side set (if any). An example of this
  // is in RepeatableRayStudy.
  //
  // If the private parameter '_claim_after_define_rays' == false, it is assumed
  // that the Rays that were filled into _rays from the overridden defineRays():
  // - Have their starting element and incoming side (if applicable) set and it is
  //   correct
  // - Are on the processor that will start them (the processor that contains
  //   the starting element)
  // At this point, the Rays in _rays will be also inserted into _local_rays
  // because they are on the right processor with starting information set.
  // An example of this is in LotsOfRaysRayStudy.
  if (_should_define_rays)
  {
    _should_define_rays = false;
 
    defineRaysInternal();
  }
 
  if (_should_claim_rays)
  {
    _should_claim_rays = false;
 
    claimRaysInternal();
  }
 
  // Reserve ahead of time how many Rays we are adding to the buffer
  reserveRayBuffer(_local_rays.size());
 
  // To make this study "repeatable", we will not trace the Rays that
  // are ready to go in _local_rays. We will instead create new Rays
  // that are duplicates of the ones in _local_rays, and trace those.
  // This ensures that on multiple executions of this study, we always
  // have the information to create the same Rays.
  for (const auto & ray : _local_rays)
  {
    // This acquires a new ray that is copied from a Ray that has already
    // been claimed to begin on this processor with the user-defined trajectory
    std::shared_ptr<Ray> copied_ray = acquireCopiedRay(*ray);
 
    // This calls std::move() on the ray, which means that copied_ray in this context
    // is no longer valid. We use the move method because copied_ray is a shared_ptr
    // and otherwise we would increase the count as we add it to the buffer and also
    // decrease the count once this goes out of scope.
    moveRayToBuffer(copied_ray);
  }
}

generateReplicatedRayID()

RayID RayTracingStudy::generateReplicatedRayID ( )

protectedinherited

Generates a Ray ID that is replicated across all processors.

Definition at line 1761 of file RayTracingStudy.C.

{
  return _replicated_next_ray_id++;
}

Referenced by RayTracingStudy::acquireReplicatedRay().

generateUniqueRayID()

RayID RayTracingStudy::generateUniqueRayID ( const THREAD_ID  tid )

protectedvirtualinherited

Generates a unique RayID to be used for a Ray.

This is used internally when acquiring new Rays.

Definition at line 1736 of file RayTracingStudy.C.

{
  // Get the current ID to return
  const auto id = _threaded_next_ray_id[tid];
 
  // Advance so that the next call has the correct ID
  _threaded_next_ray_id[tid] += (RayID)n_processors() * (RayID)libMesh::n_threads();
 
  return id;
}

Referenced by RayTracingStudy::acquireRay(), RayTracingStudy::acquireRayDuringTrace(), and RayTracingStudy::acquireUnsizedRay().

generationTime()

Real RayTracingStudy::generationTime ( ) const

inlineinherited

Duration for creation of all Rays in seconds.

Definition at line 200 of file RayTracingStudy.h.

{ return std::chrono::duration<Real>(_generation_time).count(); }

Referenced by PerProcessorRayTracingResultsVectorPostprocessor::execute().

getBankedRay()

std::shared_ptr< Ray > RayTracingStudy::getBankedRay ( const RayID  ray_id ) const

protectedinherited

Gets the Ray with the ID ray_id from the Ray bank.

If the Ray with ray_id is not found across all processors, this will error.

This will ONLY return a valid Ray (not a null shared_ptr) on the processor that has the Ray.

Definition at line 1388 of file RayTracingStudy.C.

{
  // This is only a linear search - can be improved on with a map in the future
  // if this is used on a larger scale
  std::shared_ptr<Ray> ray;
  for (const std::shared_ptr<Ray> & possible_ray : rayBank())
    if (possible_ray->id() == ray_id)
    {
      ray = possible_ray;
      break;
    }
 
  // Make sure one and only one processor has the Ray
  unsigned int have_ray = ray ? 1 : 0;
  _communicator.sum(have_ray);
  if (have_ray == 0)
    mooseError("Could not find a Ray with the ID ", ray_id, " in the Ray banks.");
 
  // This should never happen... but let's make sure
  mooseAssert(have_ray == 1, "Multiple rays with the same ID were found in the Ray banks");
 
  return ray;
}

Referenced by RayTracingStudy::getBankedRayDataInternal().

getBankedRayAuxData()

RayData RayTracingStudy::getBankedRayAuxData ( const RayID  ray_id, const RayDataIndex  index  ) const

inherited

Gets the data value for a banked ray with a given ID.

This will return the value replicated across all processors

Definition at line 1432 of file RayTracingStudy.C.

{
  return getBankedRayDataInternal(ray_id, index, /* aux = */ true);
}

Referenced by RayDataValue::getValue().

getBankedRayData()

RayData RayTracingStudy::getBankedRayData ( const RayID  ray_id, const RayDataIndex  index  ) const

inherited

Gets the data value for a banked ray with a given ID.

This will return the value replicated across all processors

Definition at line 1426 of file RayTracingStudy.C.

{
  return getBankedRayDataInternal(ray_id, index, /* aux = */ false);
}

Referenced by RayDataValue::getValue(), and RayIntegralValue::getValue().

getBankedRayDataInternal()

RayData RayTracingStudy::getBankedRayDataInternal ( const RayID  ray_id, const RayDataIndex  index, const bool  aux  ) const

privateinherited

Internal method for getting the value (replicated across all processors) in a Ray's data or aux data from the Ray banks.

Definition at line 1413 of file RayTracingStudy.C.

{
  // Will be a nullptr shared_ptr if this processor doesn't own the Ray
  const std::shared_ptr<Ray> ray = getBankedRay(ray_id);
 
  Real value = ray ? (aux ? ray->auxData(index) : ray->data(index)) : 0;
  _communicator.sum(value);
  return value;
}

Referenced by RayTracingStudy::getBankedRayAuxData(), and RayTracingStudy::getBankedRayData().

getCachedTraces()

const std::vector< TraceData > & RayTracingStudy::getCachedTraces ( ) const

inlineinherited

Get the cached trace data structure.

Definition at line 595 of file RayTracingStudy.h.

{ return _cached_traces; }

Referenced by RayTracingMeshOutput::buildIDMap(), RayTracingMeshOutput::buildSegmentMesh(), RayTracingMeshOutput::fillFields(), and RayTracingMeshOutput::output().

getElemNormals()

virtual const Point * RayTracingStudy::getElemNormals ( const Elem *  , const THREAD_ID    )

inlinevirtualinherited

Gets the outward normals for a given element.

Returns a pointer to the normal for the zeroth side.

Reimplemented in BackfaceCullingStudyTest.

Definition at line 531 of file RayTracingStudy.h.

  {
    mooseError("Unimplemented element normal caching in ", type(), "::getElemNormals()");
  }

Referenced by TraceRay::moveThroughNeighbor(), RayTracingStudyTest::RayTracingStudyTest(), and TraceRay::trace().

getInternalSidesets() [1/2]

const std::set< BoundaryID > & RayTracingStudy::getInternalSidesets ( ) const

inlineinherited

Gets the internal sidesets (that have RayBCs) within the local domain.

Definition at line 459 of file RayTracingStudy.h.

{ return _internal_sidesets; }

Referenced by ViewFactorRayStudy::initialSetup().

getInternalSidesets() [2/2]

const std::vector< std::vector< BoundaryID > > & RayTracingStudy::getInternalSidesets ( const Elem *  elem ) const

inherited

Get the internal sidesets (that have RayBC(s)) for each side for a given element.

This will be empty if the elem does not have any internal sidesets that have RayBC(s)

Definition at line 1508 of file RayTracingStudy.C.

{
  mooseAssert(_use_internal_sidesets, "Not using internal sidesets");
  mooseAssert(hasInternalSidesets(), "Processor does not have internal sidesets");
  mooseAssert(_internal_sidesets_map.size() > _elem_index_helper.getIndex(elem),
              "Internal sideset map not initialized");
 
  const auto index = _elem_index_helper.getIndex(elem);
  return _internal_sidesets_map[index];
}

Referenced by TraceRay::applyOnInternalBoundary().

getRayAuxDataIndex()

RayDataIndex RayTracingStudy::getRayAuxDataIndex ( const std::string &  name, const bool  graceful = false  ) const

inherited

Gets the index associated with a registered value in the Ray aux data.

Parameters

name	The value name to get the index of
graceful	Whether or not to exit gracefully if none is found (return INVALID_RAY_DATA_INDEX)

Returns

The index for the value

Definition at line 1221 of file RayTracingStudy.C.

{
  return getRayDataIndexInternal(name, /* aux = */ true, graceful);
}

Referenced by RayDataValue::initialize(), RayTracingStudyTest::RayTracingStudyTest(), and RayTracingMeshOutput::setupEquationSystem().

getRayAuxDataIndices()

std::vector< RayDataIndex > RayTracingStudy::getRayAuxDataIndices ( const std::vector< std::string > &  names, const bool  graceful = false  ) const

inherited

Gets the indices associated with registered values in the Ray aux data.

Parameters

names	The value names to get the indices of
graceful	Whether or not to exit gracefully if none is found (index is filled with INVALID_RAY_DATA_INDEX)

Returns

The indices for the values

Definition at line 1228 of file RayTracingStudy.C.

{
  return getRayDataIndicesInternal(names, /* aux = */ true, graceful);
}

getRayAuxDataName()

const std::string & RayTracingStudy::getRayAuxDataName ( const RayDataIndex  index ) const

inherited

Gets the name associated with a registered value in the Ray aux data.

Parameters

index

The index to get the name of

Returns

The name associated with index

Definition at line 1235 of file RayTracingStudy.C.

{
  return getRayDataNameInternal(index, /* aux = */ true);
}

Referenced by Ray::getInfo().

getRayAuxDataNames()

std::vector< std::string > RayTracingStudy::getRayAuxDataNames ( const std::vector< RayDataIndex > &  indices ) const

inherited

Gets the names associated with registered values in the Ray aux data.

Parameters

indices

The indices to get the names of

Returns

The associated names

getRayBCs() [1/4]

void RayTracingStudy::getRayBCs ( std::vector< RayBoundaryConditionBase * > &  result, BoundaryID  id, THREAD_ID  tid  )

inherited

Fills the active RayBCs associated with this study and a boundary into result.

Definition at line 1299 of file RayTracingStudy.C.

{
  // If the cache doesn't have any attributes yet, it means that we haven't set
  // the conditions yet. We do this so that it can be generated on the fly on first use.
  if (!_threaded_cache_ray_bc[tid].numAttribs())
  {
    if (!_called_initial_setup)
      mooseError("Should not call getRayBCs() before initialSetup()");
 
    auto query = _fe_problem.theWarehouse()
                     .query()
                     .condition<AttribRayTracingStudy>(this)
                     .condition<AttribSystem>("RayBoundaryCondition")
                     .condition<AttribThread>(tid);
    _threaded_cache_ray_bc[tid] = query.clone();
  }
 
  _threaded_cache_ray_bc[tid].queryInto(result, std::make_tuple(id, false));
}

Referenced by RayTracingStudy::dependencyChecks(), RayTracingStudy::getRayBCs(), ViewFactorRayStudy::initialSetup(), RayTracingStudy::internalSidesetSetup(), TraceRay::onBoundary(), RayTracingStudy::periodicBoundaryChecks(), and RayTracingStudyTest::RayTracingStudyTest().

getRayBCs() [2/4]

void RayTracingStudy::getRayBCs ( std::vector< RayBoundaryConditionBase * > &  result, const std::vector< TraceRayBndElement > &  bnd_elems, THREAD_ID  tid, RayID  ray_id  )

virtualinherited

Fills the active RayBCs associated with thie study, boundary elements, and potentially Ray into result.

This is purposely virtual because it allows derived studies to optimize the retrieval of RayBCs during the trace in TraceRay.

Definition at line 1322 of file RayTracingStudy.C.

{
  // No Ray registration: no need to sift through objects
  if (!_use_ray_registration)
  {
    if (bnd_elems.size() == 1)
      getRayBCs(result, bnd_elems[0].bnd_id, tid);
    else
    {
      std::vector<BoundaryID> bnd_ids(bnd_elems.size());
      for (MooseIndex(bnd_elems.size()) i = 0; i < bnd_elems.size(); ++i)
        bnd_ids[i] = bnd_elems[i].bnd_id;
      getRayBCs(result, bnd_ids, tid);
    }
  }
  // Has Ray registration: only pick the objects associated with ray_id
  else
  {
    // Get all of the RayBCs on these boundaries
    std::vector<RayBoundaryConditionBase *> rbcs;
    if (bnd_elems.size() == 1)
      getRayBCs(rbcs, bnd_elems[0].bnd_id, tid);
    else
    {
      std::vector<BoundaryID> bnd_ids(bnd_elems.size());
      for (MooseIndex(bnd_elems.size()) i = 0; i < bnd_elems.size(); ++i)
        bnd_ids[i] = bnd_elems[i].bnd_id;
      getRayBCs(rbcs, bnd_ids, tid);
    }
 
    // The RayTracingObjects associated with this ray
    mooseAssert(ray_id < _threaded_ray_object_registration[tid].size(), "Not in registration");
    const auto & ray_id_rtos = _threaded_ray_object_registration[tid][ray_id];
 
    // The result is the union of all of the kernels and the objects associated with this Ray
    result.clear();
    for (auto rbc : rbcs)
      if (ray_id_rtos.count(rbc))
        result.push_back(rbc);
  }
}

getRayBCs() [3/4]

template<typename T >

void RayTracingStudy::getRayBCs ( std::vector< T * > &  result, const std::vector< BoundaryID > &  ids, THREAD_ID  tid  )

inlineinherited

Fills the active RayBCs associated with this study and boundaries result.

Definition at line 376 of file RayTracingStudy.h.

  {
    _fe_problem.theWarehouse()
        .query()
        .condition<AttribRayTracingStudy>(this)
        .condition<AttribSystem>("RayBoundaryCondition")
        .condition<AttribBoundaries>(ids)
        .condition<AttribThread>(tid)
        .queryInto(result);
  }

getRayBCs() [4/4]

template<typename T >

void RayTracingStudy::getRayBCs ( std::vector< T * > &  result, THREAD_ID  tid  )

inlineinherited

Fills the active RayBCs associated with this study into result.

Definition at line 390 of file RayTracingStudy.h.

  {
    _fe_problem.theWarehouse()
        .query()
        .condition<AttribRayTracingStudy>(this)
        .condition<AttribSystem>("RayBoundaryCondition")
        .condition<AttribThread>(tid)
        .queryInto(result);
  }

getRayDataIndex()

RayDataIndex RayTracingStudy::getRayDataIndex ( const std::string &  name, const bool  graceful = false  ) const

inherited

Gets the index associated with a registered value in the Ray data.

Parameters

name	The value name to get the index of
graceful	Whether or not to exit gracefully if none is found (return INVALID_RAY_DATA_INDEX)

Returns

The index for the value

Definition at line 1190 of file RayTracingStudy.C.

{
  return getRayDataIndexInternal(name, /* aux = */ false, graceful);
}

Referenced by RayDataValue::initialize(), RayIntegralValue::initialize(), RayTracingStudyTest::RayTracingStudyTest(), and RayTracingMeshOutput::setupEquationSystem().

getRayDataIndexInternal()

RayDataIndex RayTracingStudy::getRayDataIndexInternal ( const std::string &  name, const bool  aux, const bool  graceful  ) const

privateinherited

Internal method for getting the index of Ray data or Ray aux data.

Definition at line 1126 of file RayTracingStudy.C.

{
  Threads::spin_mutex::scoped_lock lock(_spin_mutex);
 
  const auto & map = aux ? _ray_aux_data_map : _ray_data_map;
  const auto find = map.find(name);
  if (find != map.end())
    return find->second;
 
  if (graceful)
    return Ray::INVALID_RAY_DATA_INDEX;
 
  const auto & other_map = aux ? _ray_data_map : _ray_aux_data_map;
  if (other_map.find(name) != other_map.end())
    mooseError("Ray data with name '",
               name,
               "' was not found.\n\n",
               "However, Ray ",
               (aux ? "non-aux" : "aux"),
               " data with said name was found.\n",
               "Did you mean to use ",
               (aux ? "getRayDataIndex()/getRayDataIndices()?"
                    : "getRayAuxDataIndex()/getRayAuxDataIndices()"),
               "?");
 
  mooseError("Unknown Ray ", (aux ? "aux " : ""), "data with name ", name);
}

Referenced by RayTracingStudy::getRayAuxDataIndex(), RayTracingStudy::getRayDataIndex(), and RayTracingStudy::getRayDataIndicesInternal().

getRayDataIndices()

std::vector< RayDataIndex > RayTracingStudy::getRayDataIndices ( const std::vector< std::string > &  names, const bool  graceful = false  ) const

inherited

Gets the indices associated with registered values in the Ray data.

Parameters

names	The value names to get the indices of
graceful	Whether or not to exit gracefully if none is found (index is filled with INVALID_RAY_DATA_INDEX)

Returns

The indices for the values

Definition at line 1196 of file RayTracingStudy.C.

{
  return getRayDataIndicesInternal(names, /* aux = */ false, graceful);
}

getRayDataIndicesInternal()

std::vector< RayDataIndex > RayTracingStudy::getRayDataIndicesInternal ( const std::vector< std::string > &  names, const bool  aux, const bool  graceful  ) const

privateinherited

Internal method for getting the indicies of Ray data or Ray aux data.

Definition at line 1157 of file RayTracingStudy.C.

{
  std::vector<RayDataIndex> indices(names.size());
  for (std::size_t i = 0; i < names.size(); ++i)
    indices[i] = getRayDataIndexInternal(names[i], aux, graceful);
  return indices;
}

Referenced by RayTracingStudy::getRayAuxDataIndices(), and RayTracingStudy::getRayDataIndices().

getRayDataName()

const std::string & RayTracingStudy::getRayDataName ( const RayDataIndex  index ) const

inherited

Gets the name associated with a registered value in the Ray data.

Parameters

index

The index to get the name of

Returns

The name associated with index

Definition at line 1203 of file RayTracingStudy.C.

{
  return getRayDataNameInternal(index, /* aux = */ false);
}

Referenced by Ray::getInfo(), and RayTracingStudyTest::RayTracingStudyTest().

getRayDataNameInternal()

const std::string & RayTracingStudy::getRayDataNameInternal ( const RayDataIndex  index, const bool  aux  ) const

privateinherited

Internal method for getting the name of Ray data or Ray aux data.

Definition at line 1168 of file RayTracingStudy.C.

{
  Threads::spin_mutex::scoped_lock lock(_spin_mutex);
 
  if ((aux ? rayAuxDataSize() : rayDataSize()) < index)
    mooseError("Unknown Ray ", aux ? "aux " : "", "data with index ", index);
  return aux ? _ray_aux_data_names[index] : _ray_data_names[index];
}

Referenced by RayTracingStudy::getRayAuxDataName(), and RayTracingStudy::getRayDataName().

getRayDataNames()

std::vector< std::string > RayTracingStudy::getRayDataNames ( const std::vector< RayDataIndex > &  indices ) const

inherited

Gets the names associated with registered values in the Ray data.

Parameters

indices

The indices to get the names of

Returns

The associated names

getRayKernels() [1/3]

void RayTracingStudy::getRayKernels ( std::vector< RayKernelBase * > &  result, SubdomainID  id, THREAD_ID  tid  )

inherited

Fills the active RayKernels associated with this study and a block into result.

Definition at line 1249 of file RayTracingStudy.C.

{
  // If the cache doesn't have any attributes yet, it means that we haven't set
  // the conditions yet. We do this so that it can be generated on the fly on first use.
  if (!_threaded_cache_ray_kernel[tid].numAttribs())
  {
    if (!_called_initial_setup)
      mooseError("Should not call getRayKernels() before initialSetup()");
 
    auto query = _fe_problem.theWarehouse()
                     .query()
                     .condition<AttribRayTracingStudy>(this)
                     .condition<AttribSystem>("RayKernel")
                     .condition<AttribThread>(tid);
    _threaded_cache_ray_kernel[tid] = query.clone();
  }
 
  _threaded_cache_ray_kernel[tid].queryInto(result, id);
}

Referenced by RayTracingStudy::coverageChecks(), RayTracingStudy::dependencyChecks(), RayTracingStudy::getRayKernels(), RayTracingStudy::hasRayKernels(), RayTracingStudy::initialSetup(), RayTracingStudyTest::RayTracingStudyTest(), RayTracingStudy::segmentSubdomainSetup(), and RayTracingStudy::zeroAuxVariables().

getRayKernels() [2/3]

void RayTracingStudy::getRayKernels ( std::vector< RayKernelBase * > &  result, SubdomainID  id, THREAD_ID  tid, RayID  ray_id  )

inherited

Fills the active RayKernels associeted with this study, block, and potentially Ray into result.

Definition at line 1270 of file RayTracingStudy.C.

{
  // No Ray registration: no need to sift through objects
  if (!_use_ray_registration)
  {
    getRayKernels(result, id, tid);
  }
  // Has Ray registration: only pick the objects associated with ray_id
  else
  {
    // Get all of the kernels on this block
    std::vector<RayKernelBase *> rkbs;
    getRayKernels(rkbs, id, tid);
 
    // The RayTracingObjects associated with this ray
    const auto & ray_id_rtos = _threaded_ray_object_registration[tid][ray_id];
 
    // The result is the union of all of the kernels and the objects associated with this Ray
    result.clear();
    for (auto rkb : rkbs)
      if (ray_id_rtos.count(rkb))
        result.push_back(rkb);
  }
}

getRayKernels() [3/3]

template<typename T >

void RayTracingStudy::getRayKernels ( std::vector< T * > &  result, THREAD_ID  tid  )

inlineinherited

Fills the active RayKernels associated with this study into result.

Definition at line 354 of file RayTracingStudy.h.

  {
    _fe_problem.theWarehouse()
        .query()
        .condition<AttribRayTracingStudy>(this)
        .condition<AttribSystem>("RayKernel")
        .condition<AttribThread>(tid)
        .queryInto(result);
  }

getRayTracingObjects()

std::vector< RayTracingObject * > RayTracingStudy::getRayTracingObjects ( )

protectedinherited

Gets all of the currently active RayTracingObjects.

Definition at line 1368 of file RayTracingStudy.C.

{
  std::vector<RayTracingObject *> result;
  _fe_problem.theWarehouse().query().condition<AttribRayTracingStudy>(this).queryInto(result);
  return result;
}

Referenced by RayTracingStudy::executeStudy(), RayTracingStudy::initialSetup(), RayTracingStudy::jacobianSetup(), RayTracingStudy::registeredRaySetup(), RayTracingStudy::residualSetup(), and RayTracingStudy::timestepSetup().

getSideNormal()

const Point & RayTracingStudy::getSideNormal ( const Elem *  elem, const unsigned short  side, const THREAD_ID  tid  )

virtualinherited

Get the outward normal for a given element side.

Definition at line 1661 of file RayTracingStudy.C.

{
  std::unordered_map<std::pair<const Elem *, unsigned short>, Point> & cache =
      _threaded_cached_normals[tid];
 
  // See if we've already cached this side normal
  const auto elem_side_pair = std::make_pair(elem, side);
  const auto search = cache.find(elem_side_pair);
 
  // Haven't cached this side normal: compute it and then cache it
  if (search == cache.end())
  {
    _threaded_fe_face[tid]->reinit(elem, side);
    const auto & normal = _threaded_fe_face[tid]->get_normals()[0];
    cache.emplace(elem_side_pair, normal);
    return normal;
  }
 
  // Have cached this side normal: simply return it
  return search->second;
}

Referenced by LotsOfRaysRayStudy::defineRays(), BackfaceCullingStudyTest::generateNormals(), ViewFactorRayStudy::generateRays(), TraceRay::getEdgeNeighbors(), TraceRay::getPointNeighbors(), TraceRay::getVertexNeighbors(), ReflectRayBC::onBoundary(), RayTracingStudy::sideIsIncoming(), and TraceRay::trace().

hasInternalSidesets()

bool RayTracingStudy::hasInternalSidesets ( ) const

inlineinherited

Whether or not the local mesh has internal sidesets that have RayBCs on them.

NOTE: if useInternalSidesets() == false, this will be false even if the mesh does have internal sidesets

Definition at line 449 of file RayTracingStudy.h.

{ return _internal_sidesets.size(); }

Referenced by TraceRay::applyOnInternalBoundary(), RayTracingStudy::getInternalSidesets(), and TraceRay::trace().

hasRayAuxData()

bool RayTracingStudy::hasRayAuxData ( ) const

inlineinherited

Whether or not any Ray aux data are registered.

Definition at line 336 of file RayTracingStudy.h.

{ return _ray_aux_data_names.size(); }

hasRayData()

bool RayTracingStudy::hasRayData ( ) const

inlineinherited

Whether or not any Ray data are registered.

Definition at line 276 of file RayTracingStudy.h.

{ return _ray_data_names.size(); }

Referenced by RayTracingMeshOutput::fillFields().

hasRayKernels()

bool RayTracingStudy::hasRayKernels ( const THREAD_ID  tid )

inherited

Whether or not there are currently any active RayKernel objects.

Definition at line 1241 of file RayTracingStudy.C.

{
  std::vector<RayKernelBase *> result;
  getRayKernels(result, tid);
  return result.size();
}

Referenced by ViewFactorRayStudy::initialSetup(), and TraceRay::preExecute().

hasSameLevelActiveElems()

bool RayTracingStudy::hasSameLevelActiveElems ( ) const

inlineinherited

Whether or not the mesh has active elements of the same level.

Use this over sameLevelActiveElems(), which is for internally setting _has_same_level_active_elems

Definition at line 475 of file RayTracingStudy.h.

{ return _has_same_level_active_elems; }

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

initialize()

virtual void RayTracingStudy::initialize ( )

inlineoverridevirtualinherited

Implements GeneralUserObject.

Definition at line 80 of file RayTracingStudy.h.

{}

initialSetup()

void RayTracingStudy::initialSetup ( )

overridevirtualinherited

Reimplemented from GeneralUserObject.

Reimplemented in ViewFactorRayStudy, and BackfaceCullingStudyTest.

Definition at line 233 of file RayTracingStudy.C.

{
  // Keep track of initialSetup call to avoid registration of various things
  _called_initial_setup = true;
 
  // Sets up a local index for each elem this proc knows about
  localElemIndexSetup();
 
  // Check for RayKernel coverage
  coverageChecks();
 
  // Make sure the dependencies exist, if any
  dependencyChecks();
 
  // Check for traceable element types
  traceableMeshChecks();
 
  // Check for sane periodic boundaries
  periodicBoundaryChecks();
 
  // Setup for internal sidesets
  internalSidesetSetup();
 
  nonPlanarSideSetup();
 
  // Setup approximate hmax for each subdomain
  subdomainHMaxSetup();
 
  // Call initial setup on all of the objects
  for (auto & rto : getRayTracingObjects())
    rto->initialSetup();
 
  // Check for proper exec flags with RayKernels
  std::vector<RayKernelBase *> ray_kernels;
  getRayKernels(ray_kernels, 0);
  for (const auto & rkb : ray_kernels)
    if (dynamic_cast<RayKernel *>(rkb) && !_execute_enum.isValueSet(EXEC_PRE_KERNELS))
      mooseError("This study has RayKernel objects that contribute to residuals and Jacobians.",
                 "\nIn this case, the study must use the execute_on = PRE_KERNELS");
 
  // Build 1D quadrature rule for along a segment
  _segment_qrule = QBase::build(
      libMesh::QGAUSS, 1, _fe_problem.getSystemBase(_sys.number()).getMinQuadratureOrder());
}

Referenced by ViewFactorRayStudy::initialSetup().

initThreadedCachedTrace()

TraceData & RayTracingStudy::initThreadedCachedTrace ( const std::shared_ptr< Ray > &  ray, THREAD_ID  tid  )

inherited

Initialize a Ray in the threaded cached trace map to be filled with segments.

Definition at line 1520 of file RayTracingStudy.C.

{
  mooseAssert(shouldCacheTrace(ray), "Not caching trace");
  mooseAssert(currentlyPropagating(), "Should only use while tracing");
 
  _threaded_cached_traces[tid].emplace_back(ray);
  return _threaded_cached_traces[tid].back();
}

Referenced by TraceRay::trace().

internalSidesetSetup()

void RayTracingStudy::internalSidesetSetup ( )

privateinherited

Does the setup for internal sidesets.

This includes:

• Setting if the local mesh has internal sidesets that have RayBCs and on which boundary (stored in _internal_sidesets)
• Sets up the internal sideset mapping that maps element sides to the BoundaryIDs on said side that have internal sidesets that have RayBCs (stored in _internal_sidesets_map)

If _use_internal_sidesets == false, this will still check to make sure that the user does not have internal sidesets with RayBCs on them, and will report an error if so.

Definition at line 523 of file RayTracingStudy.C.

{
  // Even if we have _use_internal_sidesets == false, we will make sure the user didn't add RayBCs
  // on internal boundaries
 
  // Clear the data structures and size the map based on the elements that we know about
  _internal_sidesets.clear();
  _internal_sidesets_map.clear();
  _internal_sidesets_map.resize(_elem_index_helper.maxIndex() + 1);
 
  // First, we are going to store all elements with internal sidesets (if any) that have active
  // RayBCs on them as elem -> vector of (side, vector of boundary ids)
  for (const auto & bnd_elem : *_mesh.getBoundaryElementRange())
  {
    Elem * elem = bnd_elem->_elem;
    const unsigned int side = bnd_elem->_side;
    const auto bnd_id = bnd_elem->_bnd_id;
 
    // Not internal
    const Elem * const neighbor = elem->neighbor_ptr(side);
    if (!neighbor || neighbor == remote_elem)
      continue;
 
    // No RayBCs on this sideset
    std::vector<RayBoundaryConditionBase *> result;
    getRayBCs(result, bnd_id, 0);
    if (result.empty())
      continue;
 
    if (neighbor->subdomain_id() == elem->subdomain_id())
      mooseError("RayBCs exist on internal sidesets that are not bounded by a different",
                 "\nsubdomain on each side.",
                 "\n\nIn order to use RayBCs on internal sidesets, said sidesets must have",
                 "\na different subdomain on each side.");
 
    // Mark that this boundary is an internal sideset with RayBC(s)
    _internal_sidesets.insert(bnd_id);
 
    // Get elem's entry in the internal sidset data structure
    const auto index = _elem_index_helper.getIndex(elem);
    auto & entry = _internal_sidesets_map[index];
 
    // Initialize this elem's sides if they have not been already
    if (entry.empty())
      entry.resize(elem->n_sides(), std::vector<BoundaryID>());
 
    // Add the internal boundary to the side entry
    entry[side].push_back(bnd_id);
  }
 
  if (!_use_internal_sidesets && _internal_sidesets.size())
    mooseError("RayBCs are defined on internal sidesets, but the study is not set to use ",
               "internal sidesets during tracing.",
               "\n\nSet the parameter use_internal_sidesets = true to enable this capability.");
}

Referenced by RayTracingStudy::initialSetup(), and RayTracingStudy::meshChanged().

isRectangularDomain()

bool RayTracingStudy::isRectangularDomain ( ) const

inherited

Whether or not the domain is rectangular (if it is prefectly encompassed by its bounding box)

Definition at line 1712 of file RayTracingStudy.C.

{
  Real bbox_volume = 1;
  for (unsigned int d = 0; d < _mesh.dimension(); ++d)
    bbox_volume *= std::abs(_b_box.max()(d) - _b_box.min()(d));
 
  return MooseUtils::absoluteFuzzyEqual(bbox_volume, totalVolume(), TOLERANCE);
}

Referenced by LotsOfRaysRayStudy::LotsOfRaysRayStudy(), and TraceRay::preExecute().

jacobianSetup()

void RayTracingStudy::jacobianSetup ( )

overridevirtualinherited

Reimplemented from GeneralUserObject.

Definition at line 289 of file RayTracingStudy.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
    mooseAssert(_num_cached[tid] == 0, "Cached residuals/Jacobians not empty");
 
  for (auto & rto : getRayTracingObjects())
    rto->jacobianSetup();
}

localElemIndexSetup()

void RayTracingStudy::localElemIndexSetup ( )

privateinherited

Sets up the _elem_index_helper, which is used for obtaining a contiguous index for all elements that this processor knows about.

Said index is used for quickly accessing things like internal sidesets and checking if an element side is non-planar during tracing.

Definition at line 515 of file RayTracingStudy.C.

{
  // TODO: We could probably minimize this to local active elements followed by
  // boundary point neighbors, but if using distibuted mesh it really shouldn't matter
  _elem_index_helper.initialize(_mesh.getMesh().active_element_ptr_range());
}

Referenced by RayTracingStudy::initialSetup(), and RayTracingStudy::meshChanged().

localTraceRayResult()

unsigned long long int RayTracingStudy::localTraceRayResult ( const int  result ) const

inlineinherited

Definition at line 174 of file RayTracingStudy.h.

  {
    return _local_trace_ray_results[result];
  }

Referenced by PerProcessorRayTracingResultsVectorPostprocessor::execute().

looseBoundingBox()

const BoundingBox & RayTracingStudy::looseBoundingBox ( ) const

inlineinherited

Get the loose nodal bounding box for the domain.

BoundingBox::contains_point does not have a tolerance, so we need to stretch the box a little bit for some contains_point checks.

Definition at line 429 of file RayTracingStudy.h.

{ return _loose_b_box; }

Referenced by Ray::setStart(), and Ray::setStartingEndPoint().

maxIntersections()

unsigned int RayTracingStudy::maxIntersections ( ) const

inlineinherited

Max number of intersections for a Ray.

Definition at line 159 of file RayTracingStudy.h.

{ return _max_intersections; }

maxProcessorCrossings()

unsigned int RayTracingStudy::maxProcessorCrossings ( ) const

inlineinherited

Max number of processor crossings for all Rays.

Definition at line 142 of file RayTracingStudy.h.

{ return _max_processor_crossings; }

Referenced by RayTracingStudyResult::getValue().

maxTrajectoryChanges()

unsigned int RayTracingStudy::maxTrajectoryChanges ( ) const

inlineinherited

Max number of trajectory changes for a Ray.

Definition at line 163 of file RayTracingStudy.h.

{ return _max_trajectory_changes; }

mesh()

MooseMesh & RayTracingStudy::mesh ( )

inlineinherited

Returns

A reference to the MooseMesh associated with this study.

Definition at line 520 of file RayTracingStudy.h.

{ return _mesh; }

meshBase()

MeshBase & RayTracingStudy::meshBase ( ) const

inlineinherited

Access to the libMesh MeshBase.

This is needed for unpack routines for a Ray, which has a context of this study.

Definition at line 515 of file RayTracingStudy.h.

{ return _mesh; }

Referenced by TestRay::generateRays(), libMesh::Parallel::Packing< std::shared_ptr< Ray > >::pack(), libMesh::Parallel::Packing< ViewFactorRayStudy::StartElem >::pack(), TestRayLots::postExecuteStudy(), RayTracingStudyTest::RayTracingStudyTest(), Ray::setStart(), libMesh::Parallel::Packing< std::shared_ptr< Ray > >::unpack(), and libMesh::Parallel::Packing< ViewFactorRayStudy::StartElem >::unpack().

meshChanged()

void RepeatableRayStudyBase::meshChanged ( )

overrideprotectedvirtualinherited

Reimplemented from RayTracingStudy.

Reimplemented in BackfaceCullingStudyTest.

Definition at line 117 of file RepeatableRayStudyBase.C.

{
  RayTracingStudy::meshChanged();
 
  // Need to reclaim after this
  _should_claim_rays = true;
 
  // Invalidate all of the old starting info because we can't be sure those elements still exist
  for (const auto & ray : _rays)
  {
    ray->invalidateStartingElem();
    ray->invalidateStartingIncomingSide();
  }
  for (const auto & ray : _local_rays)
  {
    ray->invalidateStartingElem();
    ray->invalidateStartingIncomingSide();
  }
}

moveRaysToBuffer()

void RayTracingStudy::moveRaysToBuffer ( std::vector< std::shared_ptr< Ray > > &  rays )

protectedinherited

Moves rays to the buffer to be traced during generateRays().

This moves the rays into the buffer (with std::move), therefore all valid rays in rays will be nullptr after this call.

Definition at line 1626 of file RayTracingStudy.C.

{
  mooseAssert(currentlyGenerating(), "Can only use while generating");
#ifndef NDEBUG
  for (const std::shared_ptr<Ray> & ray : rays)
  {
    mooseAssert(ray, "Null ray");
    mooseAssert(ray->shouldContinue(), "Ray is not continuing");
  }
#endif
 
  _parallel_ray_study->moveWorkToBuffer(rays, /* tid = */ 0);
}

Referenced by TestPICRayStudy::generateRays(), TestReuseRaysStudy::generateRays(), and TestTransientRaysStudy::generateRays().

moveRayToBuffer()

void RayTracingStudy::moveRayToBuffer ( std::shared_ptr< Ray > &  ray )

protectedinherited

Moves a ray to the buffer to be traced during generateRays().

This moves the Ray into the buffer (with std::move), therefore ray will be nullptr after this call.

Definition at line 1616 of file RayTracingStudy.C.

{
  mooseAssert(currentlyGenerating(), "Can only use while generating");
  mooseAssert(ray, "Null ray");
  mooseAssert(ray->shouldContinue(), "Ray is not continuing");
 
  _parallel_ray_study->moveWorkToBuffer(ray, /* tid = */ 0);
}

Referenced by ViewFactorRayStudy::generateRays(), RepeatableRayStudyBase::generateRays(), RayTracingStudyTest::generateRays(), StationaryRayStudyTest::generateRays(), TestReuseRaysStudy::generateRays(), and TestTransientRaysStudy::generateRays().

moveRayToBufferDuringTrace()

void RayTracingStudy::moveRayToBufferDuringTrace ( std::shared_ptr< Ray > &  ray, const THREAD_ID  tid, const AcquireMoveDuringTraceKey &    )

inherited

INTERNAL method for moving a Ray into the buffer during tracing.

You should not and cannot use this API. It is protected by the AcquireMoveDuringTraceKey, which is only constructable by RayKernelBase and RayBoundaryConditionBase.

Definition at line 1641 of file RayTracingStudy.C.

{
  mooseAssert(ray, "Null ray");
  mooseAssert(currentlyPropagating(), "Can only use while tracing");
 
  _parallel_ray_study->moveWorkToBuffer(ray, tid);
}

Referenced by RayBoundaryConditionBase::moveRayToBuffer(), and RayKernelBase::moveRayToBuffer().

nonPlanarSideSetup()

void RayTracingStudy::nonPlanarSideSetup ( )

privateinherited

Sets up the caching of whether or not each element side is non-planar, which is stored in _non_planar_sides.

This is done because this check is made within TraceRay, and determining whether or not a side is non planar is quite expensive and we don't want to call it mid-trace.

Definition at line 580 of file RayTracingStudy.C.

{
  _has_non_planar_sides = false;
  bool warned = !_warn_non_planar;
 
  // Nothing to do here for 2D or 1D
  if (_mesh.dimension() != 3)
    return;
 
  // Clear the data structure and size it based on the elements that we know about
  _non_planar_sides.clear();
  _non_planar_sides.resize(_elem_index_helper.maxIndex() + 1);
 
  for (const Elem * elem : _mesh.getMesh().active_element_ptr_range())
  {
    const auto index = _elem_index_helper.getIndex(elem);
    auto & entry = _non_planar_sides[index];
    entry.resize(elem->n_sides(), 0);
 
    for (const auto s : elem->side_index_range())
    {
      const auto & side = elemSide(*elem, s);
      if (side.n_vertices() < 4)
        continue;
 
      if (!side.has_affine_map())
      {
        entry[s] = 1;
        _has_non_planar_sides = true;
 
        if (!warned)
        {
          mooseWarning("The mesh contains non-planar faces.\n\n",
                       "Ray tracing on non-planar faces is an approximation and may fail.\n\n",
                       "Use at your own risk! You can disable this warning by setting the\n",
                       "parameter 'warn_non_planar' to false.");
          warned = true;
        }
      }
    }
  }
}

Referenced by RayTracingStudy::initialSetup(), and RayTracingStudy::meshChanged().

onCompleteRay()

void RayTracingStudy::onCompleteRay ( const std::shared_ptr< Ray > &  ray )

virtualinherited

Entry point for acting on a ray when it is completed (shouldContinue() == false)

Reimplemented in TestRayDataStudy.

Definition at line 1065 of file RayTracingStudy.C.

{
  mooseAssert(currentlyPropagating(), "Should only be called during Ray propagation");
 
  _ending_processor_crossings += ray->processorCrossings();
  _ending_max_processor_crossings =
      std::max(_ending_max_processor_crossings, ray->processorCrossings());
  _ending_intersections += ray->intersections();
  _ending_max_intersections = std::max(_ending_max_intersections, ray->intersections());
  _ending_max_trajectory_changes =
      std::max(_ending_max_trajectory_changes, ray->trajectoryChanges());
  _ending_distance += ray->distance();
 
#ifdef NDEBUG
  // In non-opt modes, we will always bank the Rays for debugging
  if (_bank_rays_on_completion)
#endif
    _ray_bank.emplace_back(ray);
}

Referenced by TestRayDataStudy::onCompleteRay(), and ParallelRayStudy::postExecuteChunk().

parallelRayStudy()

const ParallelRayStudy & RayTracingStudy::parallelRayStudy ( ) const

inlineinherited

Definition at line 179 of file RayTracingStudy.h.

{ return *_parallel_ray_study; }

Referenced by PerProcessorRayTracingResultsVectorPostprocessor::execute(), and RayTracingStudyResult::getValue().

parallelStudy()

ParallelStudy< std::shared_ptr< Ray >, Ray > * RayTracingStudy::parallelStudy ( )

inlineinherited

The underlying parallel study: used for the context for calling the packed range routines.

Definition at line 678 of file RayTracingStudy.h.

{ return _parallel_ray_study.get(); }

Referenced by RayTracingStudyTest::generateRays(), and RepeatableRayStudyBase::verifyReplicatedRays().

periodicBoundaryChecks()

void RayTracingStudy::periodicBoundaryChecks ( )

privateinherited

Check for overlapping PeriodicRayBC boundaries and check for cases in which ghosting may not be sufficient with distributed mesh for overlapping periodic boundaries.

Definition at line 408 of file RayTracingStudy.C.

{
  // Collect the PeriodicRayBCs
  std::vector<const RayBoundaryConditionBase *> rbc_ptrs;
  getRayBCs(rbc_ptrs, 0);
  std::vector<const PeriodicRayBC *> prbc_ptrs;
  for (const auto rbc_ptr : rbc_ptrs)
    if (const auto prbc_ptr = dynamic_cast<const PeriodicRayBC *>(rbc_ptr))
      prbc_ptrs.push_back(prbc_ptr);
  if (prbc_ptrs.empty())
    return;
 
  // Collect each of the periodic boundaries
  std::map<boundary_id_type,
           std::tuple<const PeriodicRayBC *,
                      const libMesh::PeriodicBoundaryBase *,
                      std::unordered_set<dof_id_type>>>
      boundary_map;
  for (const auto prbc_ptr : prbc_ptrs)
  {
    for (const auto & [bid, pb] : prbc_ptr->getPeriodicBoundaries())
    {
      const auto [it, inserted] = boundary_map.emplace(
          std::piecewise_construct,
          std::tuple{bid},
          std::forward_as_tuple(prbc_ptr, pb.get(), std::unordered_set<dof_id_type>()));
      if (!inserted)
        prbc_ptr->mooseError("The periodic boundary '",
                             _mesh.getBoundaryString(bid),
                             "' has been defined in both ",
                             prbc_ptr->typeAndName(),
                             " and ",
                             std::get<0>(it->second)->typeAndName());
    }
  }
 
  // Because we don't have ghosting setup correctly yet, we need to check if any
  // of the periodic boundaries are neighbors with distributed mesh. If the
  // mesh is replicated, we don't need to check this. See #31280.
  if (comm().size() == 1 || !_mesh.isDistributedMesh())
    return;
 
  // Collect all of the nodes that are on each periodic boundary
  const auto & sideset_map = _mesh.getMesh().get_boundary_info().get_sideset_map();
  for (const auto & [elem, side_bid_pair] : sideset_map)
  {
    const auto [side, bid] = side_bid_pair;
    if (auto it = boundary_map.find(bid); it != boundary_map.end())
      for (const auto n : elem->nodes_on_side(side))
        std::get<2>(it->second).insert(elem->node_ref(n).id());
  }
 
  // Distributed meshes have distributed boundary information, so sync
  for (auto & bid_tuple_pair : boundary_map)
    comm().set_union(std::get<2>(bid_tuple_pair.second));
 
  // Check for periodic boundaries that share nodes
  std::map<std::pair<boundary_id_type, boundary_id_type>,
           std::pair<const PeriodicRayBC *, const PeriodicRayBC *>>
      warn_boundaries;
  for (auto it = boundary_map.begin(); it != boundary_map.end(); ++it)
  {
    const auto & [bid, tup] = *it;
    const auto [prbc_ptr, pb, node_ids] = tup;
 
    for (auto other_it = std::next(it); other_it != boundary_map.end(); ++other_it)
    {
      const auto & [other_bid, other_tup] = *other_it;
 
      // Don't check against boundaries that are paried together
      if (pb->pairedboundary == other_bid)
        continue;
 
      const auto other_prbc_ptr = std::get<0>(other_tup);
      const auto & other_node_ids = std::get<2>(other_tup);
      for (const auto node_id : node_ids)
        if (other_node_ids.count(node_id))
        {
          if (!warn_boundaries.count(std::make_pair(other_bid, bid)))
            warn_boundaries.emplace(std::make_pair(bid, other_bid),
                                    std::make_pair(prbc_ptr, other_prbc_ptr));
          break;
        }
    }
  }
 
  if (warn_boundaries.size())
  {
    std::ostringstream oss;
    oss << warn_boundaries.size()
        << " ray tracing periodic boundaries were found to be neighbors:\n\n";
    for (const auto & [bids_pair, prbc_ptrs_pair] : warn_boundaries)
    {
      const auto [bid, paired_bid] = bids_pair;
      const auto [prbc_ptr, paired_prbc_ptr] = prbc_ptrs_pair;
      oss << "  '" << _mesh.getBoundaryString(bid) << "' (in " << prbc_ptr->typeAndName()
          << ") <-> '" << _mesh.getBoundaryString(paired_bid) << "' (in "
          << paired_prbc_ptr->typeAndName() << ")\n";
    }
    oss << "\nThe periodic propagation of rays at points where two or more periodic"
        << "\nboundaries meet is not fully supported with a distributed mesh."
        << "\n\nIf you encounter trace failures, you should use a replicated mesh.";
    mooseWarning(oss.str());
  }
}

Referenced by RayTracingStudy::initialSetup().

postExecuteStudy()

virtual void RayTracingStudy::postExecuteStudy ( )

inlineprotectedvirtualinherited

Entry point after study execution.

Reimplemented in ViewFactorRayStudy, RayTracingStudyTest, TestPICRayStudy, TestReuseRaysStudy, TestTransientRaysStudy, and TestRayLots.

Definition at line 709 of file RayTracingStudy.h.

{}

Referenced by RayTracingStudy::executeStudy().

postOnSegment()

void RayTracingStudy::postOnSegment ( const THREAD_ID  tid, const std::shared_ptr< Ray > &  ray  )

virtualinherited

Called at the end of a Ray segment.

Parameters

tid	Thread id
ray	The ray

Definition at line 849 of file RayTracingStudy.C.

{
  mooseAssert(currentlyPropagating(), "Should not call while not propagating");
  if (!_fe_problem.currentlyComputingJacobian() && !_fe_problem.currentlyComputingResidual())
    mooseAssert(_num_cached[tid] == 0,
                "Values should only be cached when computing Jacobian/residual");
 
  // Fill into cached Jacobian/residuals if necessary
  if (_fe_problem.currentlyComputingJacobian())
  {
    _fe_problem.cacheJacobian(tid);
 
    if (++_num_cached[tid] == 20)
    {
      Threads::spin_mutex::scoped_lock lock(_spin_mutex);
      _fe_problem.addCachedJacobian(tid);
      _num_cached[tid] = 0;
    }
  }
  else if (_fe_problem.currentlyComputingResidual())
  {
    _fe_problem.cacheResidual(tid);
 
    if (++_num_cached[tid] == 20)
    {
      Threads::spin_mutex::scoped_lock lock(_spin_mutex);
      _fe_problem.addCachedResidual(tid);
      _num_cached[tid] = 0;
    }
  }
}

Referenced by TraceRay::trace().

preExecuteStudy()

virtual void RayTracingStudy::preExecuteStudy ( )

inlineprotectedvirtualinherited

Entry point before study execution.

Reimplemented in ViewFactorRayStudy.

Definition at line 705 of file RayTracingStudy.h.

{}

Referenced by RayTracingStudy::executeStudy().

preTrace()

virtual void RayTracingStudy::preTrace ( const THREAD_ID  , const std::shared_ptr< Ray > &    )

inlinevirtualinherited

Called at the beginning of a trace for a ray.

Parameters

tid	Thread id
ray	The ray

Definition at line 120 of file RayTracingStudy.h.

{}

Referenced by TraceRay::trace().

propagationTime()

Real RayTracingStudy::propagationTime ( ) const

inlineinherited

Duration for creation of all Rays in seconds.

Definition at line 204 of file RayTracingStudy.h.

{ return std::chrono::duration<Real>(_propagation_time).count(); }

Referenced by PerProcessorRayTracingResultsVectorPostprocessor::execute().

rayAuxDataNames()

const std::vector< std::string > & RayTracingStudy::rayAuxDataNames ( ) const

inlineinherited

The Ray aux data names.

Definition at line 340 of file RayTracingStudy.h.

{ return _ray_aux_data_names; }

Referenced by RayTracingMeshOutput::setupEquationSystem().

rayAuxDataSize()

std::size_t RayTracingStudy::rayAuxDataSize ( ) const

inlineinherited

The registered size of values in the Ray aux data.

Definition at line 332 of file RayTracingStudy.h.

{ return _ray_aux_data_names.size(); }

Referenced by RayTracingStudy::acquireRay(), RayTracingStudy::acquireRayDuringTrace(), RayTracingStudy::acquireRegisteredRay(), RayTracingStudy::acquireReplicatedRay(), Ray::auxData(), Ray::auxData(), Ray::auxData(), Ray::auxData(), and RayTracingStudy::getRayDataNameInternal().

rayBank()

const std::vector< std::shared_ptr< Ray > > & RayTracingStudy::rayBank ( ) const

protectedinherited

Get the Ray bank.

This is the bank of Rays that have completed on this processor after an execution of the study.

This is only available when the private parameter _bank_rays_on_completion is set to true.

Definition at line 1376 of file RayTracingStudy.C.

{
  if (!_bank_rays_on_completion)
    mooseError("The Ray bank is not available because the private parameter "
               "'_bank_rays_on_completion' is set to false.");
  if (currentlyGenerating() || currentlyPropagating())
    mooseError("Cannot get the Ray bank during generation or propagation.");
 
  return _ray_bank;
}

Referenced by RayTracingStudyTest::generateRays(), RayTracingStudy::getBankedRay(), RayTracingStudyTest::postExecuteStudy(), TestPICRayStudy::postExecuteStudy(), TestReuseRaysStudy::postExecuteStudy(), TestTransientRaysStudy::postExecuteStudy(), TestRayLots::postExecuteStudy(), and RayTracingStudyNoBankingTest::RayTracingStudyNoBankingTest().

rayDataNames()

const std::vector< std::string > & RayTracingStudy::rayDataNames ( ) const

inlineinherited

The Ray data names.

Definition at line 280 of file RayTracingStudy.h.

{ return _ray_data_names; }

Referenced by RayTracingExodus::outputMesh(), RayTracingNemesis::outputMesh(), and RayTracingMeshOutput::setupEquationSystem().

rayDataSize()

std::size_t RayTracingStudy::rayDataSize ( ) const

inlineinherited

The registered size of values in the Ray data.

Definition at line 272 of file RayTracingStudy.h.

{ return _ray_data_names.size(); }

Referenced by RayTracingStudy::acquireRay(), RayTracingStudy::acquireRayDuringTrace(), RayTracingStudy::acquireRegisteredRay(), RayTracingStudy::acquireReplicatedRay(), Ray::data(), Ray::data(), Ray::data(), Ray::data(), and RayTracingStudy::getRayDataNameInternal().

rayDependentSubdomainSetup()

bool RayTracingStudy::rayDependentSubdomainSetup ( ) const

inlineinherited

Whether or not to use Ray dependent subdomain setup.

Definition at line 219 of file RayTracingStudy.h.

{ return _ray_dependent_subdomain_setup; }

Referenced by TraceRay::trace().

rayMaxDistance()

Real RayTracingStudy::rayMaxDistance ( ) const

inlineinherited

Max distance any Ray can travel.

Definition at line 184 of file RayTracingStudy.h.

{ return _ray_max_distance; }

Referenced by TraceRay::trace().

registeredRayID()

RayID RayTracingStudy::registeredRayID ( const std::string &  name, const bool  graceful = false  ) const

inherited

Gets the ID of a registered ray.

Parameters

name	The name of said ray
graceful	Whether or not to exit gracefully if none is found (with invalid_id)

Definition at line 1462 of file RayTracingStudy.C.

{
  Threads::spin_mutex::scoped_lock lock(_spin_mutex);
 
  if (!_use_ray_registration)
    mooseError("Should not use registeredRayID() with Ray registration disabled");
 
  const auto search = _registered_ray_map.find(name);
  if (search != _registered_ray_map.end())
    return search->second;
 
  if (graceful)
    return Ray::INVALID_RAY_ID;
 
  mooseError("Attempted to obtain ID of registered Ray ",
             name,
             ", but a Ray with said name is not registered.");
}

Referenced by RayDataValue::getValue(), RayIntegralValue::initialize(), RayTracingStudyTest::RayTracingStudyTest(), RayTracingStudyWithRegistrationTest::RayTracingStudyWithRegistrationTest(), and RayTracingStudy::registeredRaySetup().

registeredRayName()

const std::string & RayTracingStudy::registeredRayName ( const RayID  ray_id ) const

inherited

Gets the name of a registered ray.

Parameters

ray_id

The ID of said ray

Definition at line 1482 of file RayTracingStudy.C.

{
  Threads::spin_mutex::scoped_lock lock(_spin_mutex);
 
  if (!_use_ray_registration)
    mooseError("Should not use registeredRayName() with Ray registration disabled");
 
  if (_reverse_registered_ray_map.size() > ray_id)
    return _reverse_registered_ray_map[ray_id];
 
  mooseError("Attempted to obtain name of registered Ray with ID ",
             ray_id,
             ", but a Ray with said ID is not registered.");
}

Referenced by Ray::getInfo(), RayTracingStudyTest::RayTracingStudyTest(), and RayTracingStudyWithRegistrationTest::RayTracingStudyWithRegistrationTest().

registeredRaySetup()

void RayTracingStudy::registeredRaySetup ( )

privateinherited

Sets up the maps from Ray to associated RayTracingObjects if _use_ray_registration.

If ray registration is disabled, this makes sure no RayTracingObjects provided rays.

Definition at line 678 of file RayTracingStudy.C.

{
  // First, clear the objects associated with each Ray on each thread
  const auto num_rays = _registered_ray_map.size();
  for (auto & entry : _threaded_ray_object_registration)
  {
    entry.clear();
    entry.resize(num_rays);
  }
 
  const auto rtos = getRayTracingObjects();
 
  if (_use_ray_registration)
  {
    // All of the registered ray names - used when a RayTracingObject did not specify
    // any Rays so it should be associated with all Rays.
    std::vector<std::string> all_ray_names;
    all_ray_names.reserve(_registered_ray_map.size());
    for (const auto & pair : _registered_ray_map)
      all_ray_names.push_back(pair.first);
 
    for (auto & rto : rtos)
    {
      // The Ray names associated with this RayTracingObject
      const auto & ray_names = rto->parameters().get<std::vector<std::string>>("rays");
      // The registration for RayTracingObjects for the thread rto is on
      const auto tid = rto->parameters().get<THREAD_ID>("_tid");
      auto & registration = _threaded_ray_object_registration[tid];
 
      // Register each Ray for this object in the registration
      for (const auto & ray_name : (ray_names.empty() ? all_ray_names : ray_names))
      {
        const auto id = registeredRayID(ray_name, /* graceful = */ true);
        if (ray_names.size() && id == Ray::INVALID_RAY_ID)
          rto->paramError(
              "rays", "Supplied ray '", ray_name, "' is not a registered Ray in ", typeAndName());
        registration[id].insert(rto);
      }
    }
  }
  // Not using Ray registration
  else
  {
    for (const auto & rto : rtos)
      if (rto->parameters().get<std::vector<std::string>>("rays").size())
        rto->paramError(
            "rays",
            "Rays cannot be supplied when the study does not require Ray registration.\n\n",
            type(),
            " does not require Ray registration.");
  }
}

Referenced by RayTracingStudy::executeStudy().

registerRay()

RayID RayTracingStudy::registerRay ( const std::string &  name )

privateinherited

Registers a Ray with a given name.

This is for internal use only and is an internal map for replicated Ray IDs -> names for easy access for studies that have a small number of rays to generate.

Parameters

name	The name to register

Returns

The allocated ID for the registered ray

Definition at line 1438 of file RayTracingStudy.C.

{
  libmesh_parallel_only(comm());
 
  Threads::spin_mutex::scoped_lock lock(_spin_mutex);
 
  if (!_use_ray_registration)
    mooseError("Cannot use registerRay() with Ray registration disabled");
 
  // This is parallel only for now. We could likely stagger the ID building like we do with
  // the unique IDs, but it would require a sync point which isn't there right now
  libmesh_parallel_only(comm());
 
  const auto & it = _registered_ray_map.find(name);
  if (it != _registered_ray_map.end())
    return it->second;
 
  const auto id = _reverse_registered_ray_map.size();
  _registered_ray_map.emplace(name, id);
  _reverse_registered_ray_map.push_back(name);
  return id;
}

Referenced by RayTracingStudy::acquireRegisteredRay().

registerRayAuxData() [1/2]

RayDataIndex RayTracingStudy::registerRayAuxData ( const std::string &  name )

inherited

Register a value to be filled in the aux data on a Ray with a given name.

Parameters

name	The name to register

Returns

The Ray aux data index for the registered value

Note that this does not actually allocate the storage. It is simply a registration system to keep track of the values stored in the Ray aux data.

Definition at line 1209 of file RayTracingStudy.C.

{
  return registerRayDataInternal(name, /* aux = */ true);
}

Referenced by RayTracingStudyTest::RayTracingStudyTest(), StationaryRayStudyTest::StationaryRayStudyTest(), TestRayDataStudy::TestRayDataStudy(), and TestRayLots::TestRayLots().

registerRayAuxData() [2/2]

std::vector< RayDataIndex > RayTracingStudy::registerRayAuxData ( const std::vector< std::string > &  names )

inherited

Register values to be filled in the aux data on a Ray with a given name.

Parameters

names

The names to register

Returns

The Ray aux data indices for the registered values

Note that this does not actually allocate the storage. It is simply a registration system to keep track of the values stored in the Ray aux data.

Definition at line 1215 of file RayTracingStudy.C.

{
  return registerRayDataInternal(names, /* aux = */ true);
}

registerRayData() [1/2]

RayDataIndex RayTracingStudy::registerRayData ( const std::string &  name )

inherited

Register a value to be filled in the data on a Ray with a given name.

Parameters

name	The name to register

Returns

The Ray data index for the registered value

Note that this does not actually allocate the storage. It is simply a registration system to keep track of the values stored in the Ray data.

Definition at line 1178 of file RayTracingStudy.C.

{
  return registerRayDataInternal(name, /* aux = */ false);
}

Referenced by RayTracingStudyTest::generateRays(), RayTracingStudyTest::RayTracingStudyTest(), StationaryRayStudyTest::StationaryRayStudyTest(), TestRayDataStudy::TestRayDataStudy(), and TestRayLots::TestRayLots().

registerRayData() [2/2]

std::vector< RayDataIndex > RayTracingStudy::registerRayData ( const std::vector< std::string > &  names )

inherited

Register values to be filled in the data on a Ray with a given name.

Parameters

names

The names to register

Returns

The Ray data indices for the registered value

Note that this does not actually allocate the storage. It is simply a registration system to keep track of the values stored in the Ray data.

Definition at line 1184 of file RayTracingStudy.C.

{
  return registerRayDataInternal(names, /* aux = */ false);
}

registerRayDataInternal() [1/2]

RayDataIndex RayTracingStudy::registerRayDataInternal ( const std::string &  name, const bool  aux  )

privateinherited

Internal method for registering Ray data or Ray aux data with a name.

Definition at line 1086 of file RayTracingStudy.C.

{
  Threads::spin_mutex::scoped_lock lock(_spin_mutex);
 
  if (_called_initial_setup)
    mooseError("Cannot register Ray ", (aux ? "aux " : ""), "data after initialSetup()");
 
  auto & map = aux ? _ray_aux_data_map : _ray_data_map;
  const auto find = map.find(name);
  if (find != map.end())
    return find->second;
 
  auto & other_map = aux ? _ray_data_map : _ray_aux_data_map;
  if (other_map.find(name) != other_map.end())
    mooseError("Cannot register Ray aux data with name ",
               name,
               " because Ray ",
               (aux ? "(non-aux)" : "aux"),
               " data already exists with said name.");
 
  // Add into the name -> index map
  map.emplace(name, map.size());
 
  // Add into the index -> names vector
  auto & vector = aux ? _ray_aux_data_names : _ray_data_names;
  vector.push_back(name);
 
  return map.size() - 1;
}

Referenced by RayTracingStudy::registerRayAuxData(), RayTracingStudy::registerRayAuxData(), RayTracingStudy::registerRayData(), RayTracingStudy::registerRayData(), and RayTracingStudy::registerRayDataInternal().

registerRayDataInternal() [2/2]

std::vector< RayDataIndex > RayTracingStudy::registerRayDataInternal ( const std::vector< std::string > &  names, const bool  aux  )

privateinherited

Internal method for registering Ray data or Ray aux data with names.

Definition at line 1117 of file RayTracingStudy.C.

{
  std::vector<RayDataIndex> indices(names.size());
  for (std::size_t i = 0; i < names.size(); ++i)
    indices[i] = registerRayDataInternal(names[i], aux);
  return indices;
}

reinitSegment()

void RayTracingStudy::reinitSegment ( const Elem *  elem, const Point &  start, const Point &  end, const Real  length, THREAD_ID  tid  )

virtualinherited

Reinitialize objects for a Ray segment for ray tracing.

Parameters

elem	The elem the segment is in
start	Start point of the segment
end	End point of the segment
length	The length of the start -> end segment
tid	Thread id

Definition at line 785 of file RayTracingStudy.C.

{
  mooseAssert(MooseUtils::absoluteFuzzyEqual((start - end).norm(), length), "Invalid length");
  mooseAssert(currentlyPropagating(), "Should not call while not propagating");
 
  _fe_problem.setCurrentSubdomainID(elem, tid);
 
  // If we have any variables or material properties that are active, we definitely need to reinit
  bool reinit = _fe_problem.hasActiveElementalMooseVariables(tid) ||
                _fe_problem.hasActiveMaterialProperties(tid);
  // If not, make sure that the RayKernels have not requested a reinit (this could happen when a
  // RayKernel doesn't have variables or materials but still does an integration and needs qps)
  if (!reinit)
    for (const RayKernelBase * rk : currentRayKernels(tid))
      if (rk->needSegmentReinit())
      {
        reinit = true;
        break;
      }
 
  if (reinit)
  {
    _fe_problem.prepare(elem, tid);
 
    std::vector<Point> points;
    std::vector<Real> weights;
    buildSegmentQuadrature(start, end, length, points, weights);
    _fe_problem.reinitElemPhys(elem, points, tid);
    _fe_problem.assembly(tid, _sys.number()).modifyArbitraryWeights(weights);
 
    _fe_problem.reinitMaterials(elem->subdomain_id(), tid);
  }
}

Referenced by TraceRay::onSegment().

reserveRayBuffer()

void RayTracingStudy::reserveRayBuffer ( const std::size_t  size )

protectedinherited

Reserve size entires in the Ray buffer.

This can only be used within generateRays() and should be used when possible to reserve entires in the buffer before adding Rays via moveRay(s)ToBuffer.

Definition at line 1652 of file RayTracingStudy.C.

{
  if (!currentlyGenerating())
    mooseError("Can only reserve in Ray buffer during generateRays()");
 
  _parallel_ray_study->reserveBuffer(size);
}

Referenced by ViewFactorRayStudy::generateRays(), RepeatableRayStudyBase::generateRays(), and RayTracingStudyTest::RayTracingStudyTest().

resetReplicatedRayIDs()

void RayTracingStudy::resetReplicatedRayIDs ( )

protectedinherited

Resets the generation of unique replicated RayIDs accessed via generateReplicatedRayID().

Definition at line 1748 of file RayTracingStudy.C.

{
  libmesh_parallel_only(comm());
 
  Threads::spin_mutex::scoped_lock lock(_spin_mutex);
 
  mooseAssert(!currentlyGenerating() && !currentlyPropagating(),
              "Cannot be reset during generation or propagation");
 
  _replicated_next_ray_id = 0;
}

Referenced by RayTracingStudy::RayTracingStudy().

resetUniqueRayIDs()

void RayTracingStudy::resetUniqueRayIDs ( )

protectedinherited

Resets the generation of unique RayIDs via generateUniqueRayID() to the beginning of the range.

Definition at line 1722 of file RayTracingStudy.C.

{
  libmesh_parallel_only(comm());
 
  Threads::spin_mutex::scoped_lock lock(_spin_mutex);
 
  mooseAssert(!currentlyGenerating() && !currentlyPropagating(),
              "Cannot be reset during generation or propagation");
 
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
    _threaded_next_ray_id[tid] = (RayID)_pid * (RayID)libMesh::n_threads() + (RayID)tid;
}

Referenced by RayTracingStudy::RayTracingStudy().

residualSetup()

void RayTracingStudy::residualSetup ( )

overridevirtualinherited

Reimplemented from GeneralUserObject.

Definition at line 279 of file RayTracingStudy.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
    mooseAssert(_num_cached[tid] == 0, "Cached residuals/Jacobians not empty");
 
  for (auto & rto : getRayTracingObjects())
    rto->residualSetup();
}

sameLevelActiveElems()

bool RayTracingStudy::sameLevelActiveElems ( ) const

protectedinherited

Determine whether or not the mesh currently has active elements that are all the same level.

Definition at line 1684 of file RayTracingStudy.C.

{
  unsigned int min_level = std::numeric_limits<unsigned int>::max();
  unsigned int max_level = std::numeric_limits<unsigned int>::min();
 
  for (const auto & elem : *_mesh.getActiveLocalElementRange())
  {
    const auto level = elem->level();
    min_level = std::min(level, min_level);
    max_level = std::max(level, max_level);
  }
 
  _communicator.min(min_level);
  _communicator.max(max_level);
 
  return min_level == max_level;
}

Referenced by RayTracingStudy::meshChanged().

segmentsOnCacheTraces()

bool RayTracingStudy::segmentsOnCacheTraces ( ) const

inlineinherited

Whether or not to cache individual element segments when _cache_traces = true.

Definition at line 577 of file RayTracingStudy.h.

{ return _segments_on_cache_traces; }

Referenced by RayTracingMeshOutput::buildSegmentMesh(), RayTracingMeshOutput::neededNodes(), TraceRay::onContinueTrace(), TraceRay::onTrajectoryChanged(), RayTracingMeshOutput::RayTracingMeshOutput(), and RayTracingMeshOutput::startingIDs().

segmentSubdomainSetup()

void RayTracingStudy::segmentSubdomainSetup ( const SubdomainID  subdomain, const THREAD_ID  tid, const RayID  ray_id  )

virtualinherited

Setup for on subdomain change or subdomain AND ray change during ray tracing.

Parameters

subdomain	The subdomain changed to
tid	Thread id
ray_id	ID of the ray initiating the change

Definition at line 750 of file RayTracingStudy.C.

{
  mooseAssert(currentlyPropagating(), "Should not call while not propagating");
 
  // Call subdomain setup on FE
  _fe_problem.subdomainSetup(subdomain, tid);
 
  std::set<MooseVariableFEBase *> needed_moose_vars;
  std::unordered_set<unsigned int> needed_mat_props;
 
  // Get RayKernels and their dependencies and call subdomain setup
  getRayKernels(_threaded_current_ray_kernels[tid], subdomain, tid, ray_id);
  for (auto & rkb : _threaded_current_ray_kernels[tid])
  {
    rkb->subdomainSetup();
 
    const auto & mv_deps = rkb->getMooseVariableDependencies();
    needed_moose_vars.insert(mv_deps.begin(), mv_deps.end());
 
    const auto & mp_deps = rkb->getMatPropDependencies();
    needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
  }
 
  // Prepare aux vars
  for (auto & var : needed_moose_vars)
    if (var->kind() == Moose::VarKindType::VAR_AUXILIARY)
      var->prepareAux();
 
  _fe_problem.setActiveElementalMooseVariables(needed_moose_vars, tid);
  _fe_problem.prepareMaterials(needed_mat_props, subdomain, tid);
}

Referenced by TraceRay::onSubdomainChanged().

shouldCacheTrace()

virtual bool RayTracingStudy::shouldCacheTrace ( const std::shared_ptr< Ray > &  ) const

inlinevirtualinherited

Virtual that allows for selection in if a Ray should be cached or not (only used when _cache_traces).

Definition at line 583 of file RayTracingStudy.h.

  {
    return _always_cache_traces;
  }

Referenced by RayTracingStudy::initThreadedCachedTrace(), and TraceRay::trace().

sideIsIncoming()

bool RayTracingStudy::sideIsIncoming ( const Elem *const  elem, const unsigned short  side, const Point &  direction, const THREAD_ID  tid  )

inherited

Whether or not side is incoming on element elem in direction direction.

Definition at line 1767 of file RayTracingStudy.C.

{
  const auto & normal = getSideNormal(elem, side, tid);
  const auto dot = normal * direction;
  return dot < TraceRayTools::TRACE_TOLERANCE;
}

Referenced by TraceRay::exitsElem(), TraceRay::findExternalBoundarySide(), TraceRay::onSegment(), ClaimRays::postClaimRay(), and TraceRay::trace().

sideIsNonPlanar()

bool RayTracingStudy::sideIsNonPlanar ( const Elem *  elem, const unsigned short  s  ) const

inlineinherited

Whether or not the side \s on elem elem is non-planar.

This is cached because checking whether or not a face is planar is costly

Definition at line 465 of file RayTracingStudy.h.

  {
    return _has_non_planar_sides && _non_planar_sides[_elem_index_helper.getIndex(elem)][s] == 1;
  }

Referenced by TraceRay::exitsElem(), TraceRay::exitsElem(), ViewFactorRayStudy::generateRays(), ReflectRayBC::onBoundary(), TraceRay::onSegment(), TraceRay::possiblyAddToBoundaryElems(), Ray::setStart(), and TraceRay::trace().

subdomainHmax()

Real RayTracingStudy::subdomainHmax ( const SubdomainID  subdomain_id ) const

inherited

Get the cached hmax for all elements in a subdomain.

Used for scaling tolerances in ray tracing.

Definition at line 1703 of file RayTracingStudy.C.

{
  const auto find = _subdomain_hmax.find(subdomain_id);
  if (find == _subdomain_hmax.end())
    mooseError("Subdomain ", subdomain_id, " not found in subdomain hmax map");
  return find->second;
}

Referenced by RayTracingStudyTest::generateRays(), TraceRay::onSubdomainChanged(), TraceRay::subdomainHmax(), and RayTracingStudy::subdomainHMaxSetup().

subdomainHMaxSetup()

void RayTracingStudy::subdomainHMaxSetup ( )

privateinherited

Caches the hmax for all elements in each subdomain.

Definition at line 624 of file RayTracingStudy.C.

{
  // Setup map with subdomain keys
  _subdomain_hmax.clear();
  for (const auto subdomain_id : _mesh.meshSubdomains())
    _subdomain_hmax[subdomain_id] = std::numeric_limits<Real>::min();
 
  // Set local max for each subdomain
  for (const auto & elem : *_mesh.getActiveLocalElementRange())
  {
    auto & entry = _subdomain_hmax.at(elem->subdomain_id());
    entry = std::max(entry, elem->hmax());
  }
 
  // Accumulate global max for each subdomain
  _communicator.max(_subdomain_hmax);
 
  if (getParam<bool>("warn_subdomain_hmax"))
  {
    const auto warn_prefix = type() + " '" + name() + "': ";
    const auto warn_suffix =
        "\n\nRay tracing uses an approximate element size for each subdomain to scale the\n"
        "tolerances used in computing ray intersections. This warning suggests that the\n"
        "approximate element size is not a good approximation. This is likely due to poor\n"
        "element aspect ratios.\n\n"
        "This warning is only output for the first element affected.\n"
        "To disable this warning, set warn_subdomain_hmax = false.\n";
 
    for (const auto & elem : *_mesh.getActiveLocalElementRange())
    {
      const auto hmin = elem->hmin();
      const auto hmax = elem->hmax();
      const auto max_hmax = subdomainHmax(elem->subdomain_id());
 
      const auto hmax_rel = hmax / max_hmax;
      if (hmax_rel < 1.e-2 || hmax_rel > 1.e2)
        mooseDoOnce(mooseWarning(warn_prefix,
                                 "Element hmax varies significantly from subdomain hmax.\n",
                                 warn_suffix,
                                 "First element affected:\n",
                                 Moose::stringify(*elem)););
 
      const auto h_rel = max_hmax / hmin;
      if (h_rel > 1.e2)
        mooseDoOnce(mooseWarning(warn_prefix,
                                 "Element hmin varies significantly from subdomain hmax.\n",
                                 warn_suffix,
                                 "First element affected:\n",
                                 Moose::stringify(*elem)););
    }
  }
}

Referenced by RayTracingStudy::initialSetup(), and RayTracingStudy::meshChanged().

timestepSetup()

void RayTracingStudy::timestepSetup ( )

overridevirtualinherited

Reimplemented from GeneralUserObject.

Definition at line 299 of file RayTracingStudy.C.

{
  for (auto & rto : getRayTracingObjects())
    rto->timestepSetup();
}

tolerateFailure()

bool RayTracingStudy::tolerateFailure ( ) const

inlineinherited

Whether or not to tolerate failure.

Definition at line 209 of file RayTracingStudy.h.

{ return _tolerate_failure; }

Referenced by TraceRay::exitsElem(), TraceRay::onBoundary(), and TraceRay::trace().

totalDistance()

Real RayTracingStudy::totalDistance ( ) const

inlineinherited

Total distance traveled by all Rays.

Definition at line 172 of file RayTracingStudy.h.

{ return _total_distance; }

Referenced by RayTracingStudyResult::getValue().

totalIntersections()

unsigned long long int RayTracingStudy::totalIntersections ( ) const

inlineinherited

Total number of Ray/element intersections.

Definition at line 155 of file RayTracingStudy.h.

{ return _total_intersections; }

totalProcessorCrossings()

unsigned long long int RayTracingStudy::totalProcessorCrossings ( ) const

inlineinherited

Total number of processor crossings.

Definition at line 138 of file RayTracingStudy.h.

{ return _total_processor_crossings; }

Referenced by RayTracingStudyResult::getValue().

totalVolume()

Real RayTracingStudy::totalVolume ( ) const

inlineinherited

Get the current total volume of the domain.

Definition at line 437 of file RayTracingStudy.h.

{ return _total_volume; }

Referenced by RayTracingStudy::isRectangularDomain().

traceableMeshChecks()

void RayTracingStudy::traceableMeshChecks ( )

privateinherited

Check for if all of the element types in the mesh are supported by ray tracing.

Definition at line 389 of file RayTracingStudy.C.

{
  for (const auto & elem : *_mesh.getActiveLocalElementRange())
  {
    if (_fe_problem.adaptivity().isOn())
    {
      if (!TraceRayTools::isAdaptivityTraceableElem(elem))
        mooseError("Element type ",
                   Utility::enum_to_string(elem->type()),
                   " is not supported in ray tracing with adaptivity");
    }
    else if (!TraceRayTools::isTraceableElem(elem))
      mooseError("Element type ",
                 Utility::enum_to_string(elem->type()),
                 " is not supported in ray tracing");
  }
}

Referenced by RayTracingStudy::initialSetup().

traceRay() [1/2]

TraceRay & RayTracingStudy::traceRay ( const THREAD_ID  tid )

inlineinherited

Gets the threaded TraceRay object for tid.

Definition at line 647 of file RayTracingStudy.h.

{ return *_threaded_trace_ray[tid]; }

Referenced by BackfaceCullingStudyTest::BackfaceCullingStudyTest().

traceRay() [2/2]

const TraceRay & RayTracingStudy::traceRay ( const THREAD_ID  tid ) const

inlineinherited

Definition at line 648 of file RayTracingStudy.h.

{ return *_threaded_trace_ray[tid]; }

useRayRegistration()

bool RayTracingStudy::useRayRegistration ( ) const

inlineinherited

Whether or not ray registration is being used.

Definition at line 564 of file RayTracingStudy.h.

{ return _use_ray_registration; }

Referenced by Ray::getInfo(), RayIntegralValue::initialize(), and RayDataValue::RayDataValue().

validParams()

InputParameters RepeatableRayStudyDefineNoClaimTest::validParams ( )

static

Definition at line 43 of file RepeatableRayStudyBaseTest.C.

{
  auto params = RepeatableRayStudy::validParams();
  params.set<bool>("_claim_after_define_rays") = false;
  return params;
}

verifyDependenciesExist()

void RayTracingStudy::verifyDependenciesExist ( const std::vector< RayTracingObject * > &  rtos )

privateinherited

Verifies that the dependencies exist for a set of RayTracingObjects.

Definition at line 370 of file RayTracingStudy.C.

{
  for (const auto & rto : rtos)
    for (const auto & dep_name : rto->getRequestedItems())
    {
      bool found = false;
      for (const auto & rto_search : rtos)
        if (rto_search->name() == dep_name)
        {
          found = true;
          break;
        }
 
      if (!found)
        rto->paramError("depends_on", "The ", rto->getBase(), " '", dep_name, "' does not exist");
    }
}

Referenced by RayTracingStudy::dependencyChecks().

verifyRays()

bool RayTracingStudy::verifyRays ( ) const

inlineinherited

Whether or not to verify if Rays have valid information before being traced.

Definition at line 654 of file RayTracingStudy.h.

{ return _verify_rays; }

Referenced by RayKernelBase::changeRayStartDirection(), ClaimRays::claim(), RepeatableRayStudyBase::defineRaysInternal(), RayTracingStudy::executeStudy(), TraceRay::exitsElem(), Ray::setStart(), Ray::setStartingEndPoint(), and TraceRay::trace().

verifyReplicatedRays()

void RepeatableRayStudyBase::verifyReplicatedRays ( )

privateinherited

Verifies that the Rays in _rays are replicated across processors.

In optimized mode, this compares the sizes across all processors. In non-optimized modes, this communicates the Rays from all processors to the root and compares the Rays.

Definition at line 199 of file RepeatableRayStudyBase.C.

{
  TIME_SECTION("verifyReplicatedRays", 2, "Verifying Replicated Rays");
 
  const std::string error_suffix =
      "\n\nThe Rays added in defineRays() must be replicated across all processors\nwith the "
      "private param '_define_rays_replicated' == true.";
 
  // First, verify that our _rays have unique IDs beacuse we will do mapping based on Ray ID
  verifyUniqueRayIDs(_rays.begin(),
                     _rays.end(),
                     /* global = */ false,
                     "in _rays after calling defineRays()." + error_suffix);
 
  // Tag for sending rays from rank 0 -> all other ranks
  const auto tag = comm().get_unique_tag();
 
  // Send a copy of the rays on rank 0 to all other processors for verification
  if (_pid == 0)
  {
    std::vector<Parallel::Request> requests(n_processors() - 1);
    auto request_it = requests.begin();
 
    for (processor_id_type pid = 0; pid < n_processors(); ++pid)
      if (pid != 0)
        comm().send_packed_range(
            pid, parallelStudy(), _rays.begin(), _rays.end(), *request_it++, tag);
 
    Parallel::wait(requests);
  }
  // All other processors will receive and verify that their rays match the rays on rank 0
  else
  {
    // Map of RayID -> Ray for comparison from the Rays on rank 0 to the local rays
    std::unordered_map<RayID, const Ray *> ray_map;
    ray_map.reserve(_rays.size());
    for (const auto & ray : _rays)
      ray_map.emplace(ray->id(), ray.get());
 
    // Receive the duplicated rays from rank 0
    std::vector<std::shared_ptr<Ray>> rank_0_rays;
    rank_0_rays.reserve(_rays.size());
    comm().receive_packed_range(
        0, parallelStudy(), std::back_inserter(rank_0_rays), (std::shared_ptr<Ray> *)nullptr, tag);
 
    // The sizes better match
    if (rank_0_rays.size() != _rays.size())
      mooseError("The size of _rays on rank ",
                 _pid,
                 " does not match the size of rays on rank 0.",
                 error_suffix);
 
    // Make sure we have a matching local ray for each ray from rank 0
    for (const auto & ray : rank_0_rays)
    {
      const auto find = ray_map.find(ray->id());
      if (find == ray_map.end())
        mooseError("A Ray was found on rank ",
                   _pid,
                   " with an ID that does not exist on rank 0.",
                   error_suffix,
                   "\n\n",
                   ray->getInfo());
 
      const Ray * root_ray = find->second;
      if (*root_ray != *ray)
      {
        mooseError("A Ray was found on rank ",
                   _pid,
                   " that does not exist on rank 0.",
                   error_suffix,
                   "\n\nLocal ray:\n\n",
                   ray->getInfo(),
                   "\n\nRank 0 ray:\n\n",
                   root_ray->getInfo());
      }
    }
  }
}

Referenced by RepeatableRayStudyBase::defineRaysInternal().

verifyTraceIntersections()

bool RayTracingStudy::verifyTraceIntersections ( ) const

inlineinherited

Whether or not trace verification is enabled in devel/dbg modes.

Definition at line 659 of file RayTracingStudy.h.

{ return _verify_trace_intersections; }

Referenced by TraceRay::exitsElem(), TraceRay::onSegment(), TraceRay::onTrajectoryChanged(), and TraceRay::trace().

verifyUniqueRayIDs()

void RayTracingStudy::verifyUniqueRayIDs ( const std::vector< std::shared_ptr< Ray > >::const_iterator  begin, const std::vector< std::shared_ptr< Ray > >::const_iterator  end, const bool  global, const std::string &  error_suffix  ) const

inherited

Verifies that the Rays in the given range have unique Ray IDs.

Parameters

begin	The beginning of the range of Rays to check
end	The end of the range of Rays to check
global	If true, this will complete the verification across all processors
error_suffix	Entry point for additional information in the error message

Definition at line 1530 of file RayTracingStudy.C.

{
  // Determine the unique set of Ray IDs on this processor,
  // and if not locally unique throw an error. Once we build this set,
  // we will send it to rank 0 to verify globally
  std::set<RayID> local_rays;
  for (const std::shared_ptr<Ray> & ray : as_range(begin, end))
  {
    mooseAssert(ray, "Null ray");
 
    // Try to insert into the set; the second entry in the pair
    // will be false if it was not inserted
    if (!local_rays.insert(ray->id()).second)
    {
      for (const std::shared_ptr<Ray> & other_ray : as_range(begin, end))
        if (ray.get() != other_ray.get() && ray->id() == other_ray->id())
          mooseError("Multiple Rays exist with ID ",
                     ray->id(),
                     " on processor ",
                     _pid,
                     " ",
                     error_suffix,
                     "\n\nOffending Ray information:\n\n",
                     ray->getInfo(),
                     "\n",
                     other_ray->getInfo());
    }
  }
 
  // Send IDs from all procs to rank 0 and verify on rank 0
  if (global)
  {
    // Package our local IDs and send to rank 0
    std::map<processor_id_type, std::vector<RayID>> send_ids;
    if (local_rays.size())
      send_ids.emplace(std::piecewise_construct,
                       std::forward_as_tuple(0),
                       std::forward_as_tuple(local_rays.begin(), local_rays.end()));
    local_rays.clear();
 
    // Mapping on rank 0 from ID -> processor ID
    std::map<RayID, processor_id_type> global_map;
 
    // Verify another processor's IDs against the global map on rank 0
    const auto check_ids =
        [this, &global_map, &error_suffix](processor_id_type pid, const std::vector<RayID> & ids)
    {
      for (const RayID id : ids)
      {
        const auto emplace_pair = global_map.emplace(id, pid);
 
        // Means that this ID already exists in the map
        if (!emplace_pair.second)
          mooseError("Ray with ID ",
                     id,
                     " exists on ranks ",
                     emplace_pair.first->second,
                     " and ",
                     pid,
                     "\n",
                     error_suffix);
      }
    };
 
    Parallel::push_parallel_vector_data(_communicator, send_ids, check_ids);
  }
}

Referenced by RayTracingStudy::executeStudy(), and RepeatableRayStudyBase::verifyReplicatedRays().

verifyUniqueRays()

void RayTracingStudy::verifyUniqueRays ( const std::vector< std::shared_ptr< Ray > >::const_iterator  begin, const std::vector< std::shared_ptr< Ray > >::const_iterator  end, const std::string &  error_suffix  )

inherited

Verifies that the Rays in the given range are unique.

That is, that there are not multiple shared_ptrs that point to the same Ray

Parameters

begin	The beginning of the range of Rays to check
end	The end of the range of Rays to check
error_suffix	Entry point for additional information in the error message

Definition at line 1602 of file RayTracingStudy.C.

{
  std::set<const Ray *> rays;
  for (const std::shared_ptr<Ray> & ray : as_range(begin, end))
    if (!rays.insert(ray.get()).second) // false if not inserted into rays
      mooseError("Multiple shared_ptrs were found that point to the same Ray ",
                 error_suffix,
                 "\n\nOffending Ray:\n",
                 ray->getInfo());
}

Referenced by RayTracingStudy::executeStudy().

warnNonPlanar()

bool RayTracingStudy::warnNonPlanar ( ) const

inlineinherited

Whether or not to produce a warning when interacting with a non-planar mesh.

Definition at line 673 of file RayTracingStudy.h.

{ return _warn_non_planar; }

zeroAuxVariables()

void RayTracingStudy::zeroAuxVariables ( )

privateinherited

Zero the AuxVariables that the registered AuxRayKernels contribute to.

Definition at line 732 of file RayTracingStudy.C.

{
  std::set<std::string> vars_to_be_zeroed;
  std::vector<RayKernelBase *> ray_kernels;
  getRayKernels(ray_kernels, 0);
  for (auto & rk : ray_kernels)
  {
    AuxRayKernel * aux_rk = dynamic_cast<AuxRayKernel *>(rk);
    if (aux_rk)
      vars_to_be_zeroed.insert(aux_rk->variable().name());
  }
 
  std::vector<std::string> vars_to_be_zeroed_vec(vars_to_be_zeroed.begin(),
                                                 vars_to_be_zeroed.end());
  _fe_problem.getAuxiliarySystem().zeroVariables(vars_to_be_zeroed_vec);
}

Referenced by RayTracingStudy::executeStudy().

Member Data Documentation

_always_cache_traces

bool RayTracingStudy::_always_cache_traces

protectedinherited

Whether or not to cache traces on every trace execution.

Definition at line 883 of file RayTracingStudy.h.

Referenced by RayTracingStudy::shouldCacheTrace().

_aux_data_on_cache_traces

const bool RayTracingStudy::_aux_data_on_cache_traces

protectedinherited

Whether or not to store the Ray aux data on the cache traces.

Definition at line 887 of file RayTracingStudy.h.

Referenced by RayTracingStudy::auxDataOnCacheTraces().

_b_box

libMesh::BoundingBox RayTracingStudy::_b_box

privateinherited

Nodal bounding box for the domain.

Definition at line 1067 of file RayTracingStudy.h.

Referenced by RayTracingStudy::boundingBox(), RayTracingStudy::isRectangularDomain(), and RayTracingStudy::RayTracingStudy().

_bank_rays_on_completion

const bool RayTracingStudy::_bank_rays_on_completion

protectedinherited

Whether or not to bank rays on completion.

Definition at line 878 of file RayTracingStudy.h.

Referenced by RayTracingStudy::bankRaysOnCompletion(), RayTracingStudy::onCompleteRay(), and RayTracingStudy::rayBank().

_cached_traces

std::vector<TraceData> RayTracingStudy::_cached_traces

privateinherited

Storage for the cached traces.

Definition at line 1047 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::getCachedTraces().

_called_initial_setup

bool RayTracingStudy::_called_initial_setup

privateinherited

Whether or not we've called initial setup - used to stop from late registration.

Definition at line 1139 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), RayTracingStudy::getRayBCs(), RayTracingStudy::getRayKernels(), RayTracingStudy::initialSetup(), and RayTracingStudy::registerRayDataInternal().

_claim_after_define_rays

const bool RepeatableRayStudyBase::_claim_after_define_rays

protectedinherited

Whether or not Rays need to be claimed after defineRays()

Definition at line 49 of file RepeatableRayStudyBase.h.

Referenced by RepeatableRayStudyBase::defineRaysInternal(), and RepeatableRayStudyBase::RepeatableRayStudyBase().

_claim_rays

ClaimRays RepeatableRayStudyBase::_claim_rays

privateinherited

The object used to claim Rays.

Definition at line 73 of file RepeatableRayStudyBase.h.

Referenced by RepeatableRayStudyBase::claimRaysInternal().

_comm

const Parallel::Communicator& RayTracingStudy::_comm

protectedinherited

The Communicator.

Definition at line 863 of file RayTracingStudy.h.

Referenced by LotsOfRaysRayStudy::defineRays().

_data_on_cache_traces

const bool RayTracingStudy::_data_on_cache_traces

protectedinherited

Whether or not to store the Ray data on the cache traces.

Definition at line 885 of file RayTracingStudy.h.

Referenced by RayTracingStudy::dataOnCacheTraces().

_define_rays_replicated

const bool RepeatableRayStudyBase::_define_rays_replicated

protectedinherited

Whether or not the Rays filled into _rays are replicated across all processors.

Definition at line 47 of file RepeatableRayStudyBase.h.

Referenced by RepeatableRayStudyBase::defineRaysInternal().

_directions

const std::vector<Point>* const RepeatableRayStudy::_directions

protectedinherited

The Ray directions (if defined)

Definition at line 36 of file RepeatableRayStudy.h.

Referenced by RepeatableRayStudy::defineRays(), and RepeatableRayStudy::RepeatableRayStudy().

_domain_max_length

Real RayTracingStudy::_domain_max_length

privateinherited

An inflated max distance for the domain.

Definition at line 1071 of file RayTracingStudy.h.

Referenced by RayTracingStudy::domainMaxLength().

_elem_index_helper

ElemIndexHelper RayTracingStudy::_elem_index_helper

privateinherited

Helper for defining a local contiguous index for each element.

Definition at line 1142 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getInternalSidesets(), RayTracingStudy::internalSidesetSetup(), RayTracingStudy::localElemIndexSetup(), RayTracingStudy::nonPlanarSideSetup(), and RayTracingStudy::sideIsNonPlanar().

_end_points

const std::vector<Point>* const RepeatableRayStudy::_end_points

protectedinherited

The Ray end points (if defined)

Definition at line 34 of file RepeatableRayStudy.h.

Referenced by RepeatableRayStudy::defineRays(), and RepeatableRayStudy::RepeatableRayStudy().

_ending_distance

Real RayTracingStudy::_ending_distance

privateinherited

Total distance traveled by Rays that end on this processor.

Definition at line 1128 of file RayTracingStudy.h.

Referenced by RayTracingStudy::endingDistance(), RayTracingStudy::executeStudy(), and RayTracingStudy::onCompleteRay().

_ending_intersections

unsigned long long int RayTracingStudy::_ending_intersections

privateinherited

Total number of Ray/element intersections for Rays that finished on this processor.

Definition at line 1115 of file RayTracingStudy.h.

Referenced by RayTracingStudy::endingIntersections(), RayTracingStudy::executeStudy(), and RayTracingStudy::onCompleteRay().

_ending_max_intersections

unsigned int RayTracingStudy::_ending_max_intersections

privateinherited

Max number of intersections for Rays that finished on this processor.

Definition at line 1117 of file RayTracingStudy.h.

Referenced by RayTracingStudy::endingMaxIntersections(), RayTracingStudy::executeStudy(), and RayTracingStudy::onCompleteRay().

_ending_max_processor_crossings

unsigned int RayTracingStudy::_ending_max_processor_crossings

privateinherited

Max number of total processor crossings for Rays that finished on this processor.

Definition at line 1108 of file RayTracingStudy.h.

Referenced by RayTracingStudy::endingMaxProcessorCrossings(), RayTracingStudy::executeStudy(), and RayTracingStudy::onCompleteRay().

_ending_max_trajectory_changes

unsigned int RayTracingStudy::_ending_max_trajectory_changes

privateinherited

Max number of trajectory changes for Rays that finished on this processor.

Definition at line 1119 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::onCompleteRay().

_ending_processor_crossings

unsigned long long int RayTracingStudy::_ending_processor_crossings

privateinherited

Total number of processor crossings for Rays that finished on this processor.

Definition at line 1106 of file RayTracingStudy.h.

Referenced by RayTracingStudy::endingProcessorCrossings(), RayTracingStudy::executeStudy(), and RayTracingStudy::onCompleteRay().

_execution_start_time

std::chrono::steady_clock::time_point RayTracingStudy::_execution_start_time

privateinherited

Timing.

Definition at line 1025 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy().

_execution_time

std::chrono::steady_clock::duration RayTracingStudy::_execution_time

privateinherited

Definition at line 1026 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), RayTracingStudy::executionTime(), and RayTracingStudy::executionTimeNano().

_generation_time

std::chrono::steady_clock::duration RayTracingStudy::_generation_time

privateinherited

Definition at line 1027 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::generationTime().

_has_non_planar_sides

bool RayTracingStudy::_has_non_planar_sides

privateinherited

Whether or not the local mesh has elements with non-planar sides.

Definition at line 1059 of file RayTracingStudy.h.

Referenced by RayTracingStudy::nonPlanarSideSetup(), and RayTracingStudy::sideIsNonPlanar().

_has_same_level_active_elems

bool RayTracingStudy::_has_same_level_active_elems

privateinherited

Whether or not the mesh has active elements of the same level.

Definition at line 1064 of file RayTracingStudy.h.

Referenced by RayTracingStudy::hasSameLevelActiveElems(), and RayTracingStudy::meshChanged().

_initial_ray_aux_data

const std::vector<std::vector<Real> >* const RepeatableRayStudy::_initial_ray_aux_data

protectedinherited

The initial Ray data to set (if defined)

Definition at line 46 of file RepeatableRayStudy.h.

Referenced by RepeatableRayStudy::defineRays(), and RepeatableRayStudy::RepeatableRayStudy().

_initial_ray_data

const std::vector<std::vector<Real> >* const RepeatableRayStudy::_initial_ray_data

protectedinherited

The initial Ray data to set (if defined)

Definition at line 42 of file RepeatableRayStudy.h.

Referenced by RepeatableRayStudy::defineRays(), and RepeatableRayStudy::RepeatableRayStudy().

_internal_sidesets

std::set<BoundaryID> RayTracingStudy::_internal_sidesets

privateinherited

The BoundaryIDs on the local mesh that have internal RayBCs.

Definition at line 1055 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getInternalSidesets(), RayTracingStudy::hasInternalSidesets(), and RayTracingStudy::internalSidesetSetup().

_internal_sidesets_map

std::vector<std::vector<std::vector<BoundaryID> > > RayTracingStudy::_internal_sidesets_map

privateinherited

Internal sideset data, if internal sidesets exist (indexed with getLocalElemIndex())

Definition at line 1057 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getInternalSidesets(), and RayTracingStudy::internalSidesetSetup().

_local_rays

std::vector<std::shared_ptr<Ray> >& RepeatableRayStudyBase::_local_rays

privateinherited

Storage for all of the Rays this processor is responsible for (restartable)

Definition at line 70 of file RepeatableRayStudyBase.h.

Referenced by RepeatableRayStudyBase::defineRaysInternal(), RepeatableRayStudyBase::generateRays(), and RepeatableRayStudyBase::meshChanged().

_local_trace_ray_results

std::vector<unsigned long long int> RayTracingStudy::_local_trace_ray_results

privateinherited

Cumulative results on this processor from the threaded TraceRay objects.

Definition at line 1133 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::localTraceRayResult().

_loose_b_box

libMesh::BoundingBox RayTracingStudy::_loose_b_box

privateinherited

Loose nodal bounding box for the domain.

Definition at line 1069 of file RayTracingStudy.h.

Referenced by RayTracingStudy::looseBoundingBox(), and RayTracingStudy::RayTracingStudy().

_max_distances

const std::vector<Real>* const RepeatableRayStudy::_max_distances

protectedinherited

The Ray max distances (if defined)

Definition at line 38 of file RepeatableRayStudy.h.

Referenced by RepeatableRayStudy::defineRays(), and RepeatableRayStudy::RepeatableRayStudy().

_max_intersections

unsigned int RayTracingStudy::_max_intersections

privateinherited

Max number of intersections for a single Ray.

Definition at line 1123 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::maxIntersections().

_max_processor_crossings

unsigned int RayTracingStudy::_max_processor_crossings

privateinherited

Max number of processor crossings for all Rays.

Definition at line 1112 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::maxProcessorCrossings().

_max_trajectory_changes

unsigned int RayTracingStudy::_max_trajectory_changes

privateinherited

Max number of trajectory changes for a single Ray.

Definition at line 1125 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::maxTrajectoryChanges().

_mesh

MooseMesh& RayTracingStudy::_mesh

protectedinherited

The Mesh.

Definition at line 861 of file RayTracingStudy.h.

Referenced by RayTracingStudy::computeTotalVolume(), ConeRayStudy::ConeRayStudy(), RayTracingStudy::coverageChecks(), ConeRayStudy::defineRays(), LotsOfRaysRayStudy::defineRays(), RepeatableRayStudyBaseTest::defineRays(), BackfaceCullingStudyTest::generateNormals(), RayTracingStudyTest::generateRays(), StationaryRayStudyTest::generateRays(), TestReuseRaysStudy::generateRays(), TestTransientRaysStudy::generateRays(), TestRay::generateRays(), ViewFactorRayStudy::generateStartElems(), RayTracingStudy::internalSidesetSetup(), RayTracingStudy::isRectangularDomain(), RayTracingStudy::localElemIndexSetup(), LotsOfRaysRayStudy::LotsOfRaysRayStudy(), RayTracingStudy::mesh(), RayTracingStudy::meshBase(), RayTracingStudy::nonPlanarSideSetup(), RayTracingStudy::periodicBoundaryChecks(), RayTracingStudy::RayTracingStudy(), RayTracingStudy::sameLevelActiveElems(), RayTracingStudy::subdomainHMaxSetup(), TestReuseRaysStudy::TestReuseRaysStudy(), RayTracingStudy::traceableMeshChecks(), and ViewFactorRayStudy::ViewFactorRayStudy().

_names

const std::vector<std::string> RepeatableRayStudy::_names

protectedinherited

The Ray names.

Definition at line 30 of file RepeatableRayStudy.h.

Referenced by RepeatableRayStudy::defineRays(), and RepeatableRayStudy::RepeatableRayStudy().

_non_planar_sides

std::vector<std::vector<unsigned short> > RayTracingStudy::_non_planar_sides

privateinherited

Non planar side data, which is for quick checking if an elem side is non-planar We use unsigned short here to avoid a std::vector<bool>; 0 = false, otherwise true.

Definition at line 1062 of file RayTracingStudy.h.

Referenced by RayTracingStudy::nonPlanarSideSetup(), and RayTracingStudy::sideIsNonPlanar().

_num_cached

std::vector<std::size_t> RayTracingStudy::_num_cached

privateinherited

Number of currently cached objects for Jacobian/residual for each thread.

Definition at line 1052 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), RayTracingStudy::jacobianSetup(), RayTracingStudy::postOnSegment(), and RayTracingStudy::residualSetup().

_parallel_ray_study

const std::unique_ptr<ParallelRayStudy> RayTracingStudy::_parallel_ray_study

privateinherited

The study that used is to actually execute (trace) the Rays.

Definition at line 1100 of file RayTracingStudy.h.

Referenced by RayTracingStudy::acquireCopiedRay(), RayTracingStudy::acquireRay(), RayTracingStudy::acquireRayDuringTrace(), RayTracingStudy::acquireRayInternal(), RayTracingStudy::acquireRegisteredRay(), RayTracingStudy::acquireReplicatedRay(), RayTracingStudy::acquireUnsizedRay(), RayTracingStudy::currentlyGenerating(), RayTracingStudy::currentlyPropagating(), RayTracingStudy::executeStudy(), RayTracingStudy::moveRaysToBuffer(), RayTracingStudy::moveRayToBuffer(), RayTracingStudy::moveRayToBufferDuringTrace(), RayTracingStudy::parallelRayStudy(), RayTracingStudy::parallelStudy(), and RayTracingStudy::reserveRayBuffer().

_pid

const processor_id_type RayTracingStudy::_pid

protectedinherited

The rank of this processor (this actually takes time to lookup - so just do it once)

Definition at line 865 of file RayTracingStudy.h.

Referenced by LotsOfRaysRayStudy::defineRays(), RepeatableRayStudyBaseTest::defineRays(), RayTracingStudyTest::generateRays(), StationaryRayStudyTest::generateRays(), ViewFactorRayStudy::generateStartElems(), RayTracingStudy::resetUniqueRayIDs(), RepeatableRayStudyBase::verifyReplicatedRays(), and RayTracingStudy::verifyUniqueRayIDs().

_propagation_time

std::chrono::steady_clock::duration RayTracingStudy::_propagation_time

privateinherited

Definition at line 1028 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::propagationTime().

_ray_aux_data_indices

const std::vector<RayDataIndex> RepeatableRayStudy::_ray_aux_data_indices

protectedinherited

The Ray aux data indices (if defined)

Definition at line 44 of file RepeatableRayStudy.h.

Referenced by RepeatableRayStudy::defineRays(), and RepeatableRayStudy::RepeatableRayStudy().

_ray_aux_data_map

std::unordered_map<std::string, RayDataIndex> RayTracingStudy::_ray_aux_data_map

privateinherited

The map from Ray aux data names to index.

Definition at line 1034 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getRayDataIndexInternal(), and RayTracingStudy::registerRayDataInternal().

_ray_aux_data_names

std::vector<std::string> RayTracingStudy::_ray_aux_data_names

privateinherited

The names for each Ray aux data entry.

Definition at line 1039 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getRayDataNameInternal(), RayTracingStudy::hasRayAuxData(), RayTracingStudy::rayAuxDataNames(), RayTracingStudy::rayAuxDataSize(), and RayTracingStudy::registerRayDataInternal().

_ray_bank

std::vector<std::shared_ptr<Ray> > RayTracingStudy::_ray_bank

privateinherited

Cumulative Ray bank - stored only when _bank_rays_on_completion.

Definition at line 1093 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), RayTracingStudy::onCompleteRay(), and RayTracingStudy::rayBank().

_ray_data_indices

const std::vector<RayDataIndex> RepeatableRayStudy::_ray_data_indices

protectedinherited

The Ray data indices (if defined)

Definition at line 40 of file RepeatableRayStudy.h.

Referenced by RepeatableRayStudy::defineRays(), and RepeatableRayStudy::RepeatableRayStudy().

_ray_data_map

std::unordered_map<std::string, RayDataIndex> RayTracingStudy::_ray_data_map

privateinherited

The map from Ray data names to index.

Definition at line 1032 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getRayDataIndexInternal(), and RayTracingStudy::registerRayDataInternal().

_ray_data_names

std::vector<std::string> RayTracingStudy::_ray_data_names

privateinherited

The names for each Ray data entry.

Definition at line 1037 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getRayDataNameInternal(), RayTracingStudy::hasRayData(), RayTracingStudy::rayDataNames(), RayTracingStudy::rayDataSize(), and RayTracingStudy::registerRayDataInternal().

_ray_dependent_subdomain_setup

const bool RayTracingStudy::_ray_dependent_subdomain_setup

protectedinherited

Whether or not subdomain setup is dependent on the Ray.

Definition at line 880 of file RayTracingStudy.h.

Referenced by RayTracingStudy::rayDependentSubdomainSetup().

_ray_kernel_coverage_check

const bool RayTracingStudy::_ray_kernel_coverage_check

protectedinherited

Whether or not to perform coverage checks on RayKernels.

Definition at line 868 of file RayTracingStudy.h.

Referenced by RayTracingStudy::coverageChecks().

_ray_max_distance

const Real RayTracingStudy::_ray_max_distance

protectedinherited

Max distance a Ray can travel before being killed (can change)

Definition at line 891 of file RayTracingStudy.h.

Referenced by RayTracingStudy::rayMaxDistance().

_rays

std::vector<std::shared_ptr<Ray> >& RepeatableRayStudyBase::_rays

protectedinherited

Vector of Rays that the user will fill into in defineRays() (restartable)

Definition at line 44 of file RepeatableRayStudyBase.h.

Referenced by LotsOfRaysRayStudy::defineRay(), ConeRayStudy::defineRays(), RepeatableRayStudy::defineRays(), RepeatableRayStudyBaseTest::defineRays(), RepeatableRayStudyBase::defineRaysInternal(), RepeatableRayStudyBase::meshChanged(), TestRayDataStudy::modifyRays(), and RepeatableRayStudyBase::verifyReplicatedRays().

_registered_ray_map

std::unordered_map<std::string, RayID>& RayTracingStudy::_registered_ray_map

privateinherited

Map from registered Ray name to ID.

Definition at line 1042 of file RayTracingStudy.h.

Referenced by RayTracingStudy::registeredRayID(), RayTracingStudy::registeredRaySetup(), and RayTracingStudy::registerRay().

_replicated_next_ray_id

RayID RayTracingStudy::_replicated_next_ray_id

privateinherited

Storage for the next available replicated RayID, obtained via generateReplicatedRayID()

Definition at line 1097 of file RayTracingStudy.h.

Referenced by RayTracingStudy::generateReplicatedRayID(), and RayTracingStudy::resetReplicatedRayIDs().

_reverse_registered_ray_map

std::vector<std::string>& RayTracingStudy::_reverse_registered_ray_map

privateinherited

Map from registered Ray ID to name.

Definition at line 1044 of file RayTracingStudy.h.

Referenced by RayTracingStudy::registeredRayName(), and RayTracingStudy::registerRay().

_segment_qrule

std::unique_ptr<libMesh::QBase> RayTracingStudy::_segment_qrule

privateinherited

Quadrature rule for laying points across a 1D ray segment.

Definition at line 1103 of file RayTracingStudy.h.

Referenced by RayTracingStudy::buildSegmentQuadrature(), and RayTracingStudy::initialSetup().

_segments_on_cache_traces

const bool RayTracingStudy::_segments_on_cache_traces

protectedinherited

Whether or not to cache individual element segments when caching.

Definition at line 889 of file RayTracingStudy.h.

Referenced by RayTracingStudy::segmentsOnCacheTraces().

_should_claim_rays

bool& RepeatableRayStudyBase::_should_claim_rays

privateinherited

Whether or not we should call claimRays() on the next generateRays() (restartable)

Definition at line 76 of file RepeatableRayStudyBase.h.

Referenced by RepeatableRayStudyBase::defineRaysInternal(), RepeatableRayStudyBase::generateRays(), and RepeatableRayStudyBase::meshChanged().

_should_define_rays

bool& RepeatableRayStudyBase::_should_define_rays

protectedinherited

Whether or not we should call defineRays() on the next generateRays() Can be set to true in derived classes if they wish to redefine the rays after they have been defined once.

(restartable)

Definition at line 54 of file RepeatableRayStudyBase.h.

Referenced by RepeatableRayStudyBase::generateRays().

_spin_mutex

Threads::spin_mutex RayTracingStudy::_spin_mutex

mutableprivateinherited

Spin mutex object for locks.

Definition at line 1145 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getRayDataIndexInternal(), RayTracingStudy::getRayDataNameInternal(), RayTracingStudy::postOnSegment(), RayTracingStudy::registeredRayID(), RayTracingStudy::registeredRayName(), RayTracingStudy::registerRay(), RayTracingStudy::registerRayDataInternal(), RayTracingStudy::resetReplicatedRayIDs(), and RayTracingStudy::resetUniqueRayIDs().

_start_points

const std::vector<Point> RepeatableRayStudy::_start_points

protectedinherited

The points to start the Rays from.

Definition at line 32 of file RepeatableRayStudy.h.

Referenced by RepeatableRayStudy::defineRays(), and RepeatableRayStudy::RepeatableRayStudy().

_subdomain_hmax

std::unordered_map<SubdomainID, Real> RayTracingStudy::_subdomain_hmax

privateinherited

The cached hmax for all elements in a subdomain.

Definition at line 1136 of file RayTracingStudy.h.

Referenced by RayTracingStudy::subdomainHmax(), and RayTracingStudy::subdomainHMaxSetup().

_threaded_cache_ray_bc

std::vector<TheWarehouse::QueryCache<AttribBoundaries> > RayTracingStudy::_threaded_cache_ray_bc

privateinherited

Threaded cached boundary query for RayBC objects pertaining to this study.

Definition at line 1078 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getRayBCs().

_threaded_cache_ray_kernel

std::vector<TheWarehouse::QueryCache<AttribSubdomains> > RayTracingStudy::_threaded_cache_ray_kernel

privateinherited

Threaded cached subdomain query for RayKernelBase objects pertaining to this study.

Definition at line 1076 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getRayKernels().

_threaded_cached_normals

std::vector<std::unordered_map<std::pair<const Elem *, unsigned short>, Point> > RayTracingStudy::_threaded_cached_normals

privateinherited

Threaded cache for side normals that have been computed already during tracing.

Definition at line 1091 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::getSideNormal().

_threaded_cached_traces

std::vector<std::vector<TraceData> > RayTracingStudy::_threaded_cached_traces

privateinherited

The threaded storage for cached traces.

Definition at line 1049 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::initThreadedCachedTrace().

_threaded_current_ray_kernels

std::vector<std::vector<RayKernelBase *> > RayTracingStudy::_threaded_current_ray_kernels

privateinherited

The current RayKernel objects for each thread.

Definition at line 1082 of file RayTracingStudy.h.

Referenced by RayTracingStudy::currentRayKernels(), RayTracingStudy::currentRayKernelsWrite(), RayTracingStudy::executeStudy(), and RayTracingStudy::segmentSubdomainSetup().

_threaded_elem_side_builders

std::vector<libMesh::ElemSideBuilder> RayTracingStudy::_threaded_elem_side_builders

privateinherited

Threaded helpers for building element sides without extraneous allocation.

Definition at line 1021 of file RayTracingStudy.h.

Referenced by RayTracingStudy::elemSide().

_threaded_fe_face

std::vector<std::unique_ptr<libMesh::FEBase> > RayTracingStudy::_threaded_fe_face

privateinherited

Face FE used for computing face normals for each thread.

Definition at line 1086 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getSideNormal(), and RayTracingStudy::RayTracingStudy().

_threaded_next_ray_id

std::vector<RayID> RayTracingStudy::_threaded_next_ray_id

privateinherited

Storage for the next available unique RayID, obtained via generateUniqueRayID()

Definition at line 1095 of file RayTracingStudy.h.

Referenced by RayTracingStudy::generateUniqueRayID(), and RayTracingStudy::resetUniqueRayIDs().

_threaded_q_face

std::vector<std::unique_ptr<libMesh::QBase> > RayTracingStudy::_threaded_q_face

privateinherited

Face quadrature used for computing face normals for each thread.

Definition at line 1088 of file RayTracingStudy.h.

Referenced by RayTracingStudy::RayTracingStudy().

_threaded_ray_object_registration

std::vector<std::vector<std::set<const RayTracingObject *> > > RayTracingStudy::_threaded_ray_object_registration

privateinherited

Threaded storage for all of the RayTracingObjects associated with a single Ray.

Definition at line 1080 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getRayBCs(), RayTracingStudy::getRayKernels(), and RayTracingStudy::registeredRaySetup().

_threaded_trace_ray

std::vector<std::shared_ptr<TraceRay> > RayTracingStudy::_threaded_trace_ray

privateinherited

The TraceRay objects for each thread (they do the physical tracing)

Definition at line 1084 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), RayTracingStudy::meshChanged(), RayTracingStudy::RayTracingStudy(), RayTracingStudy::traceRay(), and RayTracingStudy::traceRay().

_tolerate_failure

const bool RayTracingStudy::_tolerate_failure

protectedinherited

Whether or not to tolerate a Ray Tracing failure.

Definition at line 876 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::tolerateFailure().

_total_distance

Real RayTracingStudy::_total_distance

privateinherited

Total distance traveled by all Rays.

Definition at line 1130 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::totalDistance().

_total_intersections

unsigned long long int RayTracingStudy::_total_intersections

privateinherited

Total number of Ray/element intersections.

Definition at line 1121 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::totalIntersections().

_total_processor_crossings

unsigned long long int RayTracingStudy::_total_processor_crossings

privateinherited

Total number of processor crossings.

Definition at line 1110 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy(), and RayTracingStudy::totalProcessorCrossings().

_total_volume

Real RayTracingStudy::_total_volume

privateinherited

The total volume of the domain.

Definition at line 1073 of file RayTracingStudy.h.

Referenced by RayTracingStudy::totalVolume().

_use_internal_sidesets

const bool RayTracingStudy::_use_internal_sidesets

protectedinherited

Whether or not to use the internal sidesets in ray tracing.

Definition at line 874 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getInternalSidesets(), and RayTracingStudy::internalSidesetSetup().

_use_ray_registration

const bool RayTracingStudy::_use_ray_registration

protectedinherited

Whether or not to use Ray registration.

Definition at line 872 of file RayTracingStudy.h.

Referenced by RayTracingStudy::getRayBCs(), RayTracingStudy::getRayKernels(), RayTracingStudy::registeredRayID(), RayTracingStudy::registeredRayName(), RayTracingStudy::registeredRaySetup(), RayTracingStudy::registerRay(), and RayTracingStudy::useRayRegistration().

_verify_rays

const bool RayTracingStudy::_verify_rays

protectedinherited

Whether or not to verify if Rays have valid information before being traced.

Definition at line 893 of file RayTracingStudy.h.

Referenced by RayTracingStudy::verifyRays().

_verify_trace_intersections

const bool RayTracingStudy::_verify_trace_intersections

protectedinherited

Whether or not to verify the trace intersections in devel and dbg modes.

Definition at line 896 of file RayTracingStudy.h.

Referenced by RayTracingStudy::verifyTraceIntersections().

_warn_non_planar

const bool RayTracingStudy::_warn_non_planar

protectedinherited

Whether not to warn if non-planar faces are found.

Definition at line 870 of file RayTracingStudy.h.

Referenced by RayTracingStudy::nonPlanarSideSetup(), and RayTracingStudy::warnNonPlanar().

---

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

• ray_tracing/test/include/userobjects/RepeatableRayStudyBaseTest.h
• ray_tracing/test/src/userobjects/RepeatableRayStudyBaseTest.C