Week of January 29

Yayyy!!! I finished our calculations!!! I'm one step closer to becoming an actual scientist :) Basically, our calculations predict the number of D mesons produced from one billion B mesons. They are so simple that anyone who knows the laws of probability can do them. The key is just knowing the decays for each particle and what numbers to actually multiply together.

Here are the decays each B meson goes through to get to a D meson:

Number of B Mesons: 1 billion

B => B0 Bbar0: 500 million

B => B+ B- =500 million

B+- => K+- psi/g =1%

B0 => K0 psi/g= 1%

psi/g => D2(2460) D

psi/g => D2(2460) D*

psi/g => D1(2420) D

psi/g => D1(2420) D*

So, as you can see, we start off with one billion B mesons. 500 million mesons decay to B neutral Bbar neutral mesons, and 500 million decay to B+ and B- mesons. The charged B mesons then decay to charged kaons and psi/g particles, and the neutral B mesons decay to neutral kaons and psi/g particles. The psi/g particles then decay to our four different types of particles: the D2(2460), D1(2420), D, and D* mesons. (The number in parentheses just tells the mass of the meson.)

The BaBar detector isn't 100% efficient, and its efficiency varies depending on the particle. So, while the efficiency for the charged kaon was a solid 95%, the efficiency for a neutral kaon was only 40%. We had to take all of this into account when making our predictions. Here are all of our efficiencies:

B+- => K+- psi/g =1%	efficiency for K+-: 95%
B0 => K0 psi/g= 1%	efficiency for K0: 40%

However, just because the detector will be able to detect a certain decay doesn't mean that that decay will actually happen in the first place. We also have to take the branching ratios of the decays into account. As I explained in an earlier blog post, the branching ratio is the probability that a certain decay will actually take place. Here are the branching ratios we came up with:

psi/g => D2(2460) D	BR: 25%
psi/g => D2(2460) D*	BR: 20%
psi/g => D1(2420) D	BR: 25%
psi/g => D1(2420) D*	BR: 20%

Once I had all the assumptions, I could finally get started on the actual calculations! This was probably the easiest part of the whole process; all I had to do was multiply the right percentages together to get the final number of D mesons produced. Here are the calculations:

