Embedded Files
Background
In our beloved CMS detector exists four different detector layers which detect different types of particles and the paths they take following the collision event. One such of these layers is the Hadron Calorimeter. This layer makes use of plastic scintillators, which emit light when a hadron passes through them. This light is then converted by photomultiplier tubes into a current, a signal that can be processed to glean information about the hadron. Our project specifically focuses on how radiation produced by the particle collision and scattering process affects the performance of these plastic scintillators.
2/12/17
Jacob and I had our first meeting with Professor Eno a couple days ago. For the first half of it, we took a mini-tour of the lab they do the radiation research in and discussed some possible research paths we can take for the semester. One of the things that they do in the lab is letting plastic scintillator samples sit in a black box so that they get hit with cosmic rays. This lets them investigate how the high energy particles interact with the sample. Something that they've wanted to set up for a while is an apparatus that would track the direction of these cosmic rays. Developing a simulation of this system in GEANT would allow us to investigate the optimal configuration of the tracking setup, and this is the type of project we will work on throughout the semester. During the second half of our meeting, Professor Eno gave us some background on how plastic scintillators work. We also got a lot of resources about plastics scintillators and photomultiplier tubes (PMTs), which will be necessary to have a pretty good understanding of if we're to design a simulation surrounding them.
To Do
Review resources on plastic scintillators
GEANT tutorial
Resources
Plastic scintillators-- https://twiki.cern.ch/twiki/bin/viewauth/CMS/UMDScintillatorUpgradeTesting
PMTs-- http://www.hamamatsu.com/resources/pdf/etd/PMT_handbook_v3aE.pdf
Radiation-- https://docs.google.com/file/d/0B_Ce2ncoxFYka2V5US1MR2xvbXM/edit
GEANT tutorial-- https://sites.google.com/a/physics.umd.edu/physhonr268n/tutorials/geant4tutorial
2/21/17
We spent last meeting discussing what we picked up from the readings on photomultiplier tubes.
What I picked up from the PMT readings:
Can split up PMTs into the following different components:
Input window
Photons produced by the scintillator goes in through this "glass" window (read: not always made of normal borosilicate "Pyrex" glass)
Photocathode
Photons hit this material and produce photoelectrons by the photoelectric effect (ratio of photons to electrons is about 1:1)
Dynodes
Multiplies electrons in process called secondary emission so a detectable current can be produced
Anode
Finish line: an electrode collects all the electrons and produces a signal
I came to the meeting with a short list of questions about the project and received some satisfying answers in return:
Why do we use cosmic rays as a particle source when we have better control over other particle sources (i.e. alpha sources?)
Cosmic rays are at a much higher energy, meaning they are much more likely to fully penetrate the scintillator sample than alpha source particles
Why do we want to track the cosmic rays in the first place?
With a tracker, we will be able to tell where the cosmic rays went through the tile
Can use this info to tell if different areas of the tile have different light outputs (e.g. does the middle of the sample read out a weaker signal than the edges?)
Why does the scintillator need to shift light from the UV down to the visible spectrum
UV light tends to get reabsorbed by the material
The material the PMT input window is made of is opaque to UV light
What specifically will we be simulating/looking for?
The tracker will consist of detecting scintillators placed above and below the sample
We will vary characteristics of the detecting scintillators such as spacing between them and total amount to find the optimal tracker configuration
This week's work is going to be fairly similar to last week's; we're going to read up on cosmic rays so we can know what's going on when we start simulating them and continue with more GEANT tutorials.
To Do
Review resources on cosmic rays
More GEANT
Resources
Cosmic rays
http://www.slac.stanford.edu/cgi-wrap/getdoc/slac-tn-95-001.pdf
http://courses.washington.edu/phys433/muon_counting/counting_telescope.pdf
http://onlinelibrary.wiley.com/doi/10.1029/92JA02672/abstract
https://arxiv.org/abs/astro-ph/0403704
https://arxiv.org/abs/hep-ex/0408114
GEANT
https://sites.google.com/a/physics.umd.edu/physhonr268n/exercises#TOC-GEANT
https://sites.google.com/a/physics.umd.edu/physhonr268n/exercises#TOC-Tracker-Exercises
Bonus!!
Something that was just casually sitting on the first page of the PMT reading.
2/28/17
We started working through the GEANT4 exercises. For reference, here is what each class in the src directory of the B4 example does:
B4DetectorConstruction
Defines detector materials and volume
B4PrimaryGeneratorAction
Defines properties of run
# particles
particle momentum/energy
particle type
Set position of particle and initiates event
B4RunAction
Creates histograms and ntuples
Prints and saves histograms
Prints run data
B4aEventAction
Fills histogram and ntuples
Prints event data (e.g. "total energy in absorber...")
B4aSteppingAction
Keeps track of track length and energy deposited in material during each step
B4aActionInitialization
Initializes instances of above classes and implements the simulation
Also, because I keep forgetting it, here's how to run the B4example as a macro (no visualization):
Go to B4build area
source ../G4_Setup.sh
make
./exampleB4a -m run2.mac
Jacob did a cool thing and got our GEANT setup to run through on Eclipse through an integrated development environment (IDE). This makes the code much easier to deal with as apposed to working in emacs.
3/7/17
We were tasked by our mentor to create a plot of the energy deposited in the absorber vs. the resolution of the detector of the B4 example. Towards this end, we have added a argument to exampleB4a so we don't have to to change the code every time we want to run a particle at another energy. Here's an example of you'd run the example for 10 GeV:
./exampleB4a -n 10 -m run2.mac
We will work on writing a program that will go through the histograms produced and make a plot using the histogram's information next week.
3/14/17
We have the successfully been able to create a plot of the energy deposited in the absorber vs. the resolution of the detector of the B4 example. Here's the steps we took to do this:
Run B4 for multiple energies
Make different histograms for each energy, which are stored in /plots
Run makePlot.C
We made a program that goes through all of the plots, extracted all of the energies and their corresponding RMSs and plotted the result
We added another argument (-p) to exampleB4a which will make the program take the necessary plot-making steps.
3/21/17
Spring break!
3/29/17
Just got back from spring break so not much has got done in the past week or so. Looking forward, we'll need to start considering how to construct the scintillators in GEANT4. This will require us to find documentation on the scintillator material, polystyrene, and the scintillator geometry, triangular prisms. Triangular prisms may be a bit tricky, as they appear to be an uncommon detector shape and there doesn't seem to be a class provided by GEANT4 for them.
As per Eno's request, we'll also start working on a 2D histogram of the energy measured by the detector vs. the actual energy of the particle for extra practice.
4/7/17
So good news: we were able to make triangular prisms using the g4polyhedra class! Bad news: the geometry seems to be screwy and doesn't produce expected results when we fire electrons through them. It appears that making triangular prisms through this method was unsuccessful and we will have to try an alternate method.
In other news, the 2D histogram has been implemented and can be used with the -h argument. This was a similar process to making the plot; you can find our work documented on our GitHub.
Here's the link: https://github.com/jeprinz/CosmicRayTracker
4/15/17
We have successfully been able to create working scintillators! There was documentation online that told us how to make triangle prisms using the g4trap class, which can be found here: http://www3.canisius.edu/~wood5/talks/CLAS12MtgFall2010/PCAL-CLAS12Mtg2010.pdf
Our triangular prism making code can be found in the makeTriangle method of the B4Detector construction class.
Looking forward, we will need to create a class that allows the user to easily place scintillators in arbitrary layouts.
4/22/17
We have created a class called "Layout" that allows the user to easily place a number of scintillators at different positions. This now allows a user to generate layouts that can be subjected to simulated muons (cosmic rays). Geant will then produce an rms value for each different layout, which will allow the user to determine which layout will produce an optimal error (minimum error) on the position of the cosmic ray path.
In the next couple weeks we will find a way to verify the rms readings from our simulation as accurate (true to life).
4/29/17
Jacob calculated (meaning using math and not simulation) the hypothetical rms of a rectangular prism given that the incoming particle is coming straight down. His work can be found in his logbook. After we had an expected rms using the formula he produced, we fired muons straight down at a single scintillator to see if the simulated rms would comparable to the expected one. We experimentally found that the rms of a single plastic triangular prism is consistent with that of a rectangular prism with a smaller width, and this was verified by our mentor. We've concluded from this that our simulation s at least somewhat accurate, but future work may include verifying our results in 3D (not just particles coming straight down.)
At this point, we'll spend the rest of our time writing a paper, making a final presentation for the class, and creating a poster based off of our research. I'll add all of them below for further reading when they're finished.
Page updated
Report abuse