Ray study that spawns Rays in a cone from a given set of starting points for the cones and half angles for the cones. More...

#include <ConeRayStudy.h>

Inheritance diagram for ConeRayStudy:

[legend]

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	ConeRayStudy (const InputParameters &parameters)

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) More...

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. More...

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. More...

virtual void	postOnSegment (const THREAD_ID tid, const std::shared_ptr< Ray > &ray)
	Called at the end of a Ray segment. More...

virtual void	preTrace (const THREAD_ID, const std::shared_ptr< Ray > &)
	Called at the beginning of a trace for a ray. More...

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

unsigned long long int	endingProcessorCrossings () const
	Total number of processor crossings for Rays that finished on this processor. More...

unsigned int	endingMaxProcessorCrossings () const
	Max number of total processor crossings for Rays that finished on this processor. More...

unsigned long long int	totalProcessorCrossings () const
	Total number of processor crossings. More...

unsigned int	maxProcessorCrossings () const
	Max number of processor crossings for all Rays. More...

unsigned long long int	endingIntersections () const
	Total number of Ray/element intersections for Rays that finished on this processor. More...

unsigned int	endingMaxIntersections () const
	Max number of intersections for Rays that finished on this processor. More...

unsigned long long int	totalIntersections () const
	Total number of Ray/element intersections. More...

unsigned int	maxIntersections () const
	Max number of intersections for a Ray. More...

unsigned int	maxTrajectoryChanges () const
	Max number of trajectory changes for a Ray. More...

Real	endingDistance () const
	Total amount of distance traveled by the rays that end on this processor. More...

Real	totalDistance () const
	Total distance traveled by all Rays. More...

unsigned long long int	localTraceRayResult (const int result) const

const ParallelRayStudy &	parallelRayStudy () const

Real	rayMaxDistance () const
	Max distance any Ray can travel. More...

Real	executionTime ()
	Duration for execute() in seconds. More...

Real	executionTimeNano ()
	Duration for execute() in nanoseconds. More...

Real	generationTime () const
	Duration for creation of all Rays in seconds. More...

Real	propagationTime () const
	Duration for creation of all Rays in seconds. More...

bool	tolerateFailure () const
	Whether or not to tolerate failure. More...

bool	bankRaysOnCompletion () const
	Whether or not to bank Rays on completion. More...

bool	rayDependentSubdomainSetup () const
	Whether or not to use Ray dependent subdomain setup. More...

RayDataIndex	registerRayData (const std::string &name)
	Register a value to be filled in the data on a Ray with a given name. More...

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. More...

RayDataIndex	getRayDataIndex (const std::string &name, const bool graceful=false) const
	Gets the index associated with a registered value in the Ray data. More...

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. More...

const std::string &	getRayDataName (const RayDataIndex index) const
	Gets the name associated with a registered value in the Ray data. More...

std::vector< std::string >	getRayDataNames (const std::vector< RayDataIndex > &indices) const
	Gets the names associated with registered values in the Ray data. More...

std::size_t	rayDataSize () const
	The registered size of values in the Ray data. More...

bool	hasRayData () const
	Whether or not any Ray data are registered. More...

const std::vector< std::string > &	rayDataNames () const
	The Ray data names. More...

RayDataIndex	registerRayAuxData (const std::string &name)
	Register a value to be filled in the aux data on a Ray with a given name. More...

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. More...

RayDataIndex	getRayAuxDataIndex (const std::string &name, const bool graceful=false) const
	Gets the index associated with a registered value in the Ray aux data. More...

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. More...

const std::string &	getRayAuxDataName (const RayDataIndex index) const
	Gets the name associated with a registered value in the Ray aux data. More...

std::vector< std::string >	getRayAuxDataNames (const std::vector< RayDataIndex > &indices) const
	Gets the names associated with registered values in the Ray aux data. More...

std::size_t	rayAuxDataSize () const
	The registered size of values in the Ray aux data. More...

bool	hasRayAuxData () const
	Whether or not any Ray aux data are registered. More...

const std::vector< std::string > &	rayAuxDataNames () const
	The Ray aux data names. More...

bool	hasRayKernels (const THREAD_ID tid)
	Whether or not there are currently any active RayKernel objects. More...

void	getRayKernels (std::vector< RayKernelBase *> &result, SubdomainID id, THREAD_ID tid)
	Fills the active RayKernels associated with this study and a block into result. More...

template<typename T >
void	getRayKernels (std::vector< T *> &result, THREAD_ID tid)
	Fills the active RayKernels associated with this study into result. More...

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. More...

void	getRayBCs (std::vector< RayBoundaryConditionBase *> &result, BoundaryID id, THREAD_ID tid)
	Fills the active RayBCs associated with this study and a boundary into result. More...

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. More...

template<typename T >
void	getRayBCs (std::vector< T *> &result, THREAD_ID tid)
	Fills the active RayBCs associated with this study into result. More...

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. More...

const std::vector< RayKernelBase * > &	currentRayKernels (THREAD_ID tid) const
	Gets the current RayKernels for a thread, which are set in segmentSubdomainSetup() More...

const BoundingBox &	boundingBox () const
	Get the nodal bounding box for the domain. More...

const BoundingBox &	looseBoundingBox () const
	Get the loose nodal bounding box for the domain. More...

Real	domainMaxLength () const
	Get the inflated maximum length across the domain. More...

Real	totalVolume () const
	Get the current total volume of the domain. More...

bool	isRectangularDomain () const
	Whether or not the domain is rectangular (if it is prefectly encompassed by its bounding box) More...

bool	hasInternalSidesets () const
	Whether or not the local mesh has internal sidesets that have RayBCs on them. More...

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. More...

const std::set< BoundaryID > &	getInternalSidesets () const
	Gets the internal sidesets (that have RayBCs) within the local domain. More...

bool	sideIsNonPlanar (const Elem *elem, const unsigned short s) const
	Whether or not the side on elem `elem` is non-planar. More...

bool	hasSameLevelActiveElems () const
	Whether or not the mesh has active elements of the same level. More...

void	moveRayToBufferDuringTrace (std::shared_ptr< Ray > &ray, const THREAD_ID tid, const AcquireMoveDuringTraceKey &)
	INTERNAL method for moving a Ray into the buffer during tracing. More...

