Probability and Cross Section

_incident_flux(in_psp::InPhaseSpacePoint{PROC,MODEL}) where {
    PROC <: AbstractProcessDefinition,
    MODEL <: AbstractModelDefinition,
}

Interface function which returns the incident flux of the given scattering process for a given InPhaseSpacePoint.

_matrix_element(PhaseSpacePoint{PROC,MODEL}) where {
    PROC <: AbstractProcessDefinition,
    MODEL <: AbstractModelDefinition,
}

Interface function which returns an SVector of scattering matrix elements for each spin and polarization combination of proc. Any of this function, _matrix_element_square, or [_matrix_element_square_sum] have to be implemented for a process and model.

_matrix_element_square(psp::AbstractPhaseSpacePoint)

Function that returns an SVector of squared matrix elements for the given AbstractPhaseSpacePoint. This function has a default implementation that uses _matrix_element and can be implemented instead of that function.

_matrix_element_square_sum(psp::AbstractPhaseSpacePoint)

Function that returns the sum of squared matrix elements for a given AbstractPhaseSpacePoint. This function has a default implementation that uses _matrix_element_square and can be implemented instead of that function.

differential_probability(phase_space_point::AbstractPhaseSpacePoint)

If the given phase spaces are physical, return differential probability evaluated on a phase space point. Zero otherwise.

unsafe_differential_probability(phase_space_point::AbstractPhaseSpacePoint)

Return differential probability evaluated on a phase space point without checking if the given phase space(s) are physical.

total_probability(in_psp::AbstractInPhaseSpacePoint)

Return the total probability of a given AbstractInPhaseSpacePoint.

differential_cross_section(phase_space_point::PhaseSpacePoint)

If the given phase spaces are physical, return differential cross section evaluated on a phase space point. Zero otherwise.

unsafe_differential_cross_section(phase_space_point::AbstractPhaseSpacePoint)

Return the differential cross section evaluated on a phase space point without checking if the given phase space is physical.

total_cross_section(in_psp::AbstractInPhaseSpacePoint)

Return the total cross section for a given AbstractInPhaseSpacePoint.

function differential_probability!(
    dest::AbstractVector,
    phase_space_points::AbstractVector{<:AbstractPhaseSpacePoint},
)

Vectorized version of differential_probability, writing the differential probability for each element in phase_space_points to the corresponding index in dest.

By default, this calls a generic KernelAbstractions kernel which dispatches to differential_probability, allowing the use of any of its backends (CPU, CUDA, AMDGPU, Metal, oneAPI). This function can be specialized for specific processes. This should only be necessary when there is a specific reason to do so. Generally, implementing the basic process interface (see AbstractProcessDefinition) should be sufficient.

@kernel function differential_probability_kernel!(
    dest::AbstractVector,
    @Const(phase_space_points::AbstractVector{<:AbstractPhaseSpacePoint}),
)

Broadcasting kernel definition using KernelAbstractions.jl for abstract phasespace points. This dispatches to the scalar implementation of differential_probability and expects the given dest to contain the result type of that call on the given phase space points. This function is dispatched to by differential_probability! and should not be specialized (i.e. don't add methods to it). If a different implementation is required, specialize differential_probability! instead.

function unsafe_differential_probability!(
    dest::AbstractVector,
    phase_space_points::AbstractVector{<:AbstractPhaseSpacePoint},
)

Vectorized version of unsafe_differential_probability, writing the differential probability for each element in phase_space_points to the corresponding index in dest.

By default, this calls a generic KernelAbstractions kernel which dispatches to unsafe_differential_probability, allowing the use of any of its backends (CPU, CUDA, AMDGPU, Metal, oneAPI). This function can be specialized for specific processes. This should only be necessary when there is a specific reason to do so. Generally, implementing the basic process interface (see AbstractProcessDefinition) should be sufficient.

@kernel function unsafe_differential_probability_kernel!(
    dest::AbstractVector,
    @Const(phase_space_points::AbstractVector{<:AbstractPhaseSpacePoint}),
)

Broadcasting kernel definition using KernelAbstractions.jl for abstract phasespace points. This dispatches to the scalar implementation of unsafe_differential_probability and expects the given dest to contain the result type of that call on the given phase space points. This function is dispatched to by unsafe_differential_probability! and should not be specialized (i.e. don't add methods to it). If a different implementation is required, specialize unsafe_differential_probability! instead.

function differential_cross_section!(
    dest::AbstractVector,
    phase_space_points::AbstractVector{<:AbstractPhaseSpacePoint},
)

Vectorized version of differential_cross_section, writing the differential cross section for each element in phase_space_points to the corresponding index in dest.

By default, this calls a generic KernelAbstractions kernel which dispatches to differential_cross_section, allowing the use of any of its backends (CPU, CUDA, AMDGPU, Metal, oneAPI). This function can be specialized for specific processes. This should only be necessary when there is a specific reason to do so. Generally, implementing the basic process interface (see AbstractProcessDefinition) should be sufficient.

@kernel function differential_cross_section_kernel!(
    dest::AbstractVector,
    @Const(phase_space_points::AbstractVector{<:AbstractPhaseSpacePoint}),
)

Broadcasting kernel definition using KernelAbstractions.jl for abstract phasespace points. This dispatches to the scalar implementation of differential_cross_section and expects the given dest to contain the result type of that call on the given phase space points. This function is dispatched to by differential_cross_section! and should not be specialized (i.e. don't add methods to it). If a different implementation is required, specialize differential_cross_section! instead.

function unsafe_differential_cross_section!(
    dest::AbstractVector,
    phase_space_points::AbstractVector{<:AbstractPhaseSpacePoint},
)

Vectorized version of unsafe_differential_cross_section, writing the differential cross section for each element in phase_space_points to the corresponding index in dest.

By default, this calls a generic KernelAbstractions kernel which dispatches to unsafe_differential_cross_section, allowing the use of any of its backends (CPU, CUDA, AMDGPU, Metal, oneAPI). This function can be specialized for specific processes. This should only be necessary when there is a specific reason to do so. Generally, implementing the basic process interface (see AbstractProcessDefinition) should be sufficient.

@kernel function unsafe_differential_cross_section_kernel!(
    dest::AbstractVector,
    @Const(phase_space_points::AbstractVector{<:AbstractPhaseSpacePoint}),
)

Broadcasting kernel definition using KernelAbstractions.jl for abstract phasespace points. This dispatches to the scalar implementation of unsafe_differential_cross_section and expects the given dest to contain the result type of that call on the given phase space points. This function is dispatched to by unsafe_differential_cross_section! and should not be specialized (i.e. don't add methods to it). If a different implementation is required, specialize unsafe_differential_cross_section! instead.