Tag Archives: aDetector

aDetector

One of the projects I have wanted to develop for a long time is a browser based particle physics experiment simulator. Such a project would generate events using Monte Carlo methods and simuate their interactions with the detector. This was made partly as an educational aid, partly as a challenge to myself, and partly because at the time I was feeling some frustration with the lack of real analysis in my job. As expected for a Javascript based CPU intensive appplication, this reaches the limits of what is possible with current technology quite rapidly.

Links

Live page V1
Live page V2
Live page V3
Live page V4
Live page V5
GitHub repository

Overview

The model for the detector is saved in an xml file which is loaded using the same methods developed in the Marble Hornets project. Particle data are currently stored in Javascript source files, but will eventually use xml as well. The particle interactions are simulated first by choosing a process (eg \(e^+e^-\to q\bar{q}\)) and then decaying the particles. Jets are formed by popping \(q-\bar{q}\) pairs out of the vacuum while phase space allows and then arranging the resulting pairs in hadrons. Bound states are then decayed according to their Particle Data Group (PDG) branching fractions, with phase space decays used. The paths of the particles are propagated through the detector using a stepwise helix propagation. Energy depositions in the detector are estimated, according to the characteristic properties of the detector components. A list of particles is then compiled based on the particles produced and these can be used to reconstruct parent particles.

The user has access to several controls to interact with the application. They can choose how to view the detector, using Cartesian coordinates and two Euler angles (with the roll axis suppressed.) The most expensive parts of the process are the generation of the event displays and the generation of the particle table. By default these are only updated after a certain interval, to allow the user to accumulate a significant number of events without being slowed down by the graphics. To save time the detector itself is rendered once in a cutaway view, and the particle tracks are overlaid on the saved image. Eventually the user will be able to get a full event display, including the detector response to the particle with glowing detector components etc.

The user has access to collections of particles, including electrons, muons, pions, kaons, photons, and protons. From these they can construct other particles, making selections as they do so. Once they have made parent particles they can then plot kinematic variables including mass, momentum, transverse moment, and helicity angle. This should, in principle, allow students to learn how to recreate particles and how to separate signal from background effectively.

Given the large amount of information available the user has access to a number of tabs which can can be collapsed out of view. This allows the user to run the application with the expensive canvas and DOM updates, and thus collect many more events.

This is still a work in progress, with reconstruction of particle being the next main priority. Eventually the user would be able to load their favourite detector geometry and beam conditions, then perform their analysis, saving the output in xml files and possible being able to upload these to a server. This would allow users to act as “players” with “physics campaigns”, including the SPS experiments, HERA experiments, B factories, LEP experiments, and LHC experiments. This is, of course, a very ambitious goal, and one which has been ongoing for over a year at this point.

See other posts tagged with aDetector.

Challenges

Challenge: A sophisticated model for the detector was needed.
Solution: The detector is split up by subdetector, with each subdetector having its own characteristic responses to different particles. The detector is split up in cylindrical coordinates, \((
ho,\eta,\phi)\), with each subdetector also being split into modules. Individual modules then react the particles for reconstruction purposes. Thus with a few key parameters even a sophisticated model can be stored in a few variables that can be tuned quickly and easily. (Resolved.)
Challenge: The detector shold have a three dimensional view that the user can control.
Solution: The detector is drawn using a wireframe with transparent panels. This is a method I developed in 2009 for a now defunct PHP generated SVG based visualisation of the BaBar electromagnetic calorimeter, which I used to show the absorbed dose as a function of detector region and time. The drawing algorithm is not perfect, as panels are drawn in order from furthest from the user to closest. This is sufficient for most purposes, but occasionally panels will intersect causing strange artefacts. Eventually this should be replaced with a much more stable, robust, and fast implementation, such as in three.js. (Resolved, to be revisited.)
Challenge: Particles should be modeled realistically and physically correctly.
Solution: Particles are modelled with the most important parameters (mass, charge, decay modes etc) taken from the PDG. Their kinematic properties are modeled using special four vector classes, and decay products “inherit” from their parents in a consistent manner. Particles at the highest layer of the tree are assigned their four momenta, and then their decay products are decayed, inheriting the boost and production vertex from their parents. This is repeated recursively until all unstable particles are decayed. So far this does not take spin into account, as everything is decayed using a phase space model. Particles with large widths have their lineshape modeled using a Breit-Wigner shape. As a result, particle have realistic looking jets and four momentum is conserved. This required the development of special libraries to handle these decays and kinematic constraints. (Resolved, to be revisited.)
Challenge: Particles decay trees must be traversed consistently.
Solution: This is harder than it sounds! Every time an event is generated, particles are recursively decayed for as long as phase space allows. The particles must then be traversed and dispalyed in the table, in a consistent manner. Ensuring that all particles are listed hierarchally without missing anything out takes some care. (Resolved.)
Challenge: Particles lists had to be prepared for the user.
Solution: The user has access to a handful of “building blocks” to play with. These are taken from the (generated) list of particles per event and filtered by the particle type. Further lists can be created or filtered from these lists, and parent particles can reconstructed from combining lists. This means having to provide special classes to handle the particles and ensure that no particles are reconstructed recursively (leading to infinite loops.) Apart from using reconstructed particles instead of generated particles, this has been resolved. (Resolved, to be revisited.)
Challenge: The user needs to be able to make histograms.
Solution: I had made histgorams for other projects, including the Reflections and Box plotter projects, so this was mostly fairly easy to do. Even so, being able to create new histograms of arbitrary scales and variables on the fly meant that this histogram class had to be more robust than previous projects. (Resolved.)

