Models

QEDFeynman

A module containing QED and ABC model functionality for scattering processes in particle physics.

AbstractPhysicsModel

Base type for a model, e.g. ABC-Model or QED. This is used to dispatch many functions.

AbstractProcessDescription <: AbstractProblemInstance

Base type for particle scattering process descriptions. An object of this type of a corresponding AbstractPhysicsModel should uniquely identify a scattering process in that model.

See also: parse_process

AbstractProcessInput

Base type for process inputs. An object of this type contains the input values (e.g. momenta) of the particles in a process.

See also: gen_process_input

ParticleValue{ParticleType <: AbstractParticleStateful}

A struct describing a particle during a calculation of a Feynman Diagram, together with the value that's being calculated. AbstractParticleStateful is the type from the QEDbase package.

sizeof(ParticleValue()) = 48 Byte

TBW

particle value + spin/pol info, only used on the external legs (u tasks)

gen_process_input(::AbstractProcessDescription)

Interface function that must be implemented for every specific AbstractProcessDescription. Returns a randomly generated and valid corresponding ProcessInput.

get_particle(::AbstractProcessInput, t::Type, n::Int)

Interface function that must be implemented for every subtype of AbstractProcessInput. Returns the nth particle of type t.

interaction_result(t1::AbstractParticleStateful, t2::AbstractParticleStateful)

Interface function that must be implemented for AbstractParticleStatefuls for all pairs of particle_species that can occur in the model. It should return the result particle (stateful) type when the two given particles interact.

model(::AbstractProcessDescription)
model(::AbstractProcessInput)

Return the model of this process description or input.

parse_process(::AbstractString, ::AbstractPhysicsModel)

Interface function that must be implemented for every subtype of AbstractPhysicsModel. Returns a ProcessDescription object.

part_from_x(type::Type, index::Int, x::AbstractProcessInput)

Return the ParticleValue of the given type of particle with the given index from the given process input.

Function is wrapped into a FunctionCall in gen_input_assignment_code.

type_from_name(model::AbstractModel, name::String)

For a name of a particle in the given AbstractModel, return the particle's Type and index as a tuple. The input string can be expetced to be of the form "<name><index>".

types(::AbstractPhysicsModel)

Interface function that must be implemented for every subtype of AbstractPhysicsModel, returning a Vector of the available particle types in the model.

propagated_particle(p::AbstractParticleStateful)

Returns the same particle but with inversed particle_direction.

ABCModel <: AbstractPhysicsModel

Singleton definition for identification of the ABC-Model.

ABCParticle

Base type for all particles in the ABCModel.

ComputeTaskABC_P <: AbstractComputeTask

P task with no children.

ComputeTaskABC_S1 <: AbstractComputeTask

S task with a single child.

ComputeTaskABC_S2 <: AbstractComputeTask

S task with two children.

ComputeTaskABC_Sum <: AbstractComputeTask

Task that sums all its inputs, n children.

ComputeTaskABC_U <: AbstractComputeTask

u task with a single child.

ComputeTaskABC_V <: AbstractComputeTask

v task with two children.

ParticleA <: ABCParticle

An 'A' particle in the ABC Model.

ParticleB <: ABCParticle

A 'B' particle in the ABC Model.

ParticleC <: ABCParticle

A 'C' particle in the ABC Model.

PerturbativeABC <: AbstractModel

The model being used for the ABC model.

ABC_TASKS

Constant vector of all tasks of the ABC-Model.

GenericABCProcess <: AbstractProcessDefinition

ABC_conserve_momentum(p1::ABCParticle, p2::ABCParticle)

Calculate and return a new particle from two given interacting ones at a vertex.

Takes 4 effective FLOP.

ABC_inner_edge(p::AbstractParticleStateful{Dir, ABCParticle})

Return the factor of the inner edge with the given (virtual) particle.

Takes 10 effective FLOP. (3 here + 7 in square(p))

ABC_outer_edge(p::AbstractParticleStateful{Dir, ABCParticle})

Return the factor of the outer edge with the given (real) particle.

Takes 0 effective FLOP.

ABC_vertex()

Return the factor of a vertex.

Takes 0 effective FLOP since it's constant.

interaction_result(
    p1::AbstractParticleStateful{<:ParticleDirection, <:ABCParticle},
    p2::AbstractParticleStateful{<:ParticleDirection, <:ABCParticle},
)

For 2 given (non-equal) particle types, return the third of ABC.

