QEDbase

AbstractCoordinateSystem

TBW

Abstract base type for definite polarization of particles with is_boson.

Concrete types are PolarizationX and PolarizationY.

Abstract base type for definite spins of particles with is_fermion.

Concrete types are SpinUp and SpinDown.

abstract type AbstractDiracMatrix{T} <: StaticArraysCore.FieldMatrix{4, 4, T}

Abstract type for Dirac matrices, i.e. matrix representations for linear mappings from a spinor space into another.

abstract type AbstractDiracVector{T} <: StaticArraysCore.FieldVector{4, T}

Abstract type for Dirac vectors, e.g. four dimensional vectors from a spinor space.

AbstractFourMomentum

Abstract base type for four-momentas, representing one energy and three spacial components.

Also see: QEDcore.SFourMomentum, QEDcore.MFourMomentum

AbstractFrameOfReference

TBW

AbstractInPhaseSpacePoint

A partial type specialization on AbstractPhaseSpacePoint which can be used for dispatch in functions requiring only the in channel of the phase space to exist, for example implementations of _incident_flux. No restrictions are imposed on the out-channel, which may or may not exist.

See also: AbstractOutPhaseSpacePoint

Abstract base type for indefinite polarization of particles with is_boson.

One concrete type is AllPolarization.

Abstract base type for indefinite spins of particles with is_fermion.

One concrete type is AllSpin.

Abstract base type for exceptions indicating invalid input. See InvalidInputError for a simple concrete implementation. Concrete implementations should at least implement

Base.showerror(io::IO, err::CustomInvalidError) where {CustomInvalidError<:AbstractInvalidInputException}

abstract type AbstractLorentzVector{T} <: StaticArraysCore.FieldVector{4, T}

Abstract type to model generic Lorentz vectors, i.e. elements of a minkowski-like space, where the component space is arbitray.

Abstract base type for all compute model definitions in the context of scattering processes. Every subtype of AbstractModelDefinition is associated with a fundamental interaction. Therefore, one needs to implement the following soft interface function

fundamental_interaction_type(::AbstractModelDefinition)

AbstractOutPhaseSpacePoint

A partial type specialization on AbstractPhaseSpacePoint which can be used for dispatch in functions requiring only the out channel of the phase space to exist. No restrictions are imposed on the in-channel, which may or may not exist.

See also: AbstractInPhaseSpacePoint

Abstract base type for every type which might be considered a particle in the context of QED.jl. For every (concrete) subtype of AbstractParticle, there are two kinds of interface functions implemented: static functions and property functions. The static functions provide information on what kind of particle it is (defaults are written in square brackets)

    is_fermion(::AbstractParticle)::Bool [= false]
    is_boson(::AbstractParticle)::Bool [= false]
    is_particle(::AbstractParticle)::Bool [= true]
    is_anti_particle(::AbstractParticle)::Bool [= false]

If the output of those functions differ from the defaults for a subtype of AbstractParticle, these functions need to be overwritten. The second type of functions define a hard interface for AbstractParticle:

    mass(::AbstractParticle)::Real
    charge(::AbstractParticle)::Real

These functions must be implemented in order to have the subtype of AbstractParticle work with the functionalities of QEDprocesses.jl.

AbstractParticleStateful <: QEDbase.AbstractParticle

Abstract base type for the representation of a particle with a state. It requires the following interface functions to be provided:

• particle_direction: Returning the particle's direction.
• particle_species: Returning the particle's species.
• momentum: Returning the particle's momentum.

Implementations for is_fermion, is_boson, is_particle, is_anti_particle, is_incoming, is_outgoing, mass, and charge are automatically provided using the interface functions above to fulfill the QEDbase.AbstractParticle interface.

AbstractParticleType <: AbstractParticle

This is the abstract base type for every species of particles. All functionalities defined on subtypes of AbstractParticleType should be static, i.e. known at compile time. For adding runtime information, e.g. four-momenta or particle states, to a particle, consider implementing a concrete subtype of AbstractParticle instead, which may have a type parameter P<:AbstractParticleType.

Concrete built-in subtypes of AbstractParticleType are available in QEDcore.jl and should always be singletons..

AbstractPhaseSpacePoint{PROC, MODEL, PSDEF, IN_PARTICLES, OUT_PARTICLES}