MeshBase &	meshBase () const
	Access to the libMesh MeshBase. More...

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. More...

virtual const Point *	getElemNormals (const Elem *, const THREAD_ID)
	Gets the outward normals for a given element. More...

RayData	getBankedRayData (const RayID ray_id, const RayDataIndex index) const
	Gets the data value for a banked ray with a given ID. More...

RayData	getBankedRayAuxData (const RayID ray_id, const RayDataIndex index) const
	Gets the data value for a banked ray with a given ID. More...

RayID	registeredRayID (const std::string &name, const bool graceful=false) const
	Gets the ID of a registered ray. More...

const std::string &	registeredRayName (const RayID ray_id) const
	Gets the name of a registered ray. More...

bool	useRayRegistration () const
	Whether or not ray registration is being used. More...

bool	dataOnCacheTraces () const
	Whether or not to store the Ray data on the cached Ray traces. More...

bool	auxDataOnCacheTraces () const
	Whether or not to store the Ray aux data on the cached Ray traces. More...

bool	segmentsOnCacheTraces () const
	Whether or not to cache individual element segments when _cache_traces = true. More...

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). More...

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. More...

const std::vector< TraceData > &	getCachedTraces () const
	Get the cached trace data structure. More...

Real	subdomainHmax (const SubdomainID subdomain_id) const
	Get the cached hmax for all elements in a subdomain. More...

virtual void	onCompleteRay (const std::shared_ptr< Ray > &ray)
	Entry point for acting on a ray when it is completed (shouldContinue() == false) More...

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. More...

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. More...

bool	currentlyPropagating () const
	Whether or not the study is propagating (tracing Rays) More...

bool	currentlyGenerating () const
	Whether or not the study is generating. More...

bool	verifyRays () const
	Whether or not to verify if Rays have valid information before being traced. More...

bool	verifyTraceIntersections () const
	Whether or not trace verification is enabled in devel/dbg modes. More...

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`. More...

bool	warnNonPlanar () const
	Whether or not to produce a warning when interacting with a non-planar mesh. More...

ParallelStudy< std::shared_ptr< Ray >, Ray > *	parallelStudy ()
	The underlying parallel study: used for the context for calling the packed range routines. More...

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. More...

SubProblem &	getSubProblem () const

bool	shouldDuplicateInitialExecution () const

virtual Real	spatialValue (const Point &) const

virtual const std::vector< Point >	spatialPoints () 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)

void	setPrimaryThreadCopy (UserObject *primary)

UserObject *	primaryThreadCopy ()

std::set< UserObjectName >	getDependObjects () const

virtual bool	needThreadedCopy () const

const std::set< std::string > &	getRequestedItems () override

const std::set< std::string > &	getSuppliedItems () override

unsigned int	systemNumber () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

std::string	errorPrefix (const std::string &error_type) const

void	callMooseError (std::string msg, const bool with_prefix) const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

const InputParameters &	parameters () const

MooseObjectName	uniqueName () 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 &nm) const

void	paramError (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

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	mooseError (Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseInfo (Args &&... args) 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 UserObject &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObject &	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)

std::pair< const MaterialProperty< T > *, std::set< SubdomainID > >	getBlockMaterialProperty (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)

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	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

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. More...

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`. More...

const TraceRay &	traceRay (const THREAD_ID tid) const

Static Public Member Functions
static InputParameters	validParams ()

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)

Public Attributes
const ConsoleStream	_console

Static Public Attributes
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
virtual void	defineRays () override
	Entry point for the user to create Rays. More...

virtual void	meshChanged () override

virtual void	generateRays () override
	Subclasses should override this to determine how to generate Rays. More...

virtual void	preExecuteStudy ()
	Entry point before study execution. More...

virtual void	postExecuteStudy ()
	Entry point after study execution. More...

Real	computeTotalVolume ()
	Helper function for computing the total domain volume. More...

std::vector< RayKernelBase * > &	currentRayKernelsWrite (THREAD_ID tid)
	Gets the writeable current RayKernels for a thread. More...

void	reserveRayBuffer (const std::size_t size)
	Reserve `size` entires in the Ray buffer. More...

bool	sameLevelActiveElems () const
	Determine whether or not the mesh currently has active elements that are all the same level. More...

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. More...

const std::vector< std::shared_ptr< Ray > > &	rayBank () const
	Get the Ray bank. More...

std::shared_ptr< Ray >	getBankedRay (const RayID ray_id) const
	Gets the Ray with the ID `ray_id` from the Ray bank. More...

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

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

std::vector< RayTracingObject * >	getRayTracingObjects ()
	Gets all of the currently active RayTracingObjects. More...

virtual RayID	generateUniqueRayID (const THREAD_ID tid)
	Generates a unique RayID to be used for a Ray. More...

RayID	generateReplicatedRayID ()
	Generates a Ray ID that is replicated across all processors. More...

void	moveRayToBuffer (std::shared_ptr< Ray > &ray)
	Moves a ray to the buffer to be traced during generateRays(). More...

void	moveRaysToBuffer (std::vector< std::shared_ptr< Ray >> &rays)
	Moves rays to the buffer to be traced during generateRays(). More...

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &name) const override

virtual void	addVectorPostprocessorDependencyHelper (const VectorPostprocessorName &name) const override

virtual void	addUserObjectDependencyHelper (const UserObject &uo) const override

void	addReporterDependencyHelper (const ReporterName &reporter_name) override

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, TagID tag, unsigned int comp=0) const

