WIP

examples/congruent_in_ph.jl

@@ -0,0 +1,123 @@
+using MetagraphOptimization
+using QEDbase
+using QEDcore
+using Random
+using UUIDs
+
+RNG = Random.MersenneTwister(123)
+
+function mock_machine()
+    return Machine(
+        [
+            MetagraphOptimization.NumaNode(
+                0,
+                1,
+                MetagraphOptimization.default_strategy(MetagraphOptimization.NumaNode),
+                -1.0,
+                UUIDs.uuid1(),
+            ),
+        ],
+        [-1.0;;],
+    )
+end
+
+function congruent_input(processDescription::QEDProcessDescription, omega::Number)
+    # generate an input sample for given e + nk -> e' + k' process, where the nk are equal
+    massSum = 0
+    inputMasses = Vector{Float64}()
+    for (particle, n) in processDescription.inParticles
+        for _ in 1:n
+            massSum += mass(particle)
+            push!(inputMasses, mass(particle))
+        end
+    end
+    outputMasses = Vector{Float64}()
+    for (particle, n) in processDescription.outParticles
+        for _ in 1:n
+            massSum += mass(particle)
+            push!(outputMasses, mass(particle))
+        end
+    end
+
+    initialMomenta = [
+        i == 1 ? SFourMomentum(1, 0, 0, 0) : SFourMomentum(omega, 0, 0, omega) for
+        i in 1:length(inputMasses)
+    ]
+
+    # add some extra random mass to allow for some momentum
+    ss = sqrt(sum(initialMomenta) * sum(initialMomenta))
+
+    result = Vector{QEDProcessInput}()
+    sizehint!(result, 16)
+
+    spin_pol_combinations = Iterators.product(
+        [SpinUp, SpinDown], [SpinUp, SpinDown], [PolX, PolY], [PolX, PolY]
+    )
+    for (in_spin, out_spin, in_pol, out_pol) in spin_pol_combinations
+
+        # get the electron first, then the n photons
+        particles = Vector{QEDParticle}()
+
+        for (particle, n) in processDescription.inParticles
+            if particle <: FermionStateful
+                mom = initialMomenta[1]
+                push!(particles, particle(mom, in_spin()))
+            elseif particle <: PhotonStateful
+                for i in 1:n
+                    mom = initialMomenta[i + 1]
+                    push!(particles, particle(mom, in_pol()))
+                end
+            else
+                @assert false
+            end
+        end
+
+        final_momenta = MetagraphOptimization.generate_physical_massive_moms(
+            RNG, ss, outputMasses
+        )
+        index = 1
+        for (particle, n) in processDescription.outParticles
+            for _ in 1:n
+                if particle <: FermionStateful
+                    push!(particles, particle(final_momenta[index], out_spin()))
+                elseif particle <: PhotonStateful
+                    push!(particles, particle(final_momenta[index], out_pol()))
+                end
+                index += 1
+            end
+        end
+
+        inFerms = MetagraphOptimization._svector_from_type(
+            processDescription, FermionStateful{Incoming,in_spin}, particles
+        )
+        outFerms = MetagraphOptimization._svector_from_type(
+            processDescription, FermionStateful{Outgoing,out_spin}, particles
+        )
+        inAntiferms = MetagraphOptimization._svector_from_type(
+            processDescription, AntiFermionStateful{Incoming,in_spin}, particles
+        )
+        outAntiferms = MetagraphOptimization._svector_from_type(
+            processDescription, AntiFermionStateful{Outgoing,out_spin}, particles
+        )
+        inPhotons = MetagraphOptimization._svector_from_type(
+            processDescription, PhotonStateful{Incoming,in_pol}, particles
+        )
+        outPhotons = MetagraphOptimization._svector_from_type(
+            processDescription, PhotonStateful{Outgoing,out_pol}, particles
+        )
+
+        processInput = QEDProcessInput(
+            processDescription,
+            inFerms,
+            outFerms,
+            inAntiferms,
+            outAntiferms,
+            inPhotons,
+            outPhotons,
+        )
+
+        push!(result, processInput)
+    end
+
+    return result
+end