Representation of a point in the phase space of a process. It has several template arguments:

• PROC <:AbstractProcessDefinition
• MODEL <:AbstractModelDefinition
• PSDEF <:AbstractPhasespaceDefinition
• IN_PARTICLES <:Tuple{Vararg{AbstractParticleStateful}}: The tuple type of all the incoming [AbstractParticleStateful`](@ref)s.
• OUT_PARTICLES <:Tuple{Vararg{AbstractParticleStateful}}: The tuple type of all the outgoing [AbstractParticleStateful`](@ref)s.

The following interface functions must be provided:

• Base.getindex(psp::AbstractPhaseSpacePoint, dir::ParticleDirection, n::Int): Return the nth AbstractParticleStateful of the given direction. Throw BoundsError for invalid indices.
• particles(psp::AbstractPhaseSpacePoint, dir::ParticleDirection): Return the particle tuple (type IN_PARTICLES or OUT_PARTICLES depending on dir)
• process: Return the process.
• model: Return the model.
• phase_space_definition: Return the phase space definition.

From this, the following functions are automatically derived:

• momentum(psp::AbstractPhaseSpacePoint, dir::ParticleDirection, n::Int): Return the momentum of the nth AbstractParticleStateful of the given direction.
• momenta(psp::PhaseSpacePoint, ::ParticleDirection): Return a Tuple of all the momenta of the given direction.

Furthermore, an implementation of an AbstractPhaseSpacePoint has to verify on construction that it is valid, i.e., the following conditions are fulfilled:

• IN_PARTICLES must match incoming_particles(::PROC) in length, order, and type or be an empty Tuple.
• OUT_PARTICLES must match the outgoing_particles(::PROC) in length, order, and type, or be an empty Tuple.
• IN_PARTICLES and OUT_PARTICLES may not both be empty.

If IN_PARTICLES is non-empty, AbstractPhaseSpacePoint <: AbstractInPhaseSpacePoint is true. Likewise, if OUT_PARTICLES is non-empty, AbstractPhaseSpacePoint <: AbstractOutPhaseSpacePoint is true. Consequently, if both IN_PARTICLES and OUT_PARTICLES are non-empty, both <: statements are true.

AbstractPhasespaceDefinition

TBW

Abstract base type for the polarization of particles with is_boson.

Abstract base type for definitions of scattering processes. It is the root type for the process interface, which assumes that every subtype of AbstractProcessDefinition implements at least

incoming_particles(proc_def::AbstractProcessDefinition)
outgoing_particles(proc_def::AbstractProcessDefinition)

which return a tuple of the incoming and outgoing particles, respectively.

Furthermore, to calculate scattering probabilities and differential cross sections, the following interface functions need to be implemented for every combination of CustomProcess<:AbstractProcessDefinition, CustomModel<:AbstractModelDefinition, and CustomPhasespaceDefinition<:AbstractPhasespaceDefinition.

    _incident_flux(psp::InPhaseSpacePoint{CustomProcess,CustomModel})

    _matrix_element(psp::PhaseSpacePoint{CustomProcess,CustomModel})

    _averaging_norm(proc::CustomProcess)

    _is_in_phasespace(psp::PhaseSpacePoint{CustomProcess,CustomModel})

    _phase_space_factor(psp::PhaseSpacePoint{CustomProcess,CustomModel,CustomPhasespaceDefinition})

Optional is the implementation of

    _total_probability(psp::PhaseSpacePoint{CustomProcess,CustomModel,CustomPhasespaceDefinition})

to enable the calculation of total probabilities and cross sections.

Abstract base type for the spin of particles with is_fermion.

Abstract base type for the spin or polarization of particles with is_fermion or is_boson, respectively.

Concrete type indicating that a particle with is_boson has an indefinite polarization and the differential cross section calculation should average or sum over all polarizations, depending on the direction (Incoming or Outgoing) of the particle in question.

julia> using QEDbase

julia> AllPol()
all polarizations

julia> using QEDbase

julia> AllPolarization === AllPol
true

Concrete type indicating that a particle with is_fermion has an indefinite spin and the differential cross section calculation should average or sum over all spins, depending on the direction (Incoming or Outgoing) of the particle in question.

julia> using QEDbase

julia> AllSpin()
all spins

Incoming <: ParticleDirection