const VariableValue &	coupledMatrixTagScalarValue (const std::string &var_name, TagID tag, 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

const MooseVariableScalar *	getScalarVar (const std::string &var_name, unsigned int comp) const

virtual void	checkMaterialProperty (const std::string &name, const unsigned int state)

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. More...

std::shared_ptr< Ray >	acquireUnsizedRay ()
	Acquire a Ray from the pool of Rays within generateRays(), without resizing the data (sizes the data to zero). More...

std::shared_ptr< Ray >	acquireReplicatedRay ()
	Acquire a Ray from the pool of Rays within generateRays() in a replicated fashion. More...

std::shared_ptr< Ray >	acquireCopiedRay (const Ray &ray)
	Acquires a Ray that that is copied from another Ray within generateRays(). More...

std::shared_ptr< Ray >	acquireRegisteredRay (const std::string &name)
	Acquires a Ray with a given name within generateRays(). More...

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

Protected Attributes
const std::vector< Point >	_start_points
	The points to start the Rays from (the cone points) More...

const std::vector< Point >	_directions
	The directions that define the cones (points down the center of the cone) More...

const std::vector< Real >	_scaling_factors
	Scaling factors for each cone's Rays (defaults to 1) More...

const std::vector< Real >	_half_cone_angles
	The half-cone angles in degrees for each cone. More...

const std::vector< unsigned int >	_polar_quad_orders
	The polar quadrature orders for each cone. More...

const std::vector< unsigned int >	_azimuthal_quad_orders
	The azimuthal quadrature orders for each cone. More...

const RayDataIndex	_ray_data_index
	The index into the Ray's data for storing the angular quadrature weight and scaling factor. More...

std::vector< std::shared_ptr< Ray > > &	_rays
	Vector of Rays that the user will fill into in defineRays() (restartable) More...

const bool	_define_rays_replicated
	Whether or not the Rays filled into _rays are replicated across all processors. More...

const bool	_claim_after_define_rays
	Whether or not Rays need to be claimed after defineRays() More...

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. More...

MooseMesh &	_mesh
	The Mesh. More...

const Parallel::Communicator &	_comm
	The Communicator. More...

const processor_id_type	_pid
	The rank of this processor (this actually takes time to lookup - so just do it once) More...

const bool	_ray_kernel_coverage_check
	Whether or not to perform coverage checks on RayKernels. More...

const bool	_warn_non_planar
	Whether not to warn if non-planar faces are found. More...

const bool	_use_ray_registration
	Whether or not to use Ray registration. More...

const bool	_use_internal_sidesets
	Whether or not to use the internal sidesets in ray tracing. More...

const bool	_tolerate_failure
	Whether or not to tolerate a Ray Tracing failure. More...

const bool	_bank_rays_on_completion
	Whether or not to bank rays on completion. More...

const bool	_ray_dependent_subdomain_setup
	Whether or not subdomain setup is dependent on the Ray. More...

bool	_always_cache_traces
	Whether or not to cache traces on every trace execution. More...

const bool	_data_on_cache_traces
	Whether or not to store the Ray data on the cache traces. More...

const bool	_aux_data_on_cache_traces
	Whether or not to store the Ray aux data on the cache traces. More...

const bool	_segments_on_cache_traces
	Whether or not to cache individual element segments when caching. More...

const Real	_ray_max_distance
	Max distance a Ray can travel before being killed (can change) More...

const bool	_verify_rays
	Whether or not to verify if Rays have valid information before being traced. More...

const bool	_verify_trace_intersections
	Whether or not to verify the trace intersections in devel and dbg modes. More...

SubProblem &	_subproblem

FEProblemBase &	_fe_problem

SystemBase &	_sys

const THREAD_ID	_tid

Assembly &	_assembly

const Moose::CoordinateSystemType &	_coord_sys

const bool	_duplicate_initial_execution

std::set< std::string >	_depend_uo

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

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 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

Detailed Description

Ray study that spawns Rays in a cone from a given set of starting points for the cones and half angles for the cones.

Definition at line 18 of file ConeRayStudy.h.

Constructor & Destructor Documentation

◆ ConeRayStudy()

ConeRayStudy::ConeRayStudy ( const InputParameters & parameters )

Definition at line 55 of file ConeRayStudy.C.

   : RepeatableRayStudyBase(parameters),
     _start_points(getParam<std::vector<Point>>("start_points")),
     _directions(getParam<std::vector<Point>>("directions")),
     _scaling_factors(isParamValid("scaling_factors")
                          ? getParam<std::vector<Real>>("scaling_factors")
                          : std::vector<Real>(_start_points.size(), 1)), // default to 1
     _half_cone_angles(getParam<std::vector<Real>>("half_cone_angles")),
     _polar_quad_orders(isParamValid("polar_quad_orders")
                            ? getParam<std::vector<unsigned int>>("polar_quad_orders")
                            : std::vector<unsigned int>(_start_points.size(), 2)), // default to 2
     _azimuthal_quad_orders(
         isParamValid("azimuthal_quad_orders")
             ? getParam<std::vector<unsigned int>>("azimuthal_quad_orders")
             : std::vector<unsigned int>(_start_points.size(), 30)), // default to 30
     _ray_data_index(registerRayData(getParam<std::string>("ray_data_name")))
 {
   if (_directions.size() != _start_points.size())
     paramError("directions", "Not the same size as start_points.");
 
   if (_scaling_factors.size() != _start_points.size())
     paramError("scaling_factors", "Not the same size as start_points.");
 
   if (_half_cone_angles.size() != _start_points.size())
     paramError("half_cone_angles", "Not the same size as start_points.");
   for (const auto val : _half_cone_angles)
     if (val <= 0 || val > 90)
       paramError("half_cone_angles", "Must be > 0 and <= 90 degrees");
 
   if (_polar_quad_orders.size() != _start_points.size())
     paramError("polar_quad_orders", "Not the same size as start_points.");
 
   if (_azimuthal_quad_orders.size() != _start_points.size())
     paramError("azimuthal_quad_orders", "Not the same size as start_points.");
 
   if (_mesh.dimension() == 1)
     mooseError("Does not support 1D.");
 }

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 1731 of file RayTracingStudy.C.

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

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

◆ 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 1667 of file RayTracingStudy.C.

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

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

◆ 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 1739 of file RayTracingStudy.C.

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

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

◆ 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.

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

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

◆ 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 1712 of file RayTracingStudy.C.

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

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

◆ 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 1696 of file RayTracingStudy.C.

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

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

◆ 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 1682 of file RayTracingStudy.C.

Referenced by LotsOfRaysRayStudy::defineRay().

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

◆ 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.

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

573 { return _aux_data_on_cache_traces; }

RayTracingStudy::_aux_data_on_cache_traces

const bool _aux_data_on_cache_traces

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

Definition: RayTracingStudy.h:887

◆ bankRaysOnCompletion()

bool RayTracingStudy::bankRaysOnCompletion ( ) const

inlineinherited

Whether or not to bank Rays on completion.

Definition at line 214 of file RayTracingStudy.h.

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

214 { return _bank_rays_on_completion; }

RayTracingStudy::_bank_rays_on_completion

const bool _bank_rays_on_completion

Whether or not to bank rays on completion.

Definition: RayTracingStudy.h:878

◆ boundingBox()

const BoundingBox& RayTracingStudy::boundingBox ( ) const

inlineinherited

Get the nodal bounding box for the domain.

Definition at line 422 of file RayTracingStudy.h.

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

422 { return _b_box; }

RayTracingStudy::_b_box

libMesh::BoundingBox _b_box

Nodal bounding box for the domain.

Definition: RayTracingStudy.h:1060

◆ 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 710 of file RayTracingStudy.C.

Referenced by RayTracingStudy::reinitSegment().

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

◆ computeTotalVolume()

Real RayTracingStudy::computeTotalVolume ( )

protectedinherited

Helper function for computing the total domain volume.

Definition at line 1387 of file RayTracingStudy.C.

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

◆ currentlyGenerating()

bool RayTracingStudy::currentlyGenerating ( ) const

inlineinherited

Whether or not the study is generating.

Definition at line 641 of file RayTracingStudy.h.

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

641 { return _parallel_ray_study->currentlyPreExecuting(); }

RayTracingStudy::_parallel_ray_study

const std::unique_ptr< ParallelRayStudy > _parallel_ray_study

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

Definition: RayTracingStudy.h:1093

◆ currentlyPropagating()

bool RayTracingStudy::currentlyPropagating ( ) const

inlineinherited

Whether or not the study is propagating (tracing Rays)

Definition at line 637 of file RayTracingStudy.h.

637 { return _parallel_ray_study->currentlyExecuting(); }

RayTracingStudy::_parallel_ray_study

const std::unique_ptr< ParallelRayStudy > _parallel_ray_study

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

Definition: RayTracingStudy.h:1093

◆ 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.

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

   {
     return _threaded_current_ray_kernels[tid];
   }

◆ 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.

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

569 { return _data_on_cache_traces; }

RayTracingStudy::_data_on_cache_traces

const bool _data_on_cache_traces

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

Definition: RayTracingStudy.h:885

◆ defineRays()

void ConeRayStudy::defineRays ( )

overrideprotectedvirtual

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.

Implements RepeatableRayStudyBase.

Definition at line 95 of file ConeRayStudy.C.

 {
   // Loop through each cone
   for (std::size_t i = 0; i < _start_points.size(); ++i)
   {
     // Setup the angular quadrature and rotate it about the direction
     // (the direction points down the middle of the cone)
     RayTracingAngularQuadrature aq(_mesh.dimension(),
                                    _polar_quad_orders[i],
                                    _azimuthal_quad_orders[i],
                                    std::cos(_half_cone_angles[i] * M_PI / 180.),
                                    1);
     aq.rotate(_directions[i].unit());
 
     // For all angles in the angular quadrature, spawn a Ray
     for (std::size_t l = 0; l < aq.numDirections(); ++l)
     {
       // Get a Ray from the study to initialize
       std::shared_ptr<Ray> ray = acquireReplicatedRay();
 
       // Start from our cone point in the rotated angular quadrature direction
       // Note here that we do not need to set the starting element - all Rays
       // at this point are replicated across all processors and will be
       // properly claimed (moved to the starting proc with the correct starting elem)
       ray->setStart(_start_points[i]);
       ray->setStartingDirection(aq.getDirection(l));
 
       // Add the angular quadrature weight and scaling factor as data on the Ray for weighting
       //
       // In the 2D case, the 3D directions projected into the 2D plane may overlap. Therefore,
       // we could have multiple weights/sins for a single direction, which is why here we grab
       // the total weight.
       //
       // The angular quadrature weights sum to 2pi, so scale such that they scale to 1
       ray->data(_ray_data_index) = _scaling_factors[i] * aq.getTotalWeight(l) / (2. * M_PI);
 
       // Done with this Ray - move it to be traced later on
       _rays.emplace_back(std::move(ray));
     }
   }
 }

◆ domainMaxLength()

Real RayTracingStudy::domainMaxLength ( ) const

inlineinherited

Get the inflated maximum length across the domain.

Definition at line 433 of file RayTracingStudy.h.

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

433 { return _domain_max_length; }

RayTracingStudy::_domain_max_length

Real _domain_max_length

An inflated max distance for the domain.

Definition: RayTracingStudy.h:1064

◆ 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.

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

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

◆ 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.

168 { return _ending_distance; }

RayTracingStudy::_ending_distance

Real _ending_distance

Total distance traveled by Rays that end on this processor.

Definition: RayTracingStudy.h:1121

◆ 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.

147 { return _ending_intersections; }

RayTracingStudy::_ending_intersections

unsigned long long int _ending_intersections

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

Definition: RayTracingStudy.h:1108

◆ 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.

151 { return _ending_max_intersections; }

RayTracingStudy::_ending_max_intersections

unsigned int _ending_max_intersections

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

Definition: RayTracingStudy.h:1110

◆ 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.

134 { return _ending_max_processor_crossings; }

RayTracingStudy::_ending_max_processor_crossings

unsigned int _ending_max_processor_crossings

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

Definition: RayTracingStudy.h:1101

◆ 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.

130 { return _ending_processor_crossings; }

RayTracingStudy::_ending_processor_crossings

unsigned long long int _ending_processor_crossings

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

Definition: RayTracingStudy.h:1099

◆ execute()

void RayTracingStudy::execute ( )

overridevirtualinherited

Executes the study (generates and propagates Rays)

Implements GeneralUserObject.

Reimplemented in SingleTraceLineSourceTest.

Definition at line 310 of file RayTracingStudy.C.

Referenced by SingleTraceLineSourceTest::execute().

 {
   executeStudy();
 }

◆ 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 771 of file RayTracingStudy.C.

Referenced by RayTracingStudy::execute().

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

◆ executionTime()

Real RayTracingStudy::executionTime ( )

inlineinherited

Duration for execute() in seconds.

Definition at line 189 of file RayTracingStudy.h.

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

RayTracingStudy::_execution_time

std::chrono::steady_clock::duration _execution_time

Definition: RayTracingStudy.h:1019

◆ 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.

81 {}

◆ 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 1650 of file RayTracingStudy.C.

Referenced by RayTracingStudy::acquireReplicatedRay().

 {
   return _replicated_next_ray_id++;
 }

◆ 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 1625 of file RayTracingStudy.C.

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

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

◆ generationTime()

Real RayTracingStudy::generationTime ( ) const

inlineinherited

Duration for creation of all Rays in seconds.

Definition at line 200 of file RayTracingStudy.h.

Referenced by PerProcessorRayTracingResultsVectorPostprocessor::execute().

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

RayTracingStudy::_generation_time

std::chrono::steady_clock::duration _generation_time

Definition: RayTracingStudy.h:1020

◆ 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 1277 of file RayTracingStudy.C.

Referenced by RayTracingStudy::getBankedRayDataInternal().

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

◆ 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 1321 of file RayTracingStudy.C.

Referenced by RayDataValue::getValue().

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

◆ 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 1315 of file RayTracingStudy.C.

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

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

◆ getCachedTraces()

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

inlineinherited

Get the cached trace data structure.

Definition at line 595 of file RayTracingStudy.h.

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

595 { return _cached_traces; }

RayTracingStudy::_cached_traces

std::vector< TraceData > _cached_traces

Storage for the cached traces.

Definition: RayTracingStudy.h:1040

◆ 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.

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

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

◆ getInternalSidesets() [1/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)

Referenced by TraceRay::applyOnInternalBoundary().

◆ getInternalSidesets() [2/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.

Referenced by ViewFactorRayStudy::initialSetup().

459 { return _internal_sidesets; }

RayTracingStudy::_internal_sidesets

std::set< BoundaryID > _internal_sidesets

The BoundaryIDs on the local mesh that have internal RayBCs.

Definition: RayTracingStudy.h:1048

◆ 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 1110 of file RayTracingStudy.C.

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

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

◆ 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 1117 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 1124 of file RayTracingStudy.C.

Referenced by Ray::getInfo().

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

◆ 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 1188 of file RayTracingStudy.C.

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

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

◆ getRayBCs() [2/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() [3/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);
   }

◆ getRayBCs() [4/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 1211 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);
   }
 }

