EOD

src/code_gen/function.jl

@@ -56,7 +56,7 @@ end
 """
     execute(graph::DAG, process::AbstractProcessDescription, machine::Machine, input::AbstractProcessInput)
 
-Execute the code of the given `graph` on the given input particles.
+Execute the code of the given `graph` on the given input values.
 
 This is essentially shorthand for
 ```julia

src/code_gen/tape_machine.jl

@@ -1,3 +1,4 @@
+# TODO: do this with macros
 function call_fc(fc::FunctionCall{VectorT, 0}, cache::Dict{Symbol, Any}) where {VectorT <: SVector{1}}
     cache[fc.return_symbol] = fc.func(cache[fc.arguments[1]])
     return nothing
@@ -73,38 +74,27 @@ function gen_cache_init_code(machine::Machine)
     return initializeCaches
 end
 
-"""
-    part_from_x(type::Type, index::Int, x::AbstractProcessInput)
-
-Return the [`ParticleValue`](@ref) of the given type of particle with the given `index` from the given process input.
-
-Function is wrapped into a [`FunctionCall`](@ref) in [`gen_input_assignment_code`](@ref).
-"""
-part_from_x(type::Type, index::Int, x::AbstractProcessInput) =
-    ParticleValue{type, ComplexF64}(get_particle(x, type, index), one(ComplexF64))
-
 """
     gen_input_assignment_code(
         inputSymbols::Dict{String, Vector{Symbol}},
-        processDescription::AbstractProcessDescription,
+        instance::AbstractProblemInstance,
         machine::Machine,
-        processInputSymbol::Symbol = :input,
+        problemInputSymbol::Symbol = :input,
     )
 
-Return a `Vector{Expr}` doing the input assignments from the given `processInputSymbol` onto the `inputSymbols`.
+Return a `Vector{Expr}` doing the input assignments from the given `problemInputSymbol` onto the `inputSymbols`.
 """
 function gen_input_assignment_code(
     inputSymbols::Dict{String, Vector{Symbol}},
-    processDescription::AbstractProcessDescription,
+    instance::AbstractProblemInstance,
     machine::Machine,
-    processInputSymbol::Symbol = :input,
+    problemInputSymbol::Symbol = :input,
 )
-    @assert length(inputSymbols) >=
-            sum(values(in_particles(processDescription))) + sum(values(out_particles(processDescription))) "Number of input Symbols is smaller than the number of particles in the process description"
+    @assert length(inputSymbols) >= sum(values(in_particles(instance))) + sum(values(out_particles(instance))) "Number of input Symbols is smaller than the number of particles in the process description"
 
     assignInputs = Vector{FunctionCall}()
     for (name, symbols) in inputSymbols
-        (type, index) = type_index_from_name(model(processDescription), name)
+        (type, index) = type_index_from_name(model(instance), name)
         # make a function for this, since we can't use anonymous functions in the FunctionCall
 
         for symbol in symbols
@@ -114,7 +104,7 @@ function gen_input_assignment_code(
                 FunctionCall(
                     # x is the process input
                     part_from_x,
-                    SVector{1, Symbol}(processInputSymbol),
+                    SVector{1, Symbol}(problemInputSymbol),
                     SVector{2, Any}(type, index),
                     symbol,
                     device,
@@ -127,13 +117,13 @@ function gen_input_assignment_code(
 end
 
 """
-    gen_tape(graph::DAG, process::AbstractProcessDescription, machine::Machine)
+    gen_tape(graph::DAG, instance::AbstractProblemInstance, machine::Machine)
 
 Generate the code for a given graph. The return value is a [`Tape`](@ref).
 
 See also: [`execute`](@ref), [`execute_tape`](@ref)
 """
-function gen_tape(graph::DAG, process::AbstractProcessDescription, machine::Machine)
+function gen_tape(graph::DAG, instance::AbstractProblemInstance, machine::Machine)
     schedule = schedule_dag(GreedyScheduler(), graph, machine)
 
     # get inSymbols
@@ -150,19 +140,19 @@ function gen_tape(graph::DAG, process::AbstractProcessDescription, machine::Mach
     outSym = Symbol(to_var_name(get_exit_node(graph).id))
 
     initCaches = gen_cache_init_code(machine)
-    assignInputs = gen_input_assignment_code(inputSyms, process, machine, :input)
+    assignInputs = gen_input_assignment_code(inputSyms, instance, machine, :input)
 
-    return Tape(initCaches, assignInputs, schedule, inputSyms, outSym, Dict(), process, machine)
+    return Tape(initCaches, assignInputs, schedule, inputSyms, outSym, Dict(), instance, machine)
 end
 
 """
-    execute_tape(tape::Tape, input::AbstractProcessInput)
+    execute_tape(tape::Tape, input::Input) where {Input}
 
 Execute the given tape with the given input.
 
 For implementation reasons, this disregards the set [`CacheStrategy`](@ref) of the devices and always uses a dictionary.
 """
-function execute_tape(tape::Tape, input::AbstractProcessInput)
+function execute_tape(tape::Tape, input)
     cache = Dict{Symbol, Any}()
     cache[:input] = input
     # simply execute all the code snippets here

src/code_gen/type.jl

@@ -1,19 +1,19 @@
 
 """