Concrete implementation of a ParticleDirection to indicate that a particle is incoming in the context of a given process. Mostly used for dispatch.

julia> using QEDbase

julia> Incoming()
incoming

is_incoming(::Incoming) = true
is_outgoing(::Incoming) = false

InvalidInputError(msg::String)

Exception which is thrown if a function input is invalid.

Outgoing <: ParticleDirection

Concrete implementation of a ParticleDirection to indicate that a particle is outgoing in the context of a given process. Mostly used for dispatch.

julia> using QEDbase

julia> Outgoing()
outgoing

is_incoming(::Outgoing) = false
is_outgoing(::Outgoing) = true

Abstract base type for the directions of particles in the context of processes, i.e. either they are incoming or outgoing. Subtypes of this are mostly used for dispatch.

Concrete type which indicates, that a particle with is_boson has polarization in $x$-direction.

julia> using QEDbase

julia> PolX()
x-polarized

julia> using QEDbase

julia> PolarizationX === PolX
true

Concrete type which indicates, that a particle with is_boson has polarization in $y$-direction.

julia> using QEDbase

julia> PolY()
y-polarized

julia> using QEDbase

julia> PolarizationY === PolY
true

struct RegistryError <: Exception

Exception raised, if a certain type target_type can not be registed for a certain interface, since there needs the function func to be impleemnted.

Fields

• func::Function

• target_type::Any

Concrete type indicating that a particle with is_fermion has spin-down.

julia> using QEDbase

julia> SpinDown()
spin down

Concrete type indicating that a particle with is_fermion has spin-up.

julia> using QEDbase

julia> SpinUp()
spin up

UnknownDirection <: ParticleDirection

Concrete implementation of a ParticleDirection to indicate that a particle has an unknown direction. This can mean that a specific direction does not make sense in the given context, that the direction is unavailable, or that it is unnecessary.

julia> using QEDbase

julia> UnknownDirection()
unknown direction

is_incoming(::UnknownDirection) = false
is_outgoing(::UnknownDirection) = false

_as_svec(x)

Accepts a single object, an SVector of objects or a tuple of objects, and returns them in a single "layer" of SVector.

Useful with base_state.

_averaging_norm(proc::AbstractProcessDefinition)

Interface function, which returns a normalization for the averaging of the squared matrix elements over spins and polarizations.

_generate_incoming_momenta(
    proc::AbstractProcessDefinition,
    model::AbstractModelDefinition,
    phase_space_def::AbstractPhasespaceDefinition,
    in_phase_space::NTuple{N,T},
) where {N,T<:Real}

Interface function to generate the four-momenta of the incoming particles from coordinates for a given phase-space definition.

_generate_momenta(
    proc::AbstractProcessDefinition,
    model::AbstractModelDefinition,
    phase_space_def::AbstractPhasespaceDefinition,
    in_phase_space::NTuple{N,T},
    out_phase_space::NTuple{M,T},
) where {N,M,T<:Real}

Return four-momenta for incoming and outgoing particles for given coordinate based phase-space points.

_generate_outgoing_momenta(
    proc::AbstractProcessDefinition,
    model::AbstractModelDefinition,
    phase_space_def::AbstractPhasespaceDefinition,
    in_phase_space::NTuple{N,T},
    out_phase_space::NTuple{M,T},
) where {N,M,T<:Real}

Interface function to generate the four-momenta of the outgoing particles from coordinates for a given phase-space definition.

_hasmethod_registry(fun, _)

Wrapper around Base.hasmethod with a more meaningful error message in the context of function registration.

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

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

Interface function which returns true if the combination of the given incoming and outgoing phase space is physical, i.e. all momenta are on-shell and some sort of energy-momentum conservation holds.

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

Interface function which returns a tuple of scattering matrix elements for each spin and polarization combination of proc.

_phase_space_factor(PhaseSpacePoint{PROC,MODEL,PSDEF}) where {
    PROC <: AbstractProcessDefinition,
    MODEL <: AbstractModelDefinition
    PSDEF <: AbstractPhasespaceDefinition,
}

Interface function, which returns the pre-differential factor of the invariant phase space intergral measure.

where $H(\dots)$ is a characteristic function (or distribution) which constrains the phase space, e.g. $\delta^{(4)}(P_t - \sum_i p_i)$.

_spin_index(_::AbstractDefiniteSpin) -> Int64