◆ 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 1079 of file RayTracingStudy.C.

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

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

◆ 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 1085 of file RayTracingStudy.C.

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

◆ 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 1092 of file RayTracingStudy.C.

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

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

◆ 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 1138 of file RayTracingStudy.C.

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

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

◆ getRayKernels() [2/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);
   }

◆ getRayKernels() [3/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 1159 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);
   }
 }

◆ getRayTracingObjects()

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

protectedinherited

Gets all of the currently active RayTracingObjects.

Definition at line 1257 of file RayTracingStudy.C.

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

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

◆ 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 1550 of file RayTracingStudy.C.

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

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

◆ 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.

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

449 { return _internal_sidesets.size(); }

RayTracingStudy::_internal_sidesets

std::set< BoundaryID > _internal_sidesets

The BoundaryIDs on the local mesh that have internal RayBCs.

Definition: RayTracingStudy.h:1048

◆ hasRayAuxData()

bool RayTracingStudy::hasRayAuxData ( ) const

inlineinherited

Whether or not any Ray aux data are registered.

Definition at line 336 of file RayTracingStudy.h.

336 { return _ray_aux_data_names.size(); }

RayTracingStudy::_ray_aux_data_names

std::vector< std::string > _ray_aux_data_names

The names for each Ray aux data entry.

