QEDcore

AbstractParticleSpinor

TBW

struct AdjointBiSpinor <: AbstractDiracVector{ComplexF64}

Concrete type to model an adjoint Dirac four-spinor with complex-valued components. These are the elements of the dual spinor space.

Abstract base type for anti-bosons as distinct from its particle counterpart Boson.

is_boson(::AntiBoson) = true
is_particle(::AntiBoson) = false
is_anti_particle(::AntiBoson) = true

Abstract base type for anti-fermions as distinct from its particle counterpart Fermion.

is_fermion(::AntiFermion) = true
is_particle(::AntiFermion) = false
is_anti_particle(::AntiFermion) = true

struct BiSpinor <: AbstractDiracVector{ComplexF64}

Concrete type to model a Dirac four-spinor with complex-valued components. These are the elements of an actual spinor space.

Abstract base type for bosons as distinct from its anti-particle counterpart AntiBoson.

is_boson(::Boson) = true
is_particle(::Boson) = true
is_anti_particle(::Boson) = false

Abstract base types for particle species that act like bosons in the sense of particle statistics.

CenterOfMomentumFrame <: AbstractFrameOfReference

TBW

struct DiracMatrix <: AbstractDiracMatrix{ComplexF64}

Concrete type to model Dirac matrices, i.e. matrix representations of linear mappings between two spinor spaces.

Concrete type for electrons as a particle species. Mostly used for dispatch.

julia> using QEDcore

julia> Electron()
electron

mass(::Electron) = 1.0
charge(::Electron) = -1.0

ElectronRestFrame <: AbstractFrameOfReference

TBW

Abstract base type for fermions as distinct from AntiFermions.

is_fermion(::Fermion) = true
is_particle(::Fermion) = true
is_anti_particle(::Fermion) = false

Abstract base types for particle species that act like fermions in the sense of particle statistics.

InPhaseSpacePoint

A partial type specialization on PhaseSpacePoint 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: OutPhaseSpacePoint

InPhaseSpacePoint(
    proc::AbstractProcessDefinition,
    model::AbstractModelDefinition,
    ps_def::AbstractPhasespaceDefinition,
    in_momenta::NTuple{N,AbstractFourMomentum},
)

Construct a PhaseSpacePoint with only input particles from given momenta. The result will be <: InPhaseSpacePoint but not <: OutPhaseSpacePoint.

InPhaseSpacePoint(
    proc::AbstractProcessDefinition, 
    model::AbstractModelDefinition, 
    ps_def::AbstractPhasespaceDefinition, 
    in_ps::Tuple{ParticleStateful},
)

Construct a [`PhaseSpacePoint`](@ref) with only input particles from [`ParticleStateful`](@ref)s. The result will be `<: InPhaseSpacePoint` but **not** `<: OutPhaseSpacePoint`.

InPhaseSpacePoint(
    proc::AbstractProcessDefinition,
    model::AbstractModelDefinition,
    ps_def::AbstractPhasespaceDefinition,
    in_coords::NTuple{N,Real},
)

Construct a PhaseSpacePoint from given coordinates by using the _generate_momenta interface. The result will be <: InPhaseSpacePoint but not <: OutPhaseSpacePoint.

mutable struct MFourMomentum <: AbstractFourMomentum

Builds a mutable LorentzVector with real components used to statically model the four-momentum of a particle or field.

Fields

• E::Float64: energy component

• px::Float64: x component

• py::Float64: y component

• pz::Float64: z component

MFourMomentum(t, x, y, z)

The interface transforms each number-like input to float64:

MFourMomentum(
    t::Union{Integer, Irrational, Rational},
    x::Union{Integer, Irrational, Rational},
    y::Union{Integer, Irrational, Rational},
    z::Union{Integer, Irrational, Rational}
) -> MFourMomentum

mutable struct MLorentzVector{T} <: AbstractLorentzVector{T}

Concrete implementation of a generic mutable Lorentz vector. Each manipulation of an concrete implementation which is not self-contained (i.e. produces the same Lorentz vector type) will result in this type.

Fields

• t::Any: t component

• x::Any: x component

• y::Any: y component

• z::Any: z component

Abstract base type for majorana-bosons, i.e. bosons which are their own anti-particles.

is_boson(::MajoranaBoson) = true
is_particle(::MajoranaBoson) = true
is_anti_particle(::MajoranaBoson) = true