Utility function, which converts subtypes of AbstractDefiniteSpin into an integer representation, e.g. an index:

• SpinUp $\rightarrow 1$
• SpinDown $\rightarrow 2$

This is useful in the implementation of some of base_state's overloads.

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

Interface function for the combination of a scattering process and a physical model. Return the total of a given process and model for a passed InPhaseSpacePoint.

assert_onshell(mom, mass)

Assertion if a FourMomentum mom is on-shell w.r.t a given mass mass.

    base_state(
        particle::AbstractParticleType,
        direction::ParticleDirection,
        momentum::QEDbase.AbstractFourMomentum,
        [spin_or_pol::AbstractSpinOrPolarization]
    )

Return the base state of a directed on-shell particle with a given four-momentum. For internal usage only.

Input

• particle – the type of the particle, i.e., an instance of an AbstractParticleType, e.g. QEDcore.Electron, QEDcore.Positron, or QEDcore.Photon.
• direction – the direction of the particle, i.e. Incoming or Outgoing.
• momentum – the four-momentum of the particle
• [spin_or_pol] – if given, the spin or polarization of the particle, e.g. SpinUp/SpinDown or PolarizationX/PolarizationY.

Output

The output type of base_state depends on wether the spin or polarization of the particle passed in is specified or not.

If spin_or_pol is passed, the output of base_state is

base_state(::Fermion,     ::Incoming, mom, spin_or_pol) # -> BiSpinor
base_state(::AntiFermion, ::Incoming, mom, spin_or_pol) # -> AdjointBiSpinor
base_state(::Fermion,     ::Outgoing, mom, spin_or_pol) # -> AdjointBiSpinor
base_state(::AntiFermion, ::Outgoing, mom, spin_or_pol) # -> BiSpinor
base_state(::Photon,      ::Incoming, mom, spin_or_pol) # -> SLorentzVector{ComplexF64}
base_state(::Photon,      ::Outgoing, mom, spin_or_pol) # -> SLorentzVector{ComplexF64}

If spin_or_pol is of type AllPolarization or AllSpin, the output is an SVector with both spin/polarization alignments:

base_state(::Fermion,     ::Incoming, mom) # -> SVector{2,BiSpinor}
base_state(::AntiFermion, ::Incoming, mom) # -> SVector{2,AdjointBiSpinor}
base_state(::Fermion,     ::Outgoing, mom) # -> SVector{2,AdjointBiSpinor}
base_state(::AntiFermion, ::Outgoing, mom) # -> SVector{2,BiSpinor}
base_state(::Photon,      ::Incoming, mom) # -> SVector{2,SLorentzVector{ComplexF64}}
base_state(::Photon,      ::Outgoing, mom) # -> SVector{2,SLorentzVector{ComplexF64}}

Example

using QEDbase

mass = 1.0                              # set electron mass to 1.0
px,py,pz = rand(3)                      # generate random spatial components
E = sqrt(px^2 + py^2 + pz^2 + mass^2)   # compute energy, i.e. the electron is on-shell
mom = SFourMomentum(E, px, py, pz)      # initialize the four-momentum of the electron

# compute the state of an incoming electron with spin = SpinUp
# note: base_state is not exported!
electron_state = base_state(QEDcore.Electron(), Incoming(), mom, SpinUp())

julia> using QEDbase; using QEDcore

julia> mass = 1.0; px,py,pz = (0.1, 0.2, 0.3); E = sqrt(px^2 + py^2 + pz^2 + mass^2); mom = SFourMomentum(E, px, py, pz)
4-element SFourMomentum with indices SOneTo(4):
 1.0677078252031311
 0.1
 0.2
 0.3

julia> electron_state = base_state(Electron(), Incoming(), mom, SpinUp())
4-element BiSpinor with indices SOneTo(4):
   1.4379526505428235 + 0.0im
                  0.0 + 0.0im
 -0.20862995724285552 + 0.0im
 -0.06954331908095185 - 0.1390866381619037im

julia> electron_states = base_state(Electron(), Incoming(), mom, AllSpin())
2-element StaticArraysCore.SVector{2, BiSpinor} with indices SOneTo(2):
 [1.4379526505428235 + 0.0im, 0.0 + 0.0im, -0.20862995724285552 + 0.0im, -0.06954331908095185 - 0.1390866381619037im]
 [0.0 + 0.0im, 1.4379526505428235 + 0.0im, -0.06954331908095185 + 0.1390866381619037im, 0.20862995724285552 + 0.0im]