Calculations:
(5.0 x 10^8 charged B mesons)(1%)= 5.0 x 10^6 K+- psi/g		(5 x 10^8)(1% BR)(40% efficiency)= 2.0 x 10^6 K0 psi/g
(.95)(5.0 x 10^6)= 4.75 x 10^6 K+- psi/g
psi/g => D2(2460) D
(.25)(.01)(.05)(4.75 X 10^6)= 593.75		(.25)(.01)(.05)(2.0 x 10^6)= 250
psi/g => D2(2460) D*
(.2)(.01)(.03)(4.75 x 10^6)= 285		(.2)(.01)(.03)(2.0 x 10^6)= 120
psi/g => D1(2420)D
(.25)(.05)(.01)(4.75 x 10^6) = 593.75		(.25)((.05)(.01)(2.0 x 10^6)= 250
psi/g => D1(2420)D*
(.2)(.03)(.01)(4.75 x 10^6)= 285		(.03)(.01)(4.0 x 10^5)= 120

Our numbers were actually a lot better than we were expecting. From one billion B mesons, about 2500 D mesons will be produced (and actually detected). This is a good enough number to continue on with our work.

Of course, this all depends on if the assumptions we made were correct. To get a second opinion, Dr. Bellis is going to send the assumptions and calculations we made to the BaBar researchers at Stanford. If they agree with what we have come up with, then they will send us the rest of the BaBar data, which is when the real fun will begin. That's when all my Python and data analysis skills will come in handy. Fingers crossed!

Week of January 22nd

Q: What did Donald Duck say in his graduate physics class?
A: Quark, quark, quark!

Happy Lame Physics Jokes Day! Today, I was only at my internship for about an hour because of MLK Service Day and because my mentor had to leave a little bit early. I was also recovering from a cold, so I wasn't completely mentally functional. I still got some work done though!

To do our calculations for the hybrid meson, we have to come up with a list of assumed efficiencies for the particles involved in the decay. I started working on our list of assumptions today. The Particle Data Review was, as always, a really helpful source, but it was sometimes difficult to decipher all of the different numbers. I also used the paper Dr. Bellis gave me last week to come up with efficiencies for the D(2420) and D(2460) mesons. Next week, I'll be using these assumptions to actually finish the calculations, which I'm excited about!

Something cool that happened this week was that my particle physics booklet from the Particle Data Group came in the mail. This tiny booklet contains almost everything you need to know about the universe. It has the decays, branching ratios, masses, and pretty much any information you could ever want about a particle. Dr. Bellis has the full-sized version of this booklet in his office, but I ordered this free booklet so I can look up information when I'm working from school. Here's a picture of what the booklet looks like:

Week of January 15

Happy New Year! At the end of last semester, I was at a pretty good place with my internship. I'd spent a good amount of time learning technical skills, and by the last few meetings, I had started writing code for data analysis. This semester,  my first goal is to finish the preliminary calculations for the hybrid meson. Here's a quick recap to remind you:

From 1999 to 2008, the SLAC National Accelerator Laboratory at Stanford conducted the BaBar experiment, which involved hundreds of researchers using the BaBar detector, a multilayer particle detector, to study the difference or disparity between the matter and antimatter content in the universe. The experiment is no longer running, but there are years of data that have yet to be analyzed. My job is to run a code on Python that analyzes a very specific section of the data to determine whether or not it is worth further analysis. In particular, I am searching for evidence of a new type of particle called an exotic meson, which has already been predicted to exist.

The calculations are actually much simpler than the data analysis on Python I've been doing. All I have to do is figure out how many of these mesons we can expect to see in the data (if they do in fact exist). But, before I do my calculations, Dr. Bellis wants me to understand a little bit more about the BaBar experiment itself. 

So, to give me an idea of the sort of work that scientists at BaBar did, he gave me a paper that he co-authored at Stanford to read. It's called (get ready for it, it's a mouthful) "Observation of new resonances decaying to D/pi and D*/pi in inclusive e+e- collisions near s=10.58 GeV." The paper basically describes a certain type of decay that the BaBar detector measured. It was really cool to read the paper and see that they included mass distribution graphs for the particles, which are the same graphs that I've been making in Python!

The detector measures the momentum of charged particles using a huge magnet, which contains an SVT or silicon vertex tracker and a DCH or drift chamber. The SVT consists of five layers of double-sided silicon detectors, which transmit the position measurements of the particles to an integrated circuit. The DCH is a gas-filled chamber that provides the momentum measurements for charged particles. Here's some more information about the components of the detector: http://www.slac.stanford.edu/BFROOT/www/doc/workbook/detector/detector.html

The link also explains why the magnet is important: "Without a magnetic field, a tracking device could not measure charge or momentum, but only position. But when a magnetic field is present, the charged tracks curve, and the charge and momentum of the particle can be determined from the direction and curvature of the track."

Although I won't be directly using this information, it was still fascinating to learn, and it gave me a good sense of how intricate this experiment really was.

The paper also provided a great table listing the resonance, efficiency, mass, and width (among other things) of certain D mesons. I'll be using some of these numbers in my calculations, so it was really helpful to see where these numbers actually came from and how they were calculated.

I spent most of my time trying to make sense of the paper. It was pretty hard to get through, especially since I didn't understand every other word used. At first, I was intimidated by all the technical language and crazy looking graphs, but then I realized that a lot of the calculations that the physicists did just came from the mass-energy-momentum equivalence. Most of particle physics is intimidating at first, but, like the universe, it is remarkably simple at its core.

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.