-    Tape
+    Tape{INPUT}
 
 TODO: update docs
 - `code::Vector{Expr}`: The julia expression containing the code for the whole graph.
 - `inputSymbols::Dict{String, Vector{Symbol}}`: A dictionary of symbols mapping the names of the input nodes of the graph to the symbols their inputs should be provided on.
 - `outputSymbol::Symbol`: The symbol of the final calculated value
 """
-struct Tape
+struct Tape{INPUT}
     initCachesCode::Vector{Expr}
     inputAssignCode::Vector{FunctionCall}
     computeCode::Vector{FunctionCall}
     inputSymbols::Dict{String, Vector{Symbol}}
     outputSymbol::Symbol
     cache::Dict{Symbol, Any}
-    process::AbstractProcessDescription
+    instance::AbstractProblemInstance
     machine::Machine
 end

src/models/interface.jl

@@ -1,120 +1,16 @@
-import QEDbase.mass
-import QEDbase.AbstractParticle
 
 """
-    AbstractPhysicsModel
+    AbstractModel
 
-Base type for a model, e.g. ABC-Model or QED. This is used to dispatch many functions.
-"""
-abstract type AbstractPhysicsModel end
 
 """
-    ParticleValue{ParticleType <: AbstractParticle}
-
-A struct describing a particle during a calculation of a Feynman Diagram, together with the value that's being calculated. `AbstractParticle` is the type from the QEDbase package.
-
-`sizeof(ParticleValue())` = 48 Byte
-"""
-struct ParticleValue{ParticleType <: AbstractParticle, ValueType}
-    p::ParticleType
-    v::ValueType
-end
+abstract type AbstractModel end
 
 """