Definition: RayTracingStudy.h:1032

◆ hasRayData()

bool RayTracingStudy::hasRayData ( ) const

inlineinherited

Whether or not any Ray data are registered.

Definition at line 276 of file RayTracingStudy.h.

Referenced by RayTracingMeshOutput::fillFields().

276 { return _ray_data_names.size(); }

RayTracingStudy::_ray_data_names

std::vector< std::string > _ray_data_names

The names for each Ray data entry.

Definition: RayTracingStudy.h:1030

◆ hasRayKernels()

bool RayTracingStudy::hasRayKernels ( const THREAD_ID tid )

inherited

Whether or not there are currently any active RayKernel objects.

Definition at line 1130 of file RayTracingStudy.C.

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

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

◆ 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.

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

475 { return _has_same_level_active_elems; }

RayTracingStudy::_has_same_level_active_elems

bool _has_same_level_active_elems

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

Definition: RayTracingStudy.h:1057

◆ initialize()

virtual void RayTracingStudy::initialize ( )

inlineoverridevirtualinherited

Implements GeneralUserObject.

Definition at line 80 of file RayTracingStudy.h.

80 {}

◆ initialSetup()

void RayTracingStudy::initialSetup ( )

overridevirtualinherited

Reimplemented from GeneralUserObject.

Reimplemented in BackfaceCullingStudyTest, and ViewFactorRayStudy.

Definition at line 226 of file RayTracingStudy.C.

Referenced by ViewFactorRayStudy::initialSetup(), and BackfaceCullingStudyTest::initialSetup().

 {
   // 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();
 
   // 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(QGAUSS, 1, _fe_problem.getSystemBase(_sys.number()).getMinQuadratureOrder());
 }

◆ 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 1409 of file RayTracingStudy.C.

Referenced by TraceRay::trace().

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

◆ 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 1601 of file RayTracingStudy.C.

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

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

◆ jacobianSetup()

void RayTracingStudy::jacobianSetup ( )

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

◆ localTraceRayResult()

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

inlineinherited

Definition at line 174 of file RayTracingStudy.h.

Referenced by PerProcessorRayTracingResultsVectorPostprocessor::execute().

   {
     return _local_trace_ray_results[result];
   }

◆ 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.

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

429 { return _loose_b_box; }

RayTracingStudy::_loose_b_box

libMesh::BoundingBox _loose_b_box

Loose nodal bounding box for the domain.

Definition: RayTracingStudy.h:1062

◆ maxIntersections()

unsigned int RayTracingStudy::maxIntersections ( ) const

inlineinherited

Max number of intersections for a Ray.