Screenshot

Screenshot of aDetector V5
Screenshot of aDetector V5

aDetector update

My most recent project, aDetector, is coming along nicely. After a few more days of development it’s reached the stage where a detector can be assembled from a series of tracking systems and calorimeters, and simulate the decay of \(J/\psi\) mesons to pairs of leptons. The leptons propagate through the detector, following helical paths in the presence of a uniform magnetic field, and lose energy as they interact with the various components in ways characteristic to each particle and component.

The project provides three views of the detector, to allow the user to have a complete view of each event. The event displays are generated using a completely home made graphics library, where the user is able to change the position and angle of the “camera” viewing the detector. To save CPU time the complete display is only regenerated whenever the user change the position of the view, freeing up the CPU for event generation.

aDetector event display, showing J/Ψ→ee
aDetector event display, showing J/Ψ→ee

New project in development: aDetector

One of the projects I’ve wanted to put together for a long time is a very simple particle detector simulation that gives the user an idea what it is like to perform a physics analysis at and LHC experiment (or other experiment). The requirements are quite challenging:

  • The software must work on any system without the need for an installation process. (ie It should be web based and work within the browser, preferably without special plugins.)
  • The results must be relatively realistic, calling on help from experts if necessary. Fortunately I know many experts who can help with this, and my own knowledge and resources will get me most of the way.
  • The software must be extendable and in particular, capable of simulating many different detectors of arbitrary geometry and complexity.
  • While some steps can involve special software (such as the pythia particle event generator) the files used for the running of the program must be easily readable, with a preference for the xml format.
  • The software must be intuitive and attractive to the user.
  • The software must be “light” so that it can be used on almost any system.

There are probably many additional requirements which will arise later, but this is plenty to be getting on with.

Overall design concept

The software will be written in Javascript, with artwork in the canvas. The user will have several views of the detector, which will “collect” (generate) data and accumulate results. The user can then choose how to combine the detected particles to search for a signal, generate a mass peak, and then make a discovery.

The particles will be generated randomly, with background and signal processes similar to those in the relevant experiment. The detector will be a series of modules that can be taken in and out. The particles will traverse the detector components and “interact” in a very simple manner, giving a list of particle candidates.

First trials

The first component I made was a cylindrically symmetric tracking system, capable of detecting charged particles. Then I simulated \(J/\psi\to ee\) events to see what the results would look like before and after passing the particles through the tracker. The tracker should not provide perfect measurements of the particle momenta, so the reconstructed momenta must give peaks with equal areas, but larger widths than the true momenta. You can see some screenshots below:

Simulation of J/Ψ→ee
Simulation of J/Ψ→ee before and after interaction with the tracker. The generated and reconstructed samples are statistically independent.
Screenshot of the first tracker model with a J/Ψ→ee event
Screenshot of the first tracker model with a J/Ψ→ee event

Random numbers

One of the first problems I had to solve was how to generate a random number for a given distribution. It turns out this is relatively simple; for a function \(y=f(x)\) simple invert the function to get \(x=f^{-1}(y)\) then take a random uniform number for \(y\). For example, for a Cauchy distribution we have:

\[
y = \frac{1}{\pi}\frac{\gamma}{\left(x-x_0\right)^2+\gamma^2} \\
x = x_0 \pm \sqrt{ \frac{\gamma}{\pi y} – \gamma^2 }
\]

It feels good to have finally gotten around to solving this problem. If I’d have known it was this simple I’d have done this long ago instead of using the accept-reject method!