-    AbstractProcessDescription
+    AbstractProblemInstance
 
 Base type for process descriptions. An object of this type of a corresponding [`AbstractPhysicsModel`](@ref) should uniquely identify a process in that model.
 
 See also: [`parse_process`](@ref)
 """
-abstract type AbstractProcessDescription end
-
-"""
-    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`](@ref)
-"""
-abstract type AbstractProcessInput end
-
-"""
-    interaction_result(t1::Type{T1}, t2::Type{T2}) where {T1 <: AbstractParticle, T2 <: AbstractParticle}
-
-Interface function that must be implemented for every subtype of [`AbstractParticle`](@ref), returning the result particle type when the two given particles interact.
-"""
-function interaction_result end
-
-"""
-    types(::AbstractPhysicsModel)
-
-Interface function that must be implemented for every subtype of [`AbstractPhysicsModel`](@ref), returning a `Vector` of the available particle types in the model.
-"""
-function types end
-
-"""
-    in_particles(::AbstractProcessDescription)
-
-Interface function that must be implemented for every subtype of [`AbstractProcessDescription`](@ref).
-Returns a `<: Dict{Type{AbstractParticle}, Int}` object, representing the number of incoming particles for the process per particle type.
-
-
-    in_particles(::AbstractProcessInput)
-
-Interface function that must be implemented for every subtype of [`AbstractProcessInput`](@ref).
-Returns a `<: Vector{AbstractParticle}` object with the values of all incoming particles for the corresponding `ProcessDescription`.
-"""
-function in_particles end
-
-"""
-    out_particles(::AbstractProcessDescription)
-
-Interface function that must be implemented for every subtype of [`AbstractProcessDescription`](@ref).
-Returns a `<: Dict{Type{AbstractParticle}, Int}` object, representing the number of outgoing particles for the process per particle type.
-
-
-    out_particles(::AbstractProcessInput)
-
-Interface function that must be implemented for every subtype of [`AbstractProcessInput`](@ref).
-Returns a `<: Vector{AbstractParticle}` object with the values of all outgoing particles for the corresponding `ProcessDescription`.
-"""
-function out_particles end
-
-"""
-    get_particle(::AbstractProcessInput, t::Type, n::Int)
-
-Interface function that must be implemented for every subtype of [`AbstractProcessInput`](@ref).
-Returns the `n`th particle of type `t`.
-"""
-function get_particle end
-
-"""
-    parse_process(::AbstractString, ::AbstractPhysicsModel)
-
-Interface function that must be implemented for every subtype of [`AbstractPhysicsModel`](@ref).
-Returns a `ProcessDescription` object.
-"""
-function parse_process end
-
-"""
-    gen_process_input(::AbstractProcessDescription)
-
-Interface function that must be implemented for every specific [`AbstractProcessDescription`](@ref).
-Returns a randomly generated and valid corresponding `ProcessInput`.
-"""
-function gen_process_input end
-
-"""
-    model(::AbstractProcessDescription)
-    model(::AbstarctProcessInput)
-
-Return the model of this process description or input.
-"""
-function model end
-
-"""
-    type_from_name(model::AbstractModel, name::String)
-
-For a name of a particle in the given [`AbstractModel`](@ref), return the particle's [`Type`] and index as a tuple. The input string can be expetced to be of the form \"<name><index>\".
-"""
-function type_index_from_name end
+abstract type AbstractProblemInstance end

src/models/physics_models/interface.jl

@@ -0,0 +1,131 @@
+import QEDbase.mass
+import QEDbase.AbstractParticle
+
+"""
+    AbstractPhysicsModel
+
+Base type for a model, e.g. ABC-Model or QED. This is used to dispatch many functions.
+"""
+abstract type AbstractPhysicsModel <: AbstractModel end
+
+"""
+    ParticleValue{ParticleType <: AbstractParticle}
+
+A struct describing a particle during a calculation of a Feynman Diagram, together with the value that's being calculated. `AbstractParticle` is the type from the QEDbase package.
+
+`sizeof(ParticleValue())` = 48 Byte
+"""
+struct ParticleValue{ParticleType <: AbstractParticle, ValueType}
+    p::ParticleType
+    v::ValueType
+end
+
+"""
+    AbstractProcessDescription <: AbstractProblemInstance
+
+Base type for particle scattering process descriptions. An object of this type of a corresponding [`AbstractPhysicsModel`](@ref) should uniquely identify a scattering process in that model.
+
+See also: [`parse_process`](@ref), [`AbstractProblemInstance`](@ref)
+"""
+abstract type AbstractProcessDescription end
+
+
+"""
+    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`](@ref)
+"""
+abstract type AbstractProcessInput end
+
+"""
+    interaction_result(t1::Type{T1}, t2::Type{T2}) where {T1 <: AbstractParticle, T2 <: AbstractParticle}
+
+Interface function that must be implemented for every subtype of [`AbstractParticle`](@ref), returning the result particle type when the two given particles interact.
+"""
+function interaction_result end
+
+"""
+    types(::AbstractPhysicsModel)
+
+Interface function that must be implemented for every subtype of [`AbstractPhysicsModel`](@ref), returning a `Vector` of the available particle types in the model.
+"""
+function types end
+
+"""
+    in_particles(::AbstractProcessDescription)
+
+Interface function that must be implemented for every subtype of [`AbstractProcessDescription`](@ref).
+Returns a `<: Dict{Type{AbstractParticle}, Int}` object, representing the number of incoming particles for the process per particle type.
+
+
+    in_particles(::AbstractProcessInput)
+
+Interface function that must be implemented for every subtype of [`AbstractProcessInput`](@ref).
+Returns a `<: Vector{AbstractParticle}` object with the values of all incoming particles for the corresponding `ProcessDescription`.
+"""
+function in_particles end
+
+"""
+    out_particles(::AbstractProcessDescription)
+
+Interface function that must be implemented for every subtype of [`AbstractProcessDescription`](@ref).
+Returns a `<: Dict{Type{AbstractParticle}, Int}` object, representing the number of outgoing particles for the process per particle type.
+
+
+    out_particles(::AbstractProcessInput)
+
+Interface function that must be implemented for every subtype of [`AbstractProcessInput`](@ref).
+Returns a `<: Vector{AbstractParticle}` object with the values of all outgoing particles for the corresponding `ProcessDescription`.
+"""
+function out_particles end
+
+"""
+    get_particle(::AbstractProcessInput, t::Type, n::Int)
+
+Interface function that must be implemented for every subtype of [`AbstractProcessInput`](@ref).
+Returns the `n`th particle of type `t`.
+"""
+function get_particle end
+
+"""
+    parse_process(::AbstractString, ::AbstractPhysicsModel)
+
+Interface function that must be implemented for every subtype of [`AbstractPhysicsModel`](@ref).
+Returns a `ProcessDescription` object.
+"""
+function parse_process end
+
+"""
+    gen_process_input(::AbstractProcessDescription)
+
+Interface function that must be implemented for every specific [`AbstractProcessDescription`](@ref).
+Returns a randomly generated and valid corresponding `ProcessInput`.
+"""
+function gen_process_input end
+
+"""
+    model(::AbstractProcessDescription)
+    model(::AbstractProcessInput)
+
+Return the model of this process description or input.
+"""
+function model end
+
+"""
+    type_from_name(model::AbstractModel, name::String)
+
+For a name of a particle in the given [`AbstractModel`](@ref), return the particle's [`Type`] and index as a tuple. The input string can be expetced to be of the form \"<name><index>\".
+"""
+function type_index_from_name end
+
+"""
+    part_from_x(type::Type, index::Int, x::AbstractProcessInput)
+
+Return the [`ParticleValue`](@ref) of the given type of particle with the given `index` from the given process input.
+
+Function is wrapped into a [`FunctionCall`](@ref) in [`gen_input_assignment_code`](@ref).
+"""
+part_from_x(type::Type, index::Int, x::AbstractProcessInput) =
+    ParticleValue{type, ComplexF64}(get_particle(x, type, index), one(ComplexF64))