Abstract base type for majorana-fermions, i.e. fermions which are their own anti-particles.

is_fermion(::MajoranaFermion) = true
is_particle(::MajoranaFermion) = true
is_anti_particle(::MajoranaFermion) = true

OutPhaseSpacePoint

A partial type specialization on PhaseSpacePoint 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: InPhaseSpacePoint

OutPhaseSpacePoint(
    proc::AbstractProcessDefinition,
    model::AbstractModelDefinition,
    ps_def::AbstractPhasespaceDefinition,
    out_momenta::NTuple{N,AbstractFourMomentum},
)

Construct a PhaseSpacePoint with only output particles from given momenta. The result will be <: OutPhaseSpacePoint but not <: InPhaseSpacePoint.

OutPhaseSpacePoint(
    proc::AbstractProcessDefinition, 
    model::AbstractModelDefinition, 
    ps_def::AbstractPhasespaceDefinition, 
    out_ps::Tuple{ParticleStateful},
)

Construct a PhaseSpacePoint with only output particles from ParticleStatefuls. The result will be <: OutPhaseSpacePoint but not <: InPhaseSpacePoint.

ParticleStateful <: AbstractParticle

Representation of a particle with a state. It has four fields:

• dir::ParticleDirection: The direction of the particle, Incoming() or Outgoing().
• species::AbstractParticleType: The species of the particle, Electron(), Positron() etc.
• mom::AbstractFourMomentum: The momentum of the particle.

Overloads for is_fermion, is_boson, is_particle, is_anti_particle, is_incoming, is_outgoing, mass, and charge are provided, delegating the call to the correct field and thus implementing the AbstractParticle interface.

julia> using QEDcore

julia> ParticleStateful(Incoming(), Electron(), SFourMomentum(1, 0, 0, 0))
ParticleStateful: incoming electron
    momentum: [1.0, 0.0, 0.0, 0.0]

julia> ParticleStateful(Outgoing(), Photon(), SFourMomentum(1, 0, 0, 0))
ParticleStateful: outgoing photon
    momentum: [1.0, 0.0, 0.0, 0.0]

ParticleStateful{DIR, SPECIES}(mom::AbstractFourMomentum)
ParticleStateful{DIR, SPECIES, EL}(mom::EL)

Construct a ParticleStateful from the given momentum on a fully or partially specified type.

PhaseSpacePoint

Representation of a point in the phase space of a process. Contains the process (AbstractProcessDefinition), the model (AbstractModelDefinition), the phase space definition (AbstractPhasespaceDefinition), and stateful incoming and outgoing particles (ParticleStateful).

The legality of the combination of the given process and the incoming and outgoing particles is checked on construction. If the numbers of particles mismatch, the types of particles mismatch (note that order is important), or incoming particles have an Outgoing direction, an error is thrown.

julia> using QEDcore; using QEDprocesses

julia> PhaseSpacePoint(
            Compton(),
            PerturbativeQED(),
            PhasespaceDefinition(SphericalCoordinateSystem(), ElectronRestFrame()),
            (
                ParticleStateful(Incoming(), Electron(), SFourMomentum(1, 0, 0, 0)),
                ParticleStateful(Incoming(), Photon(), SFourMomentum(1, 0, 0, 0))
            ),
            (
                ParticleStateful(Outgoing(), Electron(), SFourMomentum(1, 0, 0, 0)),
                ParticleStateful(Outgoing(), Photon(), SFourMomentum(1, 0, 0, 0))
            )
        )
PhaseSpacePoint:
    process: one-photon Compton scattering
    model: perturbative QED
    phasespace definition: spherical coordinates in electron rest frame
    incoming particles:
     -> incoming electron: [1.0, 0.0, 0.0, 0.0]
     -> incoming photon: [1.0, 0.0, 0.0, 0.0]
    outgoing particles:
     -> outgoing electron: [1.0, 0.0, 0.0, 0.0]
     -> outgoing photon: [1.0, 0.0, 0.0, 0.0]

PhaseSpacePoint(
    proc::AbstractProcessDefinition,
    model::AbstractModelDefinition,
    ps_def::AbstractPhasespaceDefinition,
    in_momenta::NTuple{N,AbstractFourMomentum},
    out_momenta::NTuple{M,AbstractFourMomentum},
)

