Physics classes used inside the optical physics loop. More...

Classes
struct	AbsorptionExecutor

class	AbsorptionInteractor
	Sample optical absorption interaction. More...

class	AbsorptionModel
	Set up and launch the optical absorption model interaction. More...

class	ActionLauncher
	Profile and launch optical stepping loop kernels. More...

class	AlongStepAction
	Move a track to the next boundary or interaction. More...

class	BoundaryAction
	Move a track across a boundary. More...

struct	CherenkovData
	Cherenkov angle integrals tablulated as a function of photon energy. More...

class	CherenkovDndxCalculator
	Calculate the mean number of Cherenkov photons produced per unit length. More...

class	CherenkovGenerator
	Sample Cherenkov photons from the given distribution. More...

class	CherenkovParams
	Build and manage Cherenkov data. More...

class	ConditionalTrackSlotExecutor
	Launch the track only when a certain condition applies. More...

class	CoreParams
	Shared parameters for the optical photon loop. More...

struct	CoreParamsData
	Immutable problem data. More...

struct	CoreScalars
	Memspace-independent core variables. More...

class	CoreState
	Store all state data for a single thread. More...

struct	CoreStateData
	Thread-local state data. More...

class	CoreStateInterface
	Interface class for optical state data. More...

class	CoreTrackView
	Access all core properties of a physics track. More...

class	DiscreteSelectAction
	Select a model for tracks undergoing a discrete interaction. More...

struct	DiscreteSelectExecutor

struct	GeneratorDistributionData
	Input data for sampling optical photons. More...

struct	GeneratorStepData
	Pre- and post-step data for sampling optical photons. More...

class	ImportedMaterials
	Imported material data for optical models. More...

class	ImportedModelAdapter
	An adapter for imported model data corresponding to a specific identifier. More...

class	ImportedModels
	A collection of imported optical models. More...

class	InitializeTracksAction
	Initialize optical track states. More...

struct	Interaction
	The result of a discrete optical interaction. More...

struct	InteractionApplier
	This class is partially specialized with a second template argument to extract any launch bounds from the functor class. More...

struct	InteractionApplier< F, std::enable_if_t< kernel_max_blocks< F > > >

struct	InteractionApplier< F, std::enable_if_t< kernel_max_blocks_min_warps< F > > >

struct	InteractionApplierBaseImpl
	Wrap an interaction executor and apply it to a track. More...

class	LocateVacanciesAction
	Find the vacant track slots at the end of the step. More...

class	MaterialParams
	Manage properties for optical materials. More...

struct	MaterialParamsData
	Shared optical material properties. More...

class	MaterialView
	Access optical material properties. More...

struct	MatScintSpectrumRecord
	Material-dependent scintillation spectrum. More...

class	MfpBuilder
	Helper class for optical models to build MFP tables. More...

class	Model
	Base class for discrete, volumetric optical models. More...

class	ModelImporter
	Construct Celeritas optical model builders from imported data. More...

struct	ParScintSpectrumRecord
	Particle- and material-dependent scintillation spectrum. More...

struct	ParticleStateData
	Storage for dynamic particle data. More...

class	ParticleTrackView
	Properties of a single optical photon. More...

class	PhysicsParams

struct	PhysicsParamsData
	Persistent shared optical physics data. More...

struct	PhysicsParamsScalars
	Scalar quantities used by optical physics. More...

struct	PhysicsStateData
	Dynamic optical physics state data. More...

class	PhysicsTrackView
	Optical physics data for a track. More...

class	PreStepAction
	Set up the beginning of a physics step. More...

struct	RayleighExecutor

class	RayleighInteractor
	Sample optical Rayleigh scattering. More...

class	RayleighMfpCalculator
	Calculate the Rayleigh MFP for a given set of material properties. More...

class	RayleighModel
	Set up and launch the optical Rayleigh scattering model interaction. More...