for state in QEDbase._as_svec(base_state(Electron(), Incoming(), momentum, spin))
    # ...
end

charge(::AbstractParticle)::Real

Interface function for particles. Return the electric charge of a particle (in units of the elementary electric charge).

This needs to be implemented for each concrete subtype of AbstractParticle.

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.

differential_probability(phase_space_point::AbstractPhaseSpacePoint)

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

fundamental_interaction_type(models_def::AbstractModelDefinition)

Return the fundamental interaction associated with the passed model definition.

getBeta(lv)

Return magnitude of the beta vector for a given LorentzVectorLike, i.e. the magnitude of the LorentzVectorLike divided by its 0-component.

getCosPhi(lv)

Return the cosine of the phi angle for a given LorentzVectorLike.

getCosTheta(lv)

Return the cosine of the theta angle for a given LorentzVectorLike.

getE(lv)

Return the energy component of a given LorentzVectorLike, i.e. its 0-component.

Function alias for getE.

getGamma(lv)

Return the relativistic gamma factor for a given LorentzVectorLike, i.e. the inverse square root of one minus the beta vector squared.

getInvariantMass(lv)

Return the the invariant mass of a given LorentzVectorLike, i.e. the square root of the minkowski dot with itself.

getInvariantMass2(lv)

Return the squared invariant mass of a given LorentzVectorLike, i.e. the minkowski dot with itself.

Functiom alias for getMagnitude.

Functiom alias for getMagnitude2.

getMagnitude(lv)

Return the magnitude of a given LorentzVectorLike, i.e. the euklidian norm spatial components.

getMagnitude2(lv)

Return the square of the magnitude of a given LorentzVectorLike, i.e. the sum of the squared spatial components.

Function alias for getInvariantMass.

Function alias for getInvariantMass2

getMinus(lv)

Return the minus component for a given LorentzVectorLike in light-cone coordinates.

Function alias for getTransverseMass

Function alias for getTransverseMass2

Function alias for getTransverseMomentum.

Function alias for getTransverseMomentum2.

getPhi(lv)

Return the phi angle for a given LorentzVectorLike, i.e. the azimuthal angle of its spatial components in spherical coordinates.

getPlus(lv)

Return the plus component for a given LorentzVectorLike in light-cone coordinates.

Function alias for getTransverseMomentum.

Function alias for getTransverseMomentum2.

getPx(lv)

Return the $p_x$ component of a given LorentzVectorLike, i.e. its 1-component.

getPy(lv)

Return the $p_y$ component of a given LorentzVectorLike, i.e. its 2-component.

getPz(lv)

Return the $p_z$ component of a given LorentzVectorLike, i.e. its 3-component.

getRapidity(lv)

Return the rapidity for a given LorentzVectorLike.

Function alias for getMagnitude

Function alias for getMagnitude2

getSinPhi(lv)

Return the sine of the phi angle for a given LorentzVectorLike.

getT(lv)

Return the 0-component of a given LorentzVectorLike.

getTheta(lv)

Return the theta angle for a given LorentzVectorLike, i.e. the polar angle of its spatial components in spherical coordinates.

getTransverseMass(lv)

Return the transverse momentum for a given LorentzVectorLike, i.e. the square root of its squared transverse mass.

getTransverseMass2(lv)

Return the squared transverse mass for a given LorentzVectorLike, i.e. the difference of its squared 0- and 3-component.

getTransverseMomentum(lv)

Return the transverse momentum for a given LorentzVectorLike, i.e. the magnitude of its transverse components.

getTransverseMomentum2(lv)

Return the squared transverse momentum for a given LorentzVectorLike, i.e. the sum of its squared 1- and 2-component.

getX(lv)

Return the 1-component of a given LorentzVectorLike.

getY(lv)

Return the 2-component of a given LorentzVectorLike.

getZ(lv)

Return the 3-component of a given LorentzVectorLike.

in_phase_space_dimension(
    proc::AbstractProcessDefinition,
    model::AbstractModelDefinition,
)

TBW

incoming_particles(proc_def::AbstractProcessDefinition)

