Add notebook abc model showcase, add some pretty print functions

src/MetagraphOptimization.jl

@@ -117,6 +117,7 @@ include("task/print.jl")
 include("task/properties.jl")
 
 include("models/interface.jl")
+include("models/print.jl")
 
 include("models/abc/types.jl")
 include("models/abc/particle.jl")
@@ -124,6 +125,7 @@ include("models/abc/compute.jl")
 include("models/abc/create.jl")
 include("models/abc/properties.jl")
 include("models/abc/parse.jl")
+include("models/abc/print.jl")
 
 include("code_gen/main.jl")
 

src/models/abc/create.jl

@@ -6,7 +6,7 @@ using ForwardDiff
 ComputeTaskSum() = ComputeTaskSum(0)
 
 """
-    gen_process_input(in::Vector{ParticleType}, out::Vector{ParticleType})
+    gen_process_input(processDescription::ABCProcessDescription)
 
 Return a ProcessInput of randomly generated [`ABCParticle`](@ref)s from a [`ABCProcessDescription`](@ref). The process description can be created manually or parsed from a string using [`parse_process`](@ref).
 

src/models/abc/parse.jl

@@ -228,8 +228,14 @@ function parse_process(str::AbstractString, model::ABCModel)
     end
 
     for t in types(model)
-        inParticles[t] = count(x -> x == String(t)[1], inStr)
-        outParticles[t] = count(x -> x == String(t)[1], outStr)
+        inCount = count(x -> x == String(t)[1], inStr)
+        outCount = count(x -> x == String(t)[1], outStr)
+        if inCount != 0
+            inParticles[t] = inCount
+        end
+        if outCount != 0
+            outParticles[t] = outCount
+        end
     end
 
     if length(inStr) != sum(values(inParticles))

src/models/abc/particle.jl

@@ -1,19 +1,18 @@
 using QEDbase
 
-abstract type ABCParticle <: AbstractParticle end
+"""
+    ABCModel <: AbstractPhysicsModel
 
+Singleton definition for identification of the ABC-Model.
+"""
 struct ABCModel <: AbstractPhysicsModel end
 
-struct ABCProcessDescription <: AbstractProcessDescription
-    inParticles::Dict{Type, Int}
-    outParticles::Dict{Type, Int}
-end
+"""
+    ABCParticle
 
-struct ABCProcessInput <: AbstractProcessInput
-    process::ABCProcessDescription
-    inParticles::Vector{ABCParticle}
-    outParticles::Vector{ABCParticle}
-end
+Base type for all particles in the [`ABCModel`](@ref).
+"""
+abstract type ABCParticle <: AbstractParticle end
 
 """
     ParticleA <: ABCParticle
@@ -24,18 +23,53 @@ struct ParticleA <: ABCParticle
     momentum::SFourMomentum
 end
 
+"""
+    ParticleB <: ABCParticle
+
+A 'B' particle in the ABC Model.
+"""
 struct ParticleB <: ABCParticle
     momentum::SFourMomentum
 end
 
+"""
+    ParticleC <: ABCParticle
+
+A 'C' particle in the ABC Model.
+"""
 struct ParticleC <: ABCParticle
     momentum::SFourMomentum
 end
 
+"""
+    ABCProcessDescription <: AbstractProcessDescription
+
+A description of a process in the ABC-Model. Contains the input and output particles.
+
+See also: [`in_particles`](@ref), [`out_particles`](@ref), [`parse_process`](@ref)
+"""
+struct ABCProcessDescription <: AbstractProcessDescription
+    inParticles::Dict{Type, Int}
+    outParticles::Dict{Type, Int}
+end
+
+"""
+    ABCProcessInput <: AbstractProcessInput
+
+Input for a ABC Process. Contains the [`ABCProcessDescription`](@ref) of the process it is an input for, and the values of the in and out particles.
+
+See also: [`gen_process_input`](@ref)
+"""
+struct ABCProcessInput <: AbstractProcessInput
+    process::ABCProcessDescription
+    inParticles::Vector{ABCParticle}
+    outParticles::Vector{ABCParticle}
+end
+
 """
     PARTICLE_MASSES
 
-A constant dictionary containing the masses of the different [`ParticleType`](@ref)s.
+A constant dictionary containing the masses of the different [`ABCParticle`](@ref)s.
 """
 const PARTICLE_MASSES = Dict{Type, Float64}(ParticleA => 1.0, ParticleB => 1.0, ParticleC => 0.0)
 

src/models/abc/print.jl

@@ -0,0 +1,58 @@
+
+"""
+    show(io::IO, process::ABCProcessDescription)
+
+Pretty print an [`ABCProcessDescription`](@ref) (no newlines).
+
+```jldoctest
+julia> using MetagraphOptimization
+
+julia> print(parse_process("AB->ABBB", ABCModel()))
+ABC Process: 'AB->ABBB'
+```
+"""
+function show(io::IO, process::ABCProcessDescription)
+    # types() gives the types in order (ABC) instead of random like keys() would
+    print(io, "ABC Process: \'")
+    for type in types(ABCModel())
+        for _ in 1:get(process.inParticles, type, 0)
+            print(io, String(type))
+        end
+    end
+    print(io, "->")
+    for type in types(ABCModel())
+        for _ in 1:get(process.outParticles, type, 0)
+            print(io, String(type))
+        end
+    end
+    print(io, "'")
+    return nothing
+end
+
+"""
+    show(io::IO, processInput::ABCProcessInput)
+
+Pretty print an [`ABCProcessInput`](@ref) (with newlines).
+"""
+function show(io::IO, processInput::ABCProcessInput)
+    println(io, "Input for $(processInput.process):")
+    println(io, "  Input particles:")
+    for particle in processInput.inParticles
+        println(io, "    $particle")
+    end
+    println(io, "  Output Particles:")
+    for particle in processInput.outParticles
+        println(io, "    $particle")
+    end
+    return nothing
+end
+
+"""
+    show(io::IO, particle::T) where {T <: ABCParticle}
+
+Pretty print an [`ABCParticle`](@ref) (no newlines).
+"""
+function show(io::IO, particle::T) where {T <: ABCParticle}
+    print(io, "$(String(typeof(particle))): $(particle.momentum)")
+    return nothing
+end

src/models/print.jl

@@ -0,0 +1,10 @@
+
+"""
+    show(io::IO, particleValue::ParticleValue)
+
+Pretty print a [`ParticleValue`](@ref), no newlines.
+"""
+function show(io::IO, particleValue::ParticleValue)
+    print(io, "($(particleValue.p), value: $(particleValue.v))")
+    return nothing
+end