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

Week of November 13

Today, I continued my work on radioactive decay and calculating branching fractions. Using the Review of Particle Physics, I found the five most common decays for the D meson, and I calculated the branching fractions for each of those decays. I spent the majority of my time today working on my Python skills, however.

Today, I reviewed writing functions, using the range function, and writing if-else statements. Dr. Bellis gave me the task of writing a Python program that calculates if a number is prime or not and returns all of the prime numbers under 100. Although the part of the program that returned all of the prime numbers under 100 was fairly simple, I couldn't write that section until I wrote the first one. I knew that to calculate if a number was prime or not, I first had to define a range for the computer to calculate from. I defined the range as all the numbers between 2 (since 1 isn't a prime) and 1 + the square root of the number, since there aren't any new factors of a number after its square root. This is what that section looked like:

I had to use the integer function int() which converts all numbers into integers since the range function only works with integers. The if statement "if number % x == 0" basically says "if the number entered is divided by any number in the defined range, and the answer is equal to 0, then return 'False.' If the answer isn't equal to 0, then return 'True.'"

I wrote the section of the program that checks if the number entered by the user is prime, but there were too many bugs for the program to run successfully. Next time I have my internship, I will continue writing and debugging the program.

Week of November 6

Today, Dr. Bellis and I continued our discussion of radioactive decay, with a particular focus on the decay modes for the B meson and for the J/psi particle.

There are several different decay possibilities for any single particle. For example, two possible decay modes for J/psi are J/psi --> e+ e- and J/psi --> μ+ μ-. So, how does one know what a certain particle will decay to? All of a particle's decay modes, the probabilities of these decays, and everything else you could possibly need to know about a particle are published in the wonderful 2012 Review of Particle Physics (which has 1526 pages and a size 10 font).

One important piece of information to know about a decay mode for a particle is its branching fraction. Basically, a branching fraction is the number of particles that decay a certain way over the total number of particles that decay. The Review of Particle Physics publishes the branching fraction for each decay.

Here is a crazy looking graph for the branching fractions of the famous Higgs boson particles, which has many decay channels. This graph shows the branching fraction of the Higgs boson as a function of its mass. Source: Higgs Physics Group at Imperial College London. 

If you have two steps in the decay process, how do you calculate the total possibility of that decay? For example, suppose you want to find the proportion of particles that decay from a B neutral meson to a positive and negative pion. A B neutral meson first decays to a K neutral meson, which then decays into the two pions. You can find the total probability of the decay from a B neutral meson to a positive or negative pion using a simple rule of probability: if two events are independent, then the probability of them both occurring is the product of the probabilities of each occurring. Therefore, to find the total branching fraction for the decay of a B neutral meson to a charged pion, you have to multiply the branching fractions for each separate decay together.

Using this information, I calculated the branching fractions for three different situations. Unfortunately, I had to spend over an hour today in the IT office at Siena since my computer wouldn't connect to the network, so I didn't have much time to do anything else.

Week of October 30

This week, I finally went back to Siena after a two week break! Dr. Bellis and I started off by discussing radioactivity, since I'll be looking at the decay modes of certain mesons.

Radioactive decay occurs when an unstable atom emits particles of ionizing radiation, which results in the nucleus of the atom losing energy. The chance that a given particle will decay is constant over time, although it's impossible to predict exactly when this decay will occur (according to quantum theory). The half life is the time taken for a given amount of a radioactive substance to decay to half of its initial value.

To illustrate this process, Dr. Bellis showed me how to plot the radioactive decay for a particle on Python. Since we couldn't obtain real data, I modeled radioactive decay by shaking pennies in a box and removing all of the pennies that were heads up until there was only one penny left. 

Since the chance that any penny will come up heads on any toss is always the same (50%), about half the pennies are left after the first toss. In this model, the half-life is represented by the time it takes for one half of the remaining pennies to be removed (about one toss). Removing a penny is analogous  to the decay of a radioactive nucleus. 

This picture is what the graph looked like on Python. Radioactive decay has an exponential curve.

Unfortunately, I wasn't able to do any more work since Dr. Bellis had to leave early today. 

Week of October 23

My mentor still wasn't at Siena this week, so I answered some more of the study questions and continued learning Python from Emma.

Here are the study questions I answered:

What is an electron? What is a muon?

Electrons and muons are both classified as leptons.

Electrons are subatomic particles with a negative electric charge. They play an essential role in electricity, magnetism, and thermal conductivity, and they also participate in gravitational, electromagnetic, and weak interactions. Electrons have properties of both particles and waves, and can collide with other particles and can be diffracted like light.

Electrons radiate or absorb energy in the form of photons when accelerated. The antiparticle of an electron is a positron (identical to the electron except with an opposite charge).

A muon is an elementary particle similar to the electron, although it has a much larger mass. It has an electric charge of -1.

Where and when did the BaBar particle physics experiment run?

The BaBar particle physics experiment ran from 1999 to 2008 at the SLAC National Accelerator Laboratory at Stanford.

At the BaBar experiment, what kinds of particle beams did they collide?

BaBar studies the particles produced in collisions between electrons and positrons.