Interface function for scattering processes. Return a tuple of the incoming particles for the given process definition. This function needs to be given to implement the scattering process interface.

is_anti_particle(_::AbstractParticle) -> Bool

Interface function for particles. Return true if the passed subtype of AbstractParticle can be considered an anti particle as distinct from their particle counterpart, and false otherwise. The default implementation of is_anti_particle for every subtype of AbstractParticle will always return false.

is_boson(_::AbstractParticle)

Interface function for particles. Return true if the passed subtype of AbstractParticle can be considered a boson in the sense of particle statistics, and false otherwise. The default implementation of is_boson for every subtype of AbstractParticle will always return false.

is_fermion(_::AbstractParticle) -> Bool

Interface function for particles. Return true if the passed subtype of AbstractParticle can be considered a fermion in the sense of particle statistics, and false otherwise. The default implementation of is_fermion for every subtype of AbstractParticle will always return false.

is_incoming(dir::ParticleDirection)
is_incoming(particle::AbstractParticleStateful)

Convenience function that returns true for Incoming and incoming AbstractParticleStateful and false otherwise.

is_outgoing(dir::ParticleDirection)
is_outgoing(particle::AbstractParticleStateful)

Convenience function that returns true for Outgoing and outgoing AbstractParticleStateful and false otherwise.

is_particle(_::AbstractParticle) -> Bool

Interface function for particles. Return true if the passed subtype of AbstractParticle can be considered a particle as distinct from anti-particles, and false otherwise. The default implementation of is_particle for every subtype of AbstractParticle will always return true.

isonshell(mom, mass)

On-shell check of a given four-momentum mom w.r.t. a given mass mass.

mass(particle::AbstractParticle)::Real

Interface function for particles. Return the rest mass of a particle (in units of the electron mass).

This needs to be implemented for each concrete subtype of AbstractParticle.

Function alias for minkowski_dot.

minkowski_dot(v1,v2)

Return the Minkowski dot product of two LorentzVectorLike.

t1*t2 - (x1*x2 + y1*y2 + z1*z2)

model(psp::AbstractPhaseSpacePoint)

Return the phase space point's set model.

momenta(psp::AbstractPhaseSpacePoint, ::ParticleDirection)

Return a Tuple of all the particles' momenta for the given ParticleDirection.

momentum(part::AbstractParticleStateful)

Interface function that must return the particle's AbstractFourMomentum.

momentum(psp::AbstractPhaseSpacePoint, dir::ParticleDirection, species::AbstractParticleType, n::Int)

Returns the momentum of the nth particle in the given AbstractPhaseSpacePoint which has direction dir and species species. If n is outside the valid range for this phase space point, a BoundsError is thrown.

momentum(psp::AbstractPhaseSpacePoint, dir::ParticleDirection, species::AbstractParticleType)

Returns the momentum of the particle in the given AbstractPhaseSpacePoint with dir and species, if there is only one such particle. If there are multiple or none, an InvalidInputError is thrown.

momentum(psp::AbstractPhaseSpacePoint, dir::ParticleDirection, n::Int)

Returns the momentum of the nth particle in the given AbstractPhaseSpacePoint which has direction dir. If n is outside the valid range for this phase space point, a BoundsError is thrown.

momentum(psp::AbstractPhaseSpacePoint, dir::ParticleDirection, species::AbstractParticleType, n::Val{N})

Returns the momentum of the nth particle in the given AbstractPhaseSpacePoint which has direction dir and species species. If n is outside the valid range for this phase space point, a BoundsError is thrown.

mul(
    DM::Union{AbstractDiracMatrix, AbstractDiracVector},
    L::AbstractLorentzVector
) -> Any

Product of generic Lorentz vector with a Dirac tensor from the left. Basically, the multiplication is piped to the components from the Lorentz vector.

mul(
    L::AbstractLorentzVector,
    DM::Union{AbstractDiracMatrix, AbstractDiracVector}
) -> Any

Product of generic Lorentz vector with a Dirac tensor from the right. Basically, the multiplication is piped to the components from the Lorentz vector.

multiplicity(spin_or_pol)

Return the number of spins or polarizations respresented by spin_or_pol, e.g. multiplicity(SpinUp()) == 1, but multiplicity(AllSpin()) = 2.

number_incoming_particles(proc_def::AbstractProcessDefinition)