Definition at line 159 of file RayTracingStudy.h.

159 { return _max_intersections; }

RayTracingStudy::_max_intersections

unsigned int _max_intersections

Max number of intersections for a single Ray.

Definition: RayTracingStudy.h:1116

◆ maxProcessorCrossings()

unsigned int RayTracingStudy::maxProcessorCrossings ( ) const

inlineinherited

Max number of processor crossings for all Rays.

Definition at line 142 of file RayTracingStudy.h.

Referenced by RayTracingStudyResult::getValue().

142 { return _max_processor_crossings; }

RayTracingStudy::_max_processor_crossings

unsigned int _max_processor_crossings

Max number of processor crossings for all Rays.

Definition: RayTracingStudy.h:1105

◆ maxTrajectoryChanges()

unsigned int RayTracingStudy::maxTrajectoryChanges ( ) const

inlineinherited

Max number of trajectory changes for a Ray.

Definition at line 163 of file RayTracingStudy.h.

163 { return _max_trajectory_changes; }

RayTracingStudy::_max_trajectory_changes

unsigned int _max_trajectory_changes

Max number of trajectory changes for a single Ray.

Definition: RayTracingStudy.h:1118

◆ mesh()

MooseMesh& RayTracingStudy::mesh ( )

inlineinherited

Returns: A reference to the MooseMesh associated with this study.

Definition at line 520 of file RayTracingStudy.h.

520 { return _mesh; }

RayTracingStudy::_mesh

MooseMesh & _mesh

The Mesh.

Definition: RayTracingStudy.h:861

◆ 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.

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

515 { return _mesh; }

RayTracingStudy::_mesh

MooseMesh & _mesh

The Mesh.

Definition: RayTracingStudy.h:861

◆ meshChanged()

void RepeatableRayStudyBase::meshChanged ( )

overrideprotectedvirtualinherited

Reimplemented from RayTracingStudy.

Reimplemented in BackfaceCullingStudyTest.

Definition at line 117 of file RepeatableRayStudyBase.C.