struct	ScintillationData
	Data characterizing the scintillation spectrum for all particles and materials. More...

class	ScintillationGenerator
	Sample scintillation photons from optical property data and step data. More...

class	ScintillationParams
	Build and manage scintillation data. More...

struct	ScintRecord
	Parameterized scintillation properties. More...

struct	SimStateData
	Storage for dynamic simulation data. More...

class	SimTrackView
	Simulation properties for a single track. More...

class	TrackingCutAction
	Kill misbehaving photons and deposit energy locally. More...

struct	TrackInitializer
	Optical photon data used to initialize a photon track state. More...

class	TrackInitParams
	Manage persistent track initializer data. More...

struct	TrackInitParamsData
	Persistent data for optical track initialization. More...

struct	TrackInitStateData
	Storage for dynamic data used to initialize new optical photon tracks. More...

class	TrackSlotExecutor
	Transform a thread or track slot ID into a core track view. More...

struct	WarnAndIgnoreModel
	Warn about a missing optical model and deliberately skip it. More...

struct	WavelengthShiftData
	Wavelength shift data. More...

class	WavelengthShiftInteractor
	Apply the wavelength shift (WLS) to optical photons. More...

class	WavelengthShiftParams
	Build and manage wavelength shift (WLS) data. More...

struct	WlsMaterialRecord
	Material dependent scalar property of wavelength shift (WLS). More...

Typedefs
using	OpticalBeginRunActionInterface = BeginRunActionInterface< CoreParams, CoreState >
	Interface called at beginning of the core stepping loop.

using	OpticalStepActionInterface = StepActionInterface< CoreParams, CoreState >
	Action interface for core stepping loop.

template<MemSpace M>
using	CoreParamsPtr = CRefPtr< CoreParamsData, M >

template<MemSpace M>
using	CoreStatePtr = RefPtr< CoreStateData, M >

using	ValueGrid = NonuniformGridRecord

using	ValueGridId = OpaqueId< ValueGrid >

using	CoreMaterialId = ::celeritas::MaterialId
	Alias for MaterialId in core Celeritas namespace.

Enumerations
enum class	ImportModelClass { absorption , rayleigh , wls , size_ }
	Enumerator for available optical physics models. More...

Functions
char const *	to_cstring (ImportModelClass imc)

template<class F >
void	launch_action (CoreState< MemSpace::host > &state, F &&execute_thread)
	Helper function to run an action in parallel on CPU over all states.

template<class T >
CELER_FUNCTION	TrackSlotExecutor (CoreParamsPtr< MemSpace::native >, CoreStatePtr< MemSpace::native >, T &&) -> TrackSlotExecutor< T >

template<class C , class T >
CELER_FUNCTION	ConditionalTrackSlotExecutor (CoreParamsPtr< MemSpace::native >, CoreStatePtr< MemSpace::native >, C &&, T &&) -> ConditionalTrackSlotExecutor< C, T >

template<class T >
CELER_FUNCTION decltype(auto)	make_active_thread_executor (CoreParamsPtr< MemSpace::native > params, CoreStatePtr< MemSpace::native > const &state, T &&apply_track)
	Return a track executor that only applies to active, non-errored tracks.

template<class T >
CELER_FUNCTION decltype(auto)	make_action_thread_executor (CoreParamsPtr< MemSpace::native > params, CoreStatePtr< MemSpace::native > state, ActionId action, T &&apply_track)
	Return a track executor that only applies if the action ID matches.

template<MemSpace M>
void	resize (CoreStateData< Ownership::value, M > *state, HostCRef< CoreParamsData > const &params, StreamId stream_id, size_type size)
	Resize states in host code.

template void	resize< MemSpace::host > (CoreStateData< Ownership::value, MemSpace::host > *, HostCRef< CoreParamsData > const &, StreamId, size_type)

template void	resize< MemSpace::device > (CoreStateData< Ownership::value, MemSpace::device > *, HostCRef< CoreParamsData > const &, StreamId, size_type)