square(p::AbstractParticleStateful{Dir, ABCParticle})

Return the square of the particle's momentum as a Float value.

Takes 7 effective FLOP.

types(::ABCModel)

Return a Vector of the possible types of particle in the ABCModel.

mass(t::Type{T}) where {T <: ABCParticle}

Return the mass (at rest) of the given particle type.

parse_dag(filename::String, proc::GenericABCProcess; verbose::Bool = false)

Read an ABC-model process from the given file. If verbose is set to true, print some progress information to stdout.

Returns a valid DAG.

parse_edges(input::AbstractString)

Parse the given string into a vector of strings containing each edge. Currently unused since the entire graph can be read from just the node names.

parse_nodes(input::AbstractString)

Parse the given string into a vector of strings containing each node.

parse_process(string::AbstractString, model::ABCModel)

Parse a string representation of a process, such as "AB->ABBB" into the corresponding GenericABCProcess.

children(::ComputeTaskABC_P)

Return the number of children of a ComputeTaskABC_P (always 1).

children(::ComputeTaskABC_S1)

Return the number of children of a ComputeTaskABC_S1 (always 1).

children(::ComputeTaskABC_S2)

Return the number of children of a ComputeTaskABC_S2 (always 2).

children(::ComputeTaskABC_Sum)

Return the number of children of a ComputeTaskABC_Sum.

children(::ComputeTaskABC_U)

Return the number of children of a ComputeTaskABC_U (always 1).

children(::ComputeTaskABC_V)

Return the number of children of a ComputeTaskABC_V (always 2).

compute_effort(t::ComputeTaskABC_P)

Return the compute effort of a P task.

compute_effort(t::ComputeTaskABC_S1)

Return the compute effort of an S1 task.

compute_effort(t::ComputeTaskABC_S2)

Return the compute effort of an S2 task.

compute_effort(t::ComputeTaskABC_Sum)

Return the compute effort of a Sum task.

Note: This is a constant compute effort, even though sum scales with the number of its inputs. Since there is only ever a single sum node in a graph generated from the ABC-Model, this doesn't matter.

compute_effort(t::ComputeTaskABC_U)

Return the compute effort of a U task.

compute_effort(t::ComputeTaskABC_V)

Return the compute effort of a V task.

gen_process_input(proc::GenericABCProcess)

Return a ProcessInput of randomly generated ABCParticles from a GenericABCProcess. The process description can be created manually or parsed from a string using parse_process.

Note: This uses RAMBO to create a valid process with conservation of momentum and energy.

compute(::ComputeTaskABC_Sum, data...)
compute(::ComputeTaskABC_Sum, data::AbstractArray)

Compute a sum over the vector. Use an algorithm that accounts for accumulated errors in long sums with potentially large differences in magnitude of the summands.

Linearly many FLOP with growing data.

compute(::ComputeTaskABC_V, data1::ParticleValue, data2::ParticleValue)

Compute a vertex. Preserve momentum and particle types (AB->C etc.) to create resulting particle, multiply values together and times a vertex factor.

6 FLOP.

compute(::ComputeTaskABC_P, data::ParticleValue)

Return the particle and value as is.

0 FLOP.

compute(::ComputeTaskABC_S1, data::ParticleValue)

Compute inner edge (1 input particle, 1 output particle).

11 FLOP.

compute(::ComputeTaskABC_S2, data1::ParticleValue, data2::ParticleValue)

Compute a final inner edge (2 input particles, no output particle).

For valid inputs, both input particles should have the same momenta at this point.

12 FLOP.

compute(::ComputeTaskABC_U, data::ParticleValue)

Compute an outer edge. Return the particle value with the same particle and the value multiplied by an ABCouteredge factor.

1 FLOP.

show(io::IO, particle::ABCParticle)

Pretty print an ABCParticle (no newlines).

String(p::FeynmanParticle)

Return a string representation of the FeynmanParticle in a format that is readable by type_index_from_name.

FeynmanDiagram

Representation of a feynman diagram. It consists of its initial input/output particles, and a vector of sets of FeynmanVertexs. The vertices are to be applied level by level. A FeynmanVertex will always be at the lowest level possible, i.e. the lowest level at which all input particles for it exist. The FeynmanTie represents the final inner edge of the diagram.

FeynmanDiagram(pd::ScatteringProcess)

Create an initial FeynmanDiagram with only its initial particles set and no vertices or ties.

Use gen_diagrams to generate all possible diagrams from this one.

FeynmanParticle