Referenced by BackfaceCullingStudyTest::meshChanged().

 {
   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 1515 of file RayTracingStudy.C.

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

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

◆ 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 1505 of file RayTracingStudy.C.

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

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

◆ 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 1530 of file RayTracingStudy.C.

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

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

◆ 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 954 of file RayTracingStudy.C.

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

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

◆ parallelRayStudy()

const ParallelRayStudy& RayTracingStudy::parallelRayStudy ( ) const

inlineinherited

Definition at line 179 of file RayTracingStudy.h.

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

179 { return *_parallel_ray_study; }

RayTracingStudy::_parallel_ray_study

const std::unique_ptr< ParallelRayStudy > _parallel_ray_study

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

Definition: RayTracingStudy.h:1093

◆ 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.

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

678 { return _parallel_ray_study.get(); }

RayTracingStudy::_parallel_ray_study

const std::unique_ptr< ParallelRayStudy > _parallel_ray_study

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

Definition: RayTracingStudy.h:1093

◆ postExecuteStudy()

virtual void RayTracingStudy::postExecuteStudy ( )

inlineprotectedvirtualinherited

Entry point after study execution.

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

Definition at line 709 of file RayTracingStudy.h.

Referenced by RayTracingStudy::executeStudy().

709 {}

◆ 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 738 of file RayTracingStudy.C.

Referenced by TraceRay::trace().

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

◆ 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().

705 {}

◆ 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().

120 {}

◆ propagationTime()

Real RayTracingStudy::propagationTime ( ) const

inlineinherited

Duration for creation of all Rays in seconds.

Definition at line 204 of file RayTracingStudy.h.

Referenced by PerProcessorRayTracingResultsVectorPostprocessor::execute().

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

RayTracingStudy::_propagation_time

std::chrono::steady_clock::duration _propagation_time

Definition: RayTracingStudy.h:1021

◆ rayAuxDataNames()

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

inlineinherited

The Ray aux data names.

Definition at line 340 of file RayTracingStudy.h.

Referenced by RayTracingMeshOutput::setupEquationSystem().

340 { return _ray_aux_data_names; }

RayTracingStudy::_ray_aux_data_names

std::vector< std::string > _ray_aux_data_names

The names for each Ray aux data entry.

Definition: RayTracingStudy.h:1032

◆ 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.

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

332 { return _ray_aux_data_names.size(); }

RayTracingStudy::_ray_aux_data_names

std::vector< std::string > _ray_aux_data_names

The names for each Ray aux data entry.

Definition: RayTracingStudy.h:1032

◆ 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 1265 of file RayTracingStudy.C.

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

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

◆ rayDataNames()

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

inlineinherited

The Ray data names.

Definition at line 280 of file RayTracingStudy.h.

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

280 { return _ray_data_names; }

RayTracingStudy::_ray_data_names

std::vector< std::string > _ray_data_names

The names for each Ray data entry.

Definition: RayTracingStudy.h:1030

◆ 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.

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

272 { return _ray_data_names.size(); }

RayTracingStudy::_ray_data_names

std::vector< std::string > _ray_data_names

The names for each Ray data entry.

Definition: RayTracingStudy.h:1030

◆ rayDependentSubdomainSetup()

bool RayTracingStudy::rayDependentSubdomainSetup ( ) const

inlineinherited

Whether or not to use Ray dependent subdomain setup.

Definition at line 219 of file RayTracingStudy.h.

Referenced by TraceRay::trace().

219 { return _ray_dependent_subdomain_setup; }

RayTracingStudy::_ray_dependent_subdomain_setup

const bool _ray_dependent_subdomain_setup

Whether or not subdomain setup is dependent on the Ray.

Definition: RayTracingStudy.h:880

◆ rayMaxDistance()

Real RayTracingStudy::rayMaxDistance ( ) const

inlineinherited

Max distance any Ray can travel.

Definition at line 184 of file RayTracingStudy.h.

Referenced by TraceRay::trace().

184 { return _ray_max_distance; }

RayTracingStudy::_ray_max_distance

const Real _ray_max_distance

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

Definition: RayTracingStudy.h:891

◆ 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 1351 of file RayTracingStudy.C.

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

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

◆ 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 1371 of file RayTracingStudy.C.

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

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

◆ 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 1098 of file RayTracingStudy.C.

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

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

◆ 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 1104 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 1067 of file RayTracingStudy.C.

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

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

◆ 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 1073 of file RayTracingStudy.C.

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

◆ 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 674 of file RayTracingStudy.C.

Referenced by TraceRay::onSegment().

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

◆ 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 1541 of file RayTracingStudy.C.

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

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

◆ resetReplicatedRayIDs()

void RayTracingStudy::resetReplicatedRayIDs ( )

protectedinherited

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

Definition at line 1637 of file RayTracingStudy.C.

Referenced by RayTracingStudy::RayTracingStudy().

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

◆ resetUniqueRayIDs()

void RayTracingStudy::resetUniqueRayIDs ( )

protectedinherited

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

Definition at line 1611 of file RayTracingStudy.C.

Referenced by RayTracingStudy::RayTracingStudy().

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

◆ residualSetup()

void RayTracingStudy::residualSetup ( )

overridevirtualinherited

Reimplemented from GeneralUserObject.

Definition at line 269 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 1573 of file RayTracingStudy.C.

Referenced by RayTracingStudy::meshChanged().

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

◆ 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.

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

577 { return _segments_on_cache_traces; }

RayTracingStudy::_segments_on_cache_traces

const bool _segments_on_cache_traces

Whether or not to cache individual element segments when caching.

Definition: RayTracingStudy.h:889

◆ 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 639 of file RayTracingStudy.C.

Referenced by TraceRay::onSubdomainChanged().

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

◆ 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.

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

   {
     return _always_cache_traces;
   }

◆ 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 1656 of file RayTracingStudy.C.

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

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

◆ sideIsNonPlanar()

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

inlineinherited

Whether or not the side 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.

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

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

◆ 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 1592 of file RayTracingStudy.C.

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

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

◆ timestepSetup()

void RayTracingStudy::timestepSetup ( )

overridevirtualinherited

Reimplemented from GeneralUserObject.

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

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

209 { return _tolerate_failure; }

RayTracingStudy::_tolerate_failure

const bool _tolerate_failure

Whether or not to tolerate a Ray Tracing failure.

Definition: RayTracingStudy.h:876

◆ totalDistance()

Real RayTracingStudy::totalDistance ( ) const

inlineinherited

Total distance traveled by all Rays.

Definition at line 172 of file RayTracingStudy.h.

Referenced by RayTracingStudyResult::getValue().

172 { return _total_distance; }

RayTracingStudy::_total_distance

Real _total_distance

Total distance traveled by all Rays.

Definition: RayTracingStudy.h:1123

◆ totalIntersections()

unsigned long long int RayTracingStudy::totalIntersections ( ) const

inlineinherited

Total number of Ray/element intersections.

Definition at line 155 of file RayTracingStudy.h.

155 { return _total_intersections; }

RayTracingStudy::_total_intersections

unsigned long long int _total_intersections

Total number of Ray/element intersections.

Definition: RayTracingStudy.h:1114

◆ totalProcessorCrossings()

unsigned long long int RayTracingStudy::totalProcessorCrossings ( ) const

inlineinherited

Total number of processor crossings.

Definition at line 138 of file RayTracingStudy.h.

Referenced by RayTracingStudyResult::getValue().

138 { return _total_processor_crossings; }

RayTracingStudy::_total_processor_crossings

unsigned long long int _total_processor_crossings

Total number of processor crossings.

Definition: RayTracingStudy.h:1103

◆ totalVolume()

Real RayTracingStudy::totalVolume ( ) const

inlineinherited

Get the current total volume of the domain.

Definition at line 437 of file RayTracingStudy.h.

Referenced by RayTracingStudy::isRectangularDomain().

437 { return _total_volume; }

RayTracingStudy::_total_volume

Real _total_volume

The total volume of the domain.

Definition: RayTracingStudy.h:1066

◆ 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.

Referenced by BackfaceCullingStudyTest::BackfaceCullingStudyTest().

647 { return *_threaded_trace_ray[tid]; }

RayTracingStudy::_threaded_trace_ray

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

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

Definition: RayTracingStudy.h:1077

◆ traceRay() [2/2]

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

inlineinherited

Definition at line 648 of file RayTracingStudy.h.

648 { return *_threaded_trace_ray[tid]; }

RayTracingStudy::_threaded_trace_ray

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

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

Definition: RayTracingStudy.h:1077

◆ useRayRegistration()

bool RayTracingStudy::useRayRegistration ( ) const

inlineinherited

Whether or not ray registration is being used.

Definition at line 564 of file RayTracingStudy.h.

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

564 { return _use_ray_registration; }

RayTracingStudy::_use_ray_registration

const bool _use_ray_registration

Whether or not to use Ray registration.

Definition: RayTracingStudy.h:872

◆ validParams()

InputParameters ConeRayStudy::validParams ( )

static

Definition at line 18 of file ConeRayStudy.C.

 {
   auto params = RepeatableRayStudyBase::validParams();
 
   params.addClassDescription(
       "Ray study that spawns Rays in the direction of a cone from a given set of starting points.");
 
   params.addRequiredParam<std::vector<Point>>("start_points", "The point(s) of the cone(s).");
   params.addRequiredParam<std::vector<Point>>(
       "directions", "The direction(s) of the cone(s) (points down the center of each cone).");
   params.addParam<std::vector<Real>>("scaling_factors",
                                      "Scaling factors for each cone (if any). Defaults to 1.");
 
   params.addRequiredParam<std::vector<Real>>("half_cone_angles",
                                              "Angle of the half-cones in degrees (must be <= 90)");
   params.addParam<std::vector<unsigned int>>(
       "polar_quad_orders",
       "Order of the polar quadrature for each cone. Polar angle is between ray and the "
       "cone direction. Must be positive. This will default to 2 for all cones if not provided.");
   params.addParam<std::vector<unsigned int>>(
       "azimuthal_quad_orders",
       "Order of the azimuthal quadrature per quadrant for each cone. The azimuthal angle is "
       "measured in a plane perpendicular to the cone direction. This will default to 30 if not "
       "provided. Must be positive.");
 
   params.addRequiredParam<std::string>("ray_data_name",
                                        "The name of the Ray data that the angular quadrature "
                                        "weights and factors will be filled into for "
                                        "properly weighting the line source per Ray.");
 
   // Here we will not use Ray registration because we create so many Rays that
   // we don't want to keep track of them by name
   params.set<bool>("_use_ray_registration") = false;
 
   return params;
 }

◆ 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.

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

654 { return _verify_rays; }

RayTracingStudy::_verify_rays

const bool _verify_rays

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

Definition: RayTracingStudy.h:893

◆ 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.

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

659 { return _verify_trace_intersections; }

RayTracingStudy::_verify_trace_intersections

const bool _verify_trace_intersections

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

Definition: RayTracingStudy.h:896

◆ 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 1419 of file RayTracingStudy.C.

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

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

◆ 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 1491 of file RayTracingStudy.C.

Referenced by RayTracingStudy::executeStudy().

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

◆ 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.

673 { return _warn_non_planar; }

RayTracingStudy::_warn_non_planar

const bool _warn_non_planar

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

Definition: RayTracingStudy.h:870

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().

◆ _azimuthal_quad_orders

const std::vector<unsigned int> ConeRayStudy::_azimuthal_quad_orders

protected

The azimuthal quadrature orders for each cone.

Definition at line 40 of file ConeRayStudy.h.

Referenced by ConeRayStudy(), and defineRays().

◆ _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().

◆ _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().

◆ _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> ConeRayStudy::_directions

protected

The directions that define the cones (points down the center of the cone)

Definition at line 31 of file ConeRayStudy.h.

Referenced by ConeRayStudy(), and defineRays().

◆ _half_cone_angles

const std::vector<Real> ConeRayStudy::_half_cone_angles

protected

The half-cone angles in degrees for each cone.

Definition at line 36 of file ConeRayStudy.h.

Referenced by ConeRayStudy(), and defineRays().

◆ _mesh

MooseMesh& RayTracingStudy::_mesh

protectedinherited

The Mesh.

Definition at line 861 of file RayTracingStudy.h.

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

◆ _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 RepeatableRayStudyBaseTest::defineRays(), LotsOfRaysRayStudy::defineRays(), RayTracingStudyTest::generateRays(), StationaryRayStudyTest::generateRays(), ViewFactorRayStudy::generateStartElems(), RayTracingStudy::resetUniqueRayIDs(), RepeatableRayStudyBase::verifyReplicatedRays(), and RayTracingStudy::verifyUniqueRayIDs().

◆ _polar_quad_orders

const std::vector<unsigned int> ConeRayStudy::_polar_quad_orders

protected

The polar quadrature orders for each cone.

Definition at line 38 of file ConeRayStudy.h.

Referenced by ConeRayStudy(), and defineRays().

◆ _ray_data_index

const RayDataIndex ConeRayStudy::_ray_data_index

protected

The index into the Ray's data for storing the angular quadrature weight and scaling factor.

Definition at line 43 of file ConeRayStudy.h.

Referenced by defineRays().

◆ _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(), RepeatableRayStudyBaseTest::defineRays(), defineRays(), RepeatableRayStudy::defineRays(), RepeatableRayStudyBase::defineRaysInternal(), RepeatableRayStudyBase::meshChanged(), TestRayDataStudy::modifyRays(), and RepeatableRayStudyBase::verifyReplicatedRays().

◆ _scaling_factors

const std::vector<Real> ConeRayStudy::_scaling_factors

protected

Scaling factors for each cone's Rays (defaults to 1)

Definition at line 33 of file ConeRayStudy.h.

Referenced by ConeRayStudy(), and defineRays().

◆ _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_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().

◆ _start_points

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

protected

The points to start the Rays from (the cone points)

Definition at line 29 of file ConeRayStudy.h.

Referenced by ConeRayStudy(), and defineRays().

◆ _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().

◆ _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::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/include/userobjects/ConeRayStudy.h
ray_tracing/src/userobjects/ConeRayStudy.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ConeRayStudy()

Member Function Documentation

◆ acquireCopiedRay()

◆ acquireRay()

◆ acquireRayDuringTrace()

◆ acquireRayInternal()

◆ acquireRegisteredRay()

◆ acquireReplicatedRay()

◆ acquireUnsizedRay()

◆ auxDataOnCacheTraces()

◆ bankRaysOnCompletion()

◆ boundingBox()

◆ buildSegmentQuadrature()

◆ computeTotalVolume()

◆ currentlyGenerating()

◆ currentlyPropagating()

◆ currentRayKernels()

◆ currentRayKernelsWrite()

◆ dataOnCacheTraces()

◆ defineRays()

◆ domainMaxLength()

◆ elemSide()

◆ endingDistance()

◆ endingIntersections()

◆ endingMaxIntersections()

◆ endingMaxProcessorCrossings()

◆ endingProcessorCrossings()

◆ execute()

◆ executeStudy()

◆ executionTime()

◆ executionTimeNano()

◆ finalize()

◆ generateRays()

◆ generateReplicatedRayID()

◆ generateUniqueRayID()

◆ generationTime()

◆ getBankedRay()

◆ getBankedRayAuxData()

◆ getBankedRayData()

◆ getCachedTraces()

◆ getElemNormals()

◆ getInternalSidesets() [1/2]

◆ getInternalSidesets() [2/2]

◆ getRayAuxDataIndex()

◆ getRayAuxDataIndices()

◆ getRayAuxDataName()

◆ getRayAuxDataNames()

◆ getRayBCs() [1/4]

◆ getRayBCs() [2/4]

◆ getRayBCs() [3/4]

◆ getRayBCs() [4/4]

◆ getRayDataIndex()

◆ getRayDataIndices()

◆ getRayDataName()

◆ getRayDataNames()

◆ getRayKernels() [1/3]

◆ getRayKernels() [2/3]

◆ getRayKernels() [3/3]

◆ getRayTracingObjects()

◆ getSideNormal()

◆ hasInternalSidesets()

◆ hasRayAuxData()

◆ hasRayData()

◆ hasRayKernels()

◆ hasSameLevelActiveElems()

◆ initialize()

◆ initialSetup()

◆ initThreadedCachedTrace()

◆ isRectangularDomain()