n-Pair Trident Scattering Process
In this file, we set up an n-pair trident scattering process. A trident process looks like $k e^- \to e^- (e^- e^+)^n$.
You can download this file as a jupyter notebook.
using QEDFeynmanDiagrams
We need QEDcore of the QEDjl-project for base functionality and a process type, for which we can use the Mocks
submodule from QEDbase for this tutorial. Downstream, a ScatteringProcess
from QEDprocesses.jl could be used, for example.
using QEDcore
using QEDbase.Mocks
Let's decide how many pairs our trident should produce:
n = 2;
Now we setup the scattering process accordingly. We only consider a single spin/polarization combination here. For an example with many spin and polarization combinations, refer to the n-photon Compton example
proc = QEDbase.Mocks.MockProcessSP(
(Electron(), Photon()), # incoming particles
(Electron(), ntuple(_ -> Electron(), n)..., ntuple(_ -> Positron(), n)...), # outgoing particles
(SpinUp(), PolX()), # incoming particle spin/pols
(SpinUp(), ntuple(_ -> SpinUp(), 2 * n)...), # outgoing particle spin/pols
)
QEDbase.Mocks.MockProcessSP{Tuple{Electron, Photon}, Tuple{Electron, Electron, Electron, Positron, Positron}, Tuple{SpinUp, PolarizationX}, NTuple{5, SpinUp}}((electron, photon), (electron, electron, electron, positron, positron), (spin up, x-polarized), (spin up, spin up, spin up, spin up, spin up))
The number_of_diagrams
function returns how many valid Feynman diagrams there are for a given process.
number_of_diagrams(proc)
252
Next, we can generate the DAG representing the computation for our scattering process' squared matrix element. This uses ComputableDAGs.jl
.
dag = graph(proc)
Graph:
Nodes: Total: 943, QEDFeynmanDiagrams.ComputeTask_SpinPolCumulation: 1, QEDFeynmanDiagrams.ComputeTask_TripleNegated: 150,
QEDFeynmanDiagrams.ComputeTask_PairNegated: 9, QEDFeynmanDiagrams.ComputeTask_CollectPairs: 60, QEDFeynmanDiagrams.ComputeTask_Propagator: 60,
QEDFeynmanDiagrams.ComputeTask_Pair: 60, QEDFeynmanDiagrams.ComputeTask_CollectTriples: 1, QEDFeynmanDiagrams.ComputeTask_Triple: 30,
DataTask: 505, QEDFeynmanDiagrams.ComputeTask_PropagatePairs: 60, QEDFeynmanDiagrams.ComputeTask_BaseState: 7
Edges: 1553
Total Compute Effort: 0.0
Total Data Transfer: 0.0
Total Compute Intensity: 0.0
To continue, we will need ComputableDAGs.jl
. Since ComputableDAGs.jl
uses RuntimeGeneratedFunction
s as the return type of ComputableDAGs.get_compute_function
, we need to initialize it in our current module.
using ComputableDAGs
using RuntimeGeneratedFunctions
RuntimeGeneratedFunctions.init(@__MODULE__)
Now we need an input for the function, which is a QEDcore.PhaseSpacePoint
. For now, we generate random momenta for every particle. In the future, QEDevents will be able to generate physical PhaseSpacePoint
s.
psp = PhaseSpacePoint(
proc,
MockModel(),
FlatPhaseSpaceLayout(TwoBodyRestSystem()),
tuple((rand(SFourMomentum) for _ in 1:number_incoming_particles(proc))...),
tuple((rand(SFourMomentum) for _ in 1:number_outgoing_particles(proc))...),
)
PhaseSpacePoint:
process: QEDbase.Mocks.MockProcessSP{Tuple{Electron, Photon}, Tuple{Electron, Electron, Electron, Positron, Positron}, Tuple{SpinUp, PolarizationX}, NTuple{5, SpinUp}}((electron, photon), (electron, electron, electron, positron, positron), (spin up, x-polarized), (spin up, spin up, spin up, spin up, spin up))
model: mock model
phase space layout: FlatPhaseSpaceLayout{TwoBodyTargetSystem{Energy{2}}}(TwoBodyTargetSystem{Energy{2}}(Energy{2}()))
incoming particles:
-> incoming electron: [0.70775116924521, 0.14068121467573746, 0.3713022323562346, 0.1538118131635875]
-> incoming photon: [0.7303299825618491, 0.18231826441601218, 0.2143475990135847, 0.19766212561352836]
outgoing particles:
-> outgoing electron: [0.6277362747221342, 0.6064755512096093, 0.45018356992197417, 0.5650617101523023]
-> outgoing electron: [0.27843908479735036, 0.20585958678221983, 0.8158791982170412, 0.49028571949646327]
-> outgoing electron: [0.5335758159826485, 0.5906354856927607, 0.7221970636872301, 0.07682903174626199]
-> outgoing positron: [0.3157717324197383, 0.9432233886968963, 0.23323980212024276, 0.706855243342187]
-> outgoing positron: [0.29977260296541564, 0.23694871417269514, 0.10616842207618615, 0.015014064268333072]
With the DAG, the process, RuntimeGeneratedFunctions
initialized, and an input type to use we can now generate the actual computable function:
func = get_compute_function(
dag, proc, cpu_st(), @__MODULE__; concrete_input_type = typeof(psp)
);
Finally, we can test that the function actually runs and computes something by simply calling it on the PhaseSpacePoint
:
func(psp)
0.010133907867323565
We can benchmark the execution speed too:
using BenchmarkTools
@benchmark func($psp)
BenchmarkTools.Trial: 10000 samples with 1 evaluation per sample.
Range (min … max): 28.042 μs … 104.456 μs ┊ GC (min … max): 0.00% … 0.00%
Time (median): 30.617 μs ┊ GC (median): 0.00%
Time (mean ± σ): 31.145 μs ± 2.538 μs ┊ GC (mean ± σ): 0.00% ± 0.00%
▂██▄▂▂ ▁▁▁ ▂
▅▄▁▁▁▁▃▁▁███████▇▇▇▆▆▆▆▇▆▄▅▄▄▅▁▄▁▅▄▄▅▄▅▁▄▄▃▄▃▁▄▃▁▄▆████▇▆▆▆▄ █
28 μs Histogram: log(frequency) by time 41.9 μs <
Memory estimate: 256 bytes, allocs estimate: 2.
This page was generated using Literate.jl.