Return the number of incoming particles of a given process.

number_outgoing_particles(proc_def::AbstractProcessDefinition)

Return the number of outgoing particles of a given process.

number_particles(proc_def::AbstractProcessDefinition, particle::AbstractParticleStateful)

Return the number of particles of the given particle's direction and species in the given process definition.

number_particles(proc_def::AbstractProcessDefinition, dir::ParticleDirection)

Convenience function dispatching to number_incoming_particles or number_outgoing_particles depending on the given direction, returning the number of incoming or outgoing particles, respectively.

number_particles(proc_def::AbstractProcessDefinition, dir::ParticleDirection, species::AbstractParticleType)

Return the number of particles of the given direction and species in the given process definition.

out_phase_space_dimension(
    proc::AbstractProcessDefinition,
    model::AbstractModelDefinition,
)

TBW

outgoing_particles(proc_def::AbstractProcessDefinition)

Interface function for scattering processes. Return the tuple of outgoing particles for the given process definition. This function needs to be given to implement the scattering process interface.

particle_direction(part::AbstractParticleStateful)

Interface function that must return the particle's ParticleDirection.

particle_species(part::AbstractParticleStateful)

Interface function that must return the particle's AbstractParticleType, e.g. QEDcore.Electron().

particles(proc_def::AbstractProcessDefinition, ::ParticleDirection)

Convenience function dispatching to incoming_particles or outgoing_particles depending on the given direction.

phase_space_definition(psp::AbstractPhaseSpacePoint)

Return the phase space point's set phase space definition.

process(psp::AbstractPhaseSpacePoint)

Return the phase space point's set process.

propagator(particle::AbstractParticleType, mom::QEDbase.AbstractFourMomentum, [mass::Real])

Return the propagator of a particle for a given four-momentum. If mass is passed, the respective propagator for massive particles is used, if not, it is assumed the particle passed in is massless.

register_LorentzVectorLike(T)

Function to register a custom type as a LorentzVectorLike.

Ensure the passed custom type has implemented at least the function getT, getX, getY, getZ and enables getter functions of the lorentz vector library for the given type. If additionally the functions setT!, setX!, setY!, setZ! are implemened for the passed custom type, also the setter functions of the Lorentz vector interface are enabled.

setCosTheta!(lv,value)

Sets the cosine of the theta angle of a LorentzVectorLike to a given value.

setE!(lv,value)

Sets the energy component of a given LorentzVectorLike to a given value.

Function alias for setE!.

setMinus!(lv,value)

Sets the minus component of a LorentzVectorLike to a given value.

Function alias for setTransverseMass!.

Function alias for setTransverseMomentum!.

setPhi!(lv,value)

Sets the phi angle of a LorentzVectorLike to a given value.

setPlus!(lv,value)

Sets the plus component of a LorentzVectorLike to a given value.

Function alias for setTransverseMomentum!.

setPx!(lv,value)

Sets the 1-component of a given LorentzVectorLike to a given value.

setPy!(lv,value)

Sets the 2-component of a given LorentzVectorLike to a given value.

setPz!(lv,value)

Sets the 3-component of a given LorentzVectorLike to a given value.

setRapidity!(lv,value)

Sets the rapidity of a LorentzVectorLike to a given value.

setRho!(lv,value)

Sets the magnitude of a LorentzVectorLike to a given value.

setT!(lv,value)

Sets the 0-component of a given LorentzVectorLike to the given value.

setTheta!(lv,value)

Sets the theta angle of a LorentzVectorLike to a given value.

setTransverseMass!(lv,value)

Sets the transverse mass of a LorentzVectorLike to a given value.

setTransverseMomentum!(lv,value)

Sets the transverse momentum of a LorentzVectorLike to a given value.

setX!(lv,value)

Sets the 1-component of a given LorentzVectorLike to the given value.

setY!(lv,value)

Sets the 2-component of a given LorentzVectorLike to the given value.

setZ!(lv,value)

Sets the 3-component of a given LorentzVectorLike to the given value.

total_cross_section(in_psp::AbstractInPhaseSpacePoint)

Return the total cross section for a given AbstractInPhaseSpacePoint.

total_probability(in_psp::AbstractInPhaseSpacePoint)

Return the total probability of a given AbstractInPhaseSpacePoint.

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.

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.