API Reference

QEDprocesses.Compton — Type

Compton(
    in_spin [= AllSpin()]
    in_pol [= AllPol()]
    out_spin [= AllSpin()]
    out_pol [= AllPol()]
)

source

QEDprocesses.ScatteringProcess — Type

ScatteringProcess <: AbstractProcessDefinition

Generic implementation for scattering processes of arbitrary particles. Currently, only calculations in combination with PerturbativeQED are supported. However, this is supposed to describe scattering processes with any number of incoming and outgoing particles, and any combination of spins or polarizations for the particles.

The isphysical function can be used to check whether the process is possible in perturbative QED.

Constructors

ScatteringProcess(
    in_particles::Tuple{AbstractParticleType},
    out_particles::Tuple{AbstractParticleType},
    [in_sp::Tuple{AbstractSpinOrPolarization},
    out_sp::Tuple{AbstractSpinOrPolarization}]
)

Constructor for a ScatteringProcess with the given incoming and outgoing particles and their respective spins and pols. The constructor asserts that the particles are compatible with their respective spins and polarizations. If the assertion fails, an InvalidInputError is thrown.

The in_sp and out_sp parameters can be omitted in which case all spins and polarizations will be set to AllSpin and AllPol for every fermion and boson, respectively.

source

QEDbase._averaging_norm — Method

_averaging_norm(::Type{<:Number}, proc::Compton)

Convention

We average over the initial spins and pols, and sum over final.

source

QEDbase.in_phase_space_dimension — Method

in_phase_space_dimension(proc::AbstractProcessDefinition, ::PerturbativeQED)

Return the number of degrees of freedom to determine the incoming phase space for processes in PerturbativeQED.

Convention

The current implementation only supports the case where two of the incoming particles collide head-on.

source

QEDprocesses._base_component_type — Method

_base_component_type(array_of_lv::AbstractArray{LV}) where {LV<:AbstractLorentzVector}

Return the type of the components of given Lorentz vectors, which are by themselves elements of an AbstractArray.

Examples

julia> using QEDbase
julia> using QEDprocesses
julia> v = Vector{SFourMomentum}(undef,10)
julia> QEDprocesses._base_component_type(v)
Float64

source

QEDprocesses._diff_cs_kernel — Method

_diff_cs_kernel(proc::ScatteringProcess, ::Type{PSP})

Returns a generated KernelAbstractions.jl kernel ready to be called to compute differential cross sections on any of KernelAbstractions.jl's backends. The function signature is diff_cs(out::AbstractVector{FLOAT_T}, in::AbstractVector{PhaseSpacePoint{...}}), where the phase space point must be of type PSP and its underlying float type must be convertible to FLOAT_T.

Note

This function is memoized so it will cache the result for a unique set of arguments and not reevaluate.

See also: _diff_cs_kernel

source

QEDprocesses._generic_proc_graph — Method

_generic_proc_graph(proc::ScatteringProcess, target::Symbol)

Returns the generated DAG for the given ScatteringProcess and the specific target, one of :mat_el_sqsum, :diff_prob, :diff_cs.

Note

This function is memoized so it will cache the result for a unique set of arguments and not reevaluate.

source

QEDprocesses._mat_el_sq_sum_func — Method

_mat_el_sq_sum_func(proc::ScatteringProcess, ::Type{PSP})

Returns the generated compute function ready to be called on a PhaseSpacePoint::PSP, returning the square sum of matrix elements.

Note

This function is memoized so it will cache the result for a unique set of arguments and not reevaluate.

source

QEDprocesses.isphysical — Method

isphysical(proc::AbstractProcessDefinition, model::PerturbativeQED)

A utility function that returns whether a given AbstractProcessDefinition is valid in tree-level perturbative QED, i.e., whether it has at least one tree-level Feynman diagram.

source