Week of December 18

At my internship with my code and graphs

The blog assignment for two weeks ago was to post a picture of ourselves at our internship,  but I unfortunately wasn't there that week. So, I decided to make up that assignment this week. Here's a picture of me with my code. Happy Winter Break!

Week of December 11

I finally started looking at some actual data! Yay!! Since I missed quite a few weeks this semester, I had to do a lot of independent work. I spent most of my time learning technical skills (such as how to code in Python and the basics of particle physics). Though learning on my own was challenging, I now feel prepared and (somewhat) confident in my particle physics knowledge.

Dr. Bellis sent me a csv file (which is sort of like an Excel file) with some data. It's very similar to the files from the BaBar experiment that I'll be looking at. To give you an idea of the scope of this specific file, it contained 100,000 rows and 18 columns. (Almost 2 million data points!) That's huge, but not as immense as the BaBar data: if all of the BaBar data represented the planet, then this file would be equivalent to a mere atom.

Here are the columns of the data:

The RunNo (the run number of the particle detector), EvNo, and the eta and phi columns were all irrelevant, and I didn't include them in my data analysis.

The detector measures the momentum and energy (among other things) of daughter particles produced from the decay of each original particle. The 1 or 2 in each column indicates the first or second daughter particle, respectively. E represents the energy of the particle, and p represents the momentum (px, py, pz, and pt represent the x, y, z, and t components of momentum). Q is the charge of the particle (either -1 or +1).

So, what are these daughter particles, anyway? My job was to run a code on Python that figured this out.

If you know the mass of a particle, you can figure out what the actual particle is. (Thanks to the 1500 page Particle Physics Review, which lists all particles with everything you could ever want to know about them). The key is using the momentum and energy of the particle to find the mass.

Albert Einstein's famous equation E=mc² relates the energy (E) and mass (m) of a particle, where c is the speed of light (a constant). However, Einstein's equation isn't actually completely correct.  Dr. Bellis explained to me that since particles have velocity, the momentum (mass times velocity) of the particle has to be taken into account, too. The complete version of the equation is: E²=m²c⁴ + p²c², where p=momentum. 

Using this information, I wrote code on Python that graphed the mass of both the parent and daughter particles on a histogram. 

The section of the code that graphs the first daughter particle. The first line imports the csv file Dr. Bellis sent me, the second line identifies which columns of the code I am looking at, and the next lines use the equation relating momentum, energy, and mass to plot a histogram of the mass of this particle. 

Graph of the first daughter particle.

Using the information from the graph and the Particle Physics Review, I figured out that the first daughter particle is a muon. Next, I graphed the mass of the parent particle 

The next section of my code reconstructed the mass of the parent particle. The .csv file that Dr. Bellis sent me only had data for the daughter particles, since parent particles are often hard to measure in detectors. It's very simple to reconstruct parent particles from daughter particles, however, since the energy and the components of momentum for each daughter particle add up to equal the energy and components of momentum for each parent particle.

For example,  E1 (energy of first daughter particle) + E2 (energy of second daughter particle)= E (energy of parent particle).

Don't get this confused like I did the first time-- the masses of the two daughter particles do not add up to the mass of the parent particle! Mass can be converted into energy and vice versa, so some of the parent particle's mass becomes energy during the decay.

A graph of the parent particle. The bump represents the mass of the particle, which is an upsilon particle. 

 Once I had found the daughter and parent particles, I played around with my code a little bit. I set parameters for the charge, and only graphed the neutral particles, and I also compared the masses of the particles on one giant graph.

It was very cool to be able to take millions of numbers and reconstruct an entire particle from them. I realized that while particle physics can be very intimidating, it can also be very simple at its core: everything relates back to the one equation, E²=m²c⁴ + p²c².  I found one very tiny bump on a graph that proved the existence of a particle, which is the same thing that the scientists who discovered evidence of the Higgs Boson did. Yay for finally putting all my technical skills to use!

Weeks of November 20 to December 4

Due to an unlucky combination of events (and Thanksgiving break), I didn't have my internship for three weeks in a row. However, I still did some work on my own at home.

My main task was to finish writing my Python program that calculates if a number is prime or not and returns all primes under 100. Here's the completed program:

I started off by defining a function is_prime. I told Python that for the is_prime function, if a number is divided by the value "x" in the defined range and the answer is 0, then the statement is false. If the answer is not 0, then the statement is true.

In the next section, the raw_input function prompts the user to enter a number, which is set equal to the variable "number". The int() function is around this section since Python can only perform certain calculations if it's explicitly told that a number is an integer. Since I defined the is_prime function in the previous section, I can now use an if-else statement to tell the user whether the number they entered is prime or not.

This is what the user sees. Once they enter an integer (I entered 104), Python tells them whether the number is prime or not.

The next section prints out all the prime numbers under 100. Again, I defined the range and used the is_prime function to only return the prime numbers. This is what the user sees now:

All the prime numbers under a 100

I'm happy that this Python program was a success!

Another one of my tasks was to write down all the charge permutations for the decay of the hybrid meson (psi/g).


The psi/g is neutral. If the psi/g exists, it is predicted to decay to two particles called a D2 and a D. Now, the D2 decays to a D* and a pi. When the D* decays (ether from the psi/g or the D2), it decays to a D and a pi. Based on the law of conservation of energy, I came up with the following charge permutations that result in D mesons:

1) psi/g --> D2+  D-

                D2+ --> D*0  pi+

                            D*0  -->  D0  pi0

2) psi/g --> D2+  D-

D20 → D*+  pi-

D*+ → D0  pi+

3) psi/g --> D2+  D-

D20 → D*+  pi-

D*+ → D+  pi0

4) psi/g → D2+  D*-

D2+ → D*0  pi+

D*0 → D0  pi0

5) psi/g → D20  D*0

D20 → D*  pi-

D*+ → D0  pi+

6) psi/g → D20  D*0

D20 → D*  pi-

D*+ → D+  pi0