Construct the phase space point from given momenta of incoming and outgoing particles regarding a given process.

PhaseSpacePoint(
    proc::AbstractProcessDefinition,
    model::AbstractModelDefinition,
    ps_def::AbstractPhasespaceDefinition,
    in_coords::NTuple{N,Real},
    out_coords::NTuple{M,Real},
)

Construct a PhaseSpacePoint from given coordinates by using the _generate_momenta interface.

PhasespaceDefinition(coord_sys::AbstractCoordinateSystem, frame::AbstractFrameOfReference)

Convenient type to dispatch on coordiante systems and frames of reference. Combines a AbstractCoordinateSystem with a AbstractFrameOfReference.

Concrete type for the photons as a particle species. Mostly used for dispatch.

julia> using QEDcore

julia> Photon()
photon

mass(::Photon) = 0.0
charge(::Photon) = 0.0

Concrete type for positrons as a particle species. Mostly used for dispatch.

julia> using QEDcore

julia> Positron()
positron

mass(::Positron) = 1.0
charge(::Positron) = 1.0

struct SFourMomentum <: AbstractFourMomentum

Builds a static LorentzVectorLike with real components used to statically model the four-momentum of a particle or field.

Fields

• E::Float64: energy component

• px::Float64: x component

• py::Float64: y component

• pz::Float64: z component

SFourMomentum(t, x, y, z)

The interface transforms each number-like input to float64:

SFourMomentum(
    t::Union{Integer, Irrational, Rational},
    x::Union{Integer, Irrational, Rational},
    y::Union{Integer, Irrational, Rational},
    z::Union{Integer, Irrational, Rational}
) -> SFourMomentum

struct SLorentzVector{T} <: AbstractLorentzVector{T}

Concrete implementation of a generic static Lorentz vector. Each manipulation of an concrete implementation which is not self-contained (i.e. produces the same Lorentz vector type) will result in this type.

Fields

• t::Any: t component

• x::Any: x component

• y::Any: y component

• z::Any: z component

SphericalCoordinateSystem <: AbstractCoordinateSystem

TBW

Base.getindex(psp::PhaseSpacePoint, dir::Incoming, n::Int)

Overload for the array indexing operator []. Returns the nth incoming particle in this phase space point.

Base.getindex(psp::PhaseSpacePoint, dir::Outgoing, n::Int)

Overload for the array indexing operator []. Returns the nth outgoing particle in this phase space point.

_momentum_type(psp::PhaseSpacePoint)
_momentum_type(type::Type{PhaseSpacePoint})

Returns the element type of the PhaseSpacePoint object or type, e.g. SFourMomentum.

julia> using QEDcore; using QEDprocesses

julia> psp = PhaseSpacePoint(Compton(), PerturbativeQED(), PhasespaceDefinition(SphericalCoordinateSystem(), ElectronRestFrame()), Tuple(rand(SFourMomentum) for _ in 1:2), Tuple(rand(SFourMomentum) for _ in 1:2));

julia> QEDcore._momentum_type(psp)
SFourMomentum

julia> QEDcore._momentum_type(typeof(psp))
SFourMomentum

_mul(aBS::AdjointBiSpinor, BS::BiSpinor) -> ComplexF64

Tensor product of an adjoint with a standard bi-spinor resulting in a scalar.

_mul(
    aBS::AdjointBiSpinor,
    DM::DiracMatrix,
    BS::BiSpinor
) -> ComplexF64

Tensor product of Dirac matrix sandwiched between an adjoint and a standard bi-spinor resulting in a scalar.

_mul(
    aBS::AdjointBiSpinor,
    DM::DiracMatrix
) -> AdjointBiSpinor

Tensor product of an adjoint bi-spinor with a Dirac matrix resulting in another adjoint bi-spinor.

_mul(BS::BiSpinor, aBS::AdjointBiSpinor) -> DiracMatrix

Tensor product of a standard with an adjoint bi-spinor resulting in a Dirac matrix.

_mul(DM::DiracMatrix, BS::BiSpinor) -> BiSpinor

Tensor product of an Dirac matrix with a standard bi-spinor resulting in another standard bi-spinor.

_mul(DM1::DiracMatrix, DM2::DiracMatrix) -> DiracMatrix

Tensor product two Dirac matrices resulting in another Dirac matrix.