Representation of a particle for use in FeynmanDiagrams. Consist of the ParticleStateful type and an id.

FeynmanTie

Representation of a "tie" in a FeynmanDiagram. A tie ties two virtual particles in a diagram together and thus represent an inner line of the diagram. Not all inner lines are FeynmanTies, in fact, a connected diagram only ever has exactly one tie.

FeynmanVertex

Representation of a vertex in a FeynmanDiagram. Stores two input FeynmanParticles and one output.

add_tie!(fd::FeynmanDiagram, tie::FeynmanTie)

Add the given tie to the diagram, always at the last level.

add_tie(fd::FeynmanDiagram, tie::FeynmanTie)

Add the given tie to the diagram, at the earliest level possible. Return the new diagram without muting the given one.

add_vertex!(fd::FeynmanDiagram, vertex::FeynmanVertex)

Add the given vertex to the diagram, at the earliest level possible.

add_vertex(fd::FeynmanDiagram, vertex::FeynmanVertex)

Add the given vertex to the diagram, at the earliest level possible. Return the new diagram without muting the given one.

apply_tie!(particles::Vector{FeynmanParticle}, tie::FeynmanTie)

Apply a FeynmanTie to the given vector of FeynmanParticles.

apply_vertex!(particles::Vector{FeynmanParticle}, vertex::FeynmanVertex)

Apply a FeynmanVertex to the given vector of FeynmanParticles.

can_apply_tie(particles::Vector{FeynmanParticle}, tie::FeynmanTie)

Return true if the given FeynmanTie can be applied to the given particles, i.e. both input particles of the tie are in the vector.

can_apply_vertex(particles::Vector{FeynmanParticle}, vertex::FeynmanVertex)

Return true if the given FeynmanVertex can be applied to the given particles, i.e. both input particles of the vertex are in the vector and the output particle is not.

can_tie(p1::Type, p2::Type)

For two given QEDParticle types, return whether they can be tied together.

They can be tied iff one is the propagation_result of the other, or if both are photons, in which case their direction does not matter.

gen_compton_diagram_from_order(order::Vector{Int}, inFerm, outFerm, n::Int, m::Int)

Helper function for gen_compton_diagrams. Generates a single diagram for the given order and n input and m output photons.

gen_compton_diagram_from_order_one_side(order::Vector{Int}, inFerm, outFerm, n::Int, m::Int)

Helper function for gen_compton_diagrams. Generates a single diagram for the given order and n input and m output photons.

gen_compton_diagrams(n::Int, m::Int)

Special case diagram generation for Compton processes, i.e., processes of the form k^ne->k^me

gen_compton_diagrams_one_side(n::Int, m::Int)

Special case diagram generation for Compton processes, i.e., processes of the form k^ne->k^me, but generating from one end, yielding larger diagrams

gen_diagrams(fd::FeynmanDiagram)

From a given feynman diagram in its initial state, e.g. when created through the FeynmanDiagram(pd::ProcessDescription) constructor, generate and return all possible FeynmanDiagrams that describe that process.

get_particles(fd::FeynmanDiagram, level::Int)

Return a vector of the particles after applying the vertices and tie of the diagram up to the given level. If no level is given, apply all. The tie comes last and is its own "level".

id_for_type(d::FeynmanDiagram, t::Type{<:ParticleStateful})

Return the highest id of any particle of the given type in the diagram + 1.

is_compton(fd::FeynmanDiagram)

Returns true iff the given feynman diagram is an (empty) diagram of a compton process like ke->k^ne

isvalid(fd::FeynmanDiagram)

Return whether the given diagram is valid. A diagram is valid iff the following are true:

• After applying all vertices and the tie, there are no more particles left
• The diagram is connected

possible_tie(fd::FeynmanDiagram)

Return a possible tie or missing for the diagram at its current state.

possible_vertices(fd::FeynmanDiagram)

Return a vector of all possible vertices that can be applied to the diagram at its current state.

ComputeTaskQED_P <: AbstractComputeTask

P task with no children.

ComputeTaskQED_S1 <: AbstractComputeTask

S task with a single child.

ComputeTaskQED_S2 <: AbstractComputeTask

S task with two children.

ComputeTaskQED_Sum <: AbstractComputeTask

Task that sums all its inputs, n children.

ComputeTaskQED_U <: AbstractComputeTask

u task with a single child.

ComputeTaskQED_V <: AbstractComputeTask

v task with two children.