template<class F >
CELER_FUNCTION	InteractionApplier (F &&) -> InteractionApplier< F >

template<MemSpace M>
void	resize (ParticleStateData< Ownership::value, M > *data, size_type size)
	Resize particle states.

template<MemSpace M>
void	resize (PhysicsStateData< Ownership::value, M > *state, size_type size)
	Resize the state in host code.

CELER_FUNCTION StepLimit	calc_physics_step_limit (ParticleTrackView const &particle, PhysicsTrackView &physics)
	Calculate the discrete physics step limit for the given track.

template<class Engine >
CELER_FUNCTION ActionId	select_discrete_interaction (ParticleTrackView const &particle, PhysicsTrackView const &physics, Engine &rng)
	Randomly sample a discrete interaction by their cross sections.

template<MemSpace M>
void	resize (SimStateData< Ownership::value, M > *data, size_type size)
	Resize simulation states and set `alive` to be false.

template<MemSpace M>
void	resize (TrackInitStateData< Ownership::value, M > *data, HostCRef< TrackInitParamsData > const &params, StreamId stream, size_type size)
	Resize and initialize data.

Detailed Description

Physics classes used inside the optical physics loop.

Interface classes that integrate with the main Celeritas stepping loop are in the main namespace.

Enumeration Type Documentation

◆ ImportModelClass

enum class celeritas::optical::ImportModelClass

strong

Enumerator for available optical physics models.

This enum is used to identify the optical model that imported model MFP tables correspond to.

Function Documentation

◆ calc_physics_step_limit()

CELER_FUNCTION StepLimit celeritas::optical::calc_physics_step_limit	(	ParticleTrackView const &	particle,
		PhysicsTrackView &	physics
	)

inline

Calculate the discrete physics step limit for the given track.

The total cross section is cached in the PhysicsTrackView.

◆ launch_action()

template<class F >

void celeritas::optical::launch_action	(	CoreState< MemSpace::host > &	state,
		F &&	execute_thread
	)

Helper function to run an action in parallel on CPU over all states.

Example:

void FooAction::step(CoreParams const& params,
                     CoreStateHost& state) const
{
   launch_action(state, make_blah_executor(params, state, blah));
}

◆ make_action_thread_executor()

template<class T >

CELER_FUNCTION decltype(auto) celeritas::optical::make_action_thread_executor	(	CoreParamsPtr< MemSpace::native >	params,
		CoreStatePtr< MemSpace::native >	state,
		ActionId	action,
		T &&	apply_track
	)

inline

Return a track executor that only applies if the action ID matches.

Note: This should generally only be used for post-step actions and other cases where the IDs explicitly are set. Many explicit actions apply to all threads, active or not.

◆ resize() [1/2]

template<MemSpace M>

void celeritas::optical::resize	(	CoreStateData< Ownership::value, M > *	state,
		HostCRef< CoreParamsData > const &	params,
		StreamId	stream_id,
		size_type	size
	)

Resize states in host code.

Initialize threads to track slots mapping. Resize core states using parameter data, stream ID, and track slots.

◆ resize() [2/2]

template<MemSpace M>

void celeritas::optical::resize	(	TrackInitStateData< Ownership::value, M > *	data,
		HostCRef< TrackInitParamsData > const &	params,
		StreamId	stream,
		size_type	size
	)

Resize and initialize data.

Here size is the number of track states, and the "capacity" is the maximum number of initializers that can be buffered.

◆ select_discrete_interaction()

template<class Engine >

CELER_FUNCTION ActionId celeritas::optical::select_discrete_interaction	(	ParticleTrackView const &	particle,
		PhysicsTrackView const &	physics,
		Engine &	rng
	)

Randomly sample a discrete interaction by their cross sections.

Should be performed after discrete select action has reset the MFP, and the macroscopic cross sections have been built.

Classes

Typedefs

Enumerations

Functions