QEDModel <: AbstractPhysicsModel

Singleton definition for identification of the QED-Model.

QED_TASKS

Constant vector of all tasks of the QED-Model.

QED_conserve_momentum(p1::ParticleStateful, p2::ParticleStateful)

Calculate and return a new particle from two given interacting ones at a vertex.

QED_vertex()

Return the factor of a vertex in a QED feynman diagram.

caninteract(T1::Type{<:ParticleStateful}, T2::Type{<:ParticleStateful})

For two given ParticleStateful types, return whether they can interact at a vertex. This is equivalent to !issame(T1, T2).

See also: issame and interaction_result

issame(T1::Type{<:ParticleStateful}, T2::Type{<:ParticleStateful})

For two given ParticleStateful types, return whether they are equivalent for the purpose of a Feynman Diagram. That means e.g. an Incoming AntiFermion is the same as an Outgoing Fermion. This is equivalent to !caninteract(T1, T2).

See also: caninteract and interaction_result

model(::AbstractProcessDescription)

Return the model of this process description.

types(::QEDModel)

Return a Vector of the possible types of particle in the QEDModel.

parse_process(string::AbstractString, model::QEDModel)

Parse a string representation of a process, such as "ke->ke" into the corresponding QEDProcessDescription.

children(::ComputeTaskQED_P)

Return the number of children of a ComputeTaskQED_P (always 1).

children(::ComputeTaskQED_S1)

Return the number of children of a ComputeTaskQED_S1 (always 1).

children(::ComputeTaskQED_S2)

Return the number of children of a ComputeTaskQED_S2 (always 2).

children(::ComputeTaskQED_Sum)

Return the number of children of a ComputeTaskQED_Sum.

children(::ComputeTaskQED_U)

Return the number of children of a ComputeTaskQED_U (always 1).

children(::ComputeTaskQED_V)

Return the number of children of a ComputeTaskQED_V (always 2).

compute_effort(t::ComputeTaskQED_P)

Return the compute effort of a P task.

compute_effort(t::ComputeTaskQED_S1)

Return the compute effort of an S1 task.

compute_effort(t::ComputeTaskQED_S2)

Return the compute effort of an S2 task.

compute_effort(t::ComputeTaskQED_Sum)

Return the compute effort of a Sum task.

Note: This is a constant compute effort, even though sum scales with the number of its inputs. Since there is only ever a single sum node in a graph generated from the QED-Model, this doesn't matter.

compute_effort(t::ComputeTaskQED_U)

Return the compute effort of a U task.

compute_effort(t::ComputeTaskQED_V)

Return the compute effort of a V task.

gen_graph(process_description::ScatteringProcess)

For a given QEDprocesses.ScatteringProcess, return the DAG that computes it.

gen_process_input(processDescription::ScatteringProcess)

Return a PhaseSpacePoint of randomly generated particles from a QEDprocesses.ScatteringProcess. The process description can be created manually or parsed from a string using parse_process.

Note: This uses RAMBO to create a valid process with conservation of momentum and energy.

compute(::ComputeTaskQED_Sum, data...)
compute(::ComputeTaskQED_Sum, data::AbstractArray)

Compute a sum over the vector. Use an algorithm that accounts for accumulated errors in long sums with potentially large differences in magnitude of the summands.

Linearly many FLOP with growing data.

compute(::ComputeTaskQED_S2, data1::ParticleValue, data2::ParticleValue)

Compute a final inner edge (2 input particles, no output particle).

For valid inputs, both input particles should have the same momenta at this point.

12 FLOP.

compute(::ComputeTaskQED_U, data::ParticleValueSP)

Compute an outer edge. Return the particle value with the same particle and the value multiplied by an outer_edge factor.

compute(::ComputeTaskQED_V, data1::ParticleValue, data2::ParticleValue)

Compute a vertex. Preserve momentum and particle types (e + gamma->p etc.) to create resulting particle, multiply values together and times a vertex factor.

compute(::ComputeTaskQED_S1, data::ParticleValue)

Compute inner edge (1 input particle, 1 output particle).

show(io::IO, particle::FeynmanDiagram)

Pretty print a FeynmanDiagram (with newlines).

show(io::IO, particle::FeynmanParticle)

Pretty print a FeynmanParticle (no newlines).

show(io::IO, particle::FeynmanTie)

Pretty print a FeynmanTie (no newlines).

show(io::IO, particle::FeynmanVertex)

Pretty print a FeynmanVertex (no newlines).