Ben Moskowitz

HONR269L: Dark Matter Research

Jan. 29: Assigned to work on the LZ dark matter research project aiming to understand more of the dynamics of and interactions of the mysterious dark matter. We will be working alongside Professor Bhatti to work on simulations and development of software to analyze data to assist in the experiment. Project will utilize ROOT and Python.

Feb. 5: Set up to meet with Professor Bhatti from 5-6pm on Wednesday’s. This was our first meeting and he gave a presentation describing the theoretical background of the existence and known properties of dark matter. Evidence for dark matter’s existence can be seen through galaxies by tools such as gravitational lensing and x-rays, and it explains phenomena such as the orbital speeds of galactic bodies. The experiment that we will be working on believes dark matter is a WIMP (weakly interacting massive particle), and the LZ detector tries observing the interactions of these WIMPs with Xenon nuclei. Since the detector is not yet complete, there is no physical data for us to work with; therefore, we are going to be working with simulated data based on theoretical calculations and previous measurements. We will be discussing project goals, a timeline, and more specifics about the experiment next meeting.

Feb. 7: Began working on our research. Professor Bhatti gave us an article to read to give us a better understanding of the work that we will be doing, as well as giving us instructions for how we should set up our Tier-3 server. Unfortunately, we encountered permission errors involving retrieving his files in the T3 server, involving the shell and Linux distributions on the cluster. We met with Professor Bhatti to solve it, but we were unable to fix the issue. We will continue trying to figure it out on Sunday. 

Feb. 9: Met as a team and worked out some of the computing issues. Eli figured out how to handle the permission issues over Saturday and helped the rest of us get up to date with the right files and code. In addition, I read over the scientific article on the LZ detector that Professor Bhatti gave to further understand what the detector will do and what types of events we are going to be simulating. Below is a screenshot of the steps to login to my TIER-3 cluster, get Professor Bhatti’s files and access root.

In addition to finishing the setup of the T3 cluster, I checked out some of the code to understand what types of events we will be simulating and the types of graphs we will use.

Feb. 11: Unfortunately I encountered an issue with logging into the T3 cluster. I emailed Sam and he was able to help me reset my password and login again. After getting it back up I got the updated files and began running the code that Professor Bhatti gave us to generate example plots.

Feb 12: Met again with Professor Bhatti. This time we went into much more detail about the actual detector and what types of events we will be simulating. We discussed some of the mathematical properties of WIMPS and how events are processed in the detector, such as the S1 and S2 signals. In addition, we went over the code together to try pinpointing the best way to go about running the simulations and talked about how we should review the code and think about how we can get the most meaningful results. As a group we decided that we would all go over the codes and discuss whatever we came up with. 

Feb 16: Got together and discussed technical details about the code. Discussed how to manipulate the number of events generated, how the plots are produced, the pipeline in order to generate these pots, and what the contents of the important plots were. Compiled a list of questions on this topic to ask Professor Bhatti at our next meeting.

Feb 19: Now that we all had a solid understanding of the code, we met with Professor Bhatti, who explained any of the gaps in our knowledge of what the graphs represented. We went over the process for generation of these graphs, and discussed future graphs that we would like to be producing later in this research. I order to run the code we needed to run the following commands:

This setup root to run and then runs the file containing the code to run the events. Inside the make_H3_plots file contains the location where you can adjust the number of simulated events.

Feb 23: Spent a lot of the week playing around with the codes and understanding what each line affects. Generated lots of plots based on simulation data (26 different PNGs in total). Worked on understanding what the plots represent. Below are a few example plots.

Feb 26: Now that we all were able to generate the graphs and feel more comfortable working with the code, it was finally time to begin reproducing the first graph from the paper! The graph below is what we are trying to produce with our simulated data. The graph is a display of H3 decaying in both ER (blue) and NR (red). Our goal was to take our data (middle graph above) containing the ER data, produce the NR data, and adjust the current code to reformat the data we had to look like the graph below. We struggled quite a bit on this actually, finding it hard to find the exact lines of code that generated this data, getting the NR data, and overlaying the quantile lines. This week we will continue to work on working out these issues to be able to produce the graph.

Mar 1: Today we met as a group to try finishing up generating the above plot with our data. We discovered that it is quite a challenge working in root to merge the 2 files containing the different data (ER and NR data). In order to make the plot, we want to overlay both the existing plots we have, but in order to do this seems to require a very tedious redefinition of the parameters in one of the files. We also had trouble shifting the quantile lines. It seems that the current quantiles are generated through calling values from a stored matrix, and since our data will be displayed differently than Professor Bhatti’s initial graph, we need to generate new quantile lines. We are not sure whether we just calculate them or we get them from another file. We will hopefully get an answer bby tonight, and if not we will make sure to resolve it all for Wednesday.

Mar 4: Eli was able to solve the problem we were having of not being able to overlay the graphs or insert the correct quantile lines. In order for me to get the edits he made to the code, I just copied the new files he created from his directory, and was able to successfully run them and generate the graph below: <insert graph>. In addition, you can see some of the important edits made to the code. <Insert pics of edits>

Lastly, working with emacs was a bit since editing and managing multiple files can be tough, so Eli was able to mount my directory of the cluster to my computer using <insert command> and now I am able to edit with my local text editor of either sublime or VS code! Next steps now are to apply cuts to the graph so we can remove some of the extraneous noise present and to get mean quantile lines only for both the ER and NR data. After doing this we will be able to compare our generated plots with other ones such as seeing how tritium decay would differ. 

Mar 8: I worked for a while trying to just plot the mean quantile lines of both the ER data and NR data on the same plot. It was no problem to get it from the ER data since we were already plotting quantile lines, so I just kept the 50th percentile line and removed others. For the NR data, since we overlaid the plots, we got the data from a separate file, which we needed to get the quantile lines from. I spent some time working through the code to understand how the original quantile lines were plotted, and from there I tried to do a similar thing with the NR data. However, there was an error which I was unable to solve, causing the mean quantile line not to display. I will work on fixing the issue later this week. 

Mar 9: We got everything working! Delina and Eli were able to solve the overlay of the plots, and Eli was able to help get the mean quantile line for the NR data. To quickly go over what these plots represent, the S1Area_phd one represents the recoil energy of both the S1 and logS2 data after preprocessing. Due to the absorption of some energy in the nucleus, NR data tends to have lower energy levels represented, as can be seen by the mean quantile lines. The S2 data is much higher since that is read after passing through many photo-multipliers to strengthen the signal. The raw S1 and S2 graphs represent the raw data from both the H3 data and the WIMP data, allowing us to compare their raw count frequencies. From here our next steps are to apply the cuts found in the LZ paper. These cuts remove background noise such as removing the data from the border of the detector due to the radiation it gives off. We will need to find out how to apply these cuts in our code, which Eli is editing to try making it a bit more organized and readable, making the task of implementing the cuts much easier.

HONR268N: Logbook

Homework 2: 9/10/19

In this homework we got introduced to the linux command structure and got practice testing different useful commands. Here are the some of the commands:

Pwd - prints the directory you are currently in.

Ls <dirPath> - List the files in whatever directory you indicate.

Ls alone will automatically use current directory.

You can also use options -l so each item gets its own line.

Mkdir <dirPath> <dirName> - Makes a new directory with the chosen in the desired location.

Cd <dirPath> - Change the directory to indicated path (cd .. to navigate back 1 directory and cd ~ to navigate to home directory).

rm/rmdir - rmdir will remove an empty directory, while rm will remove anything you specify.

Find <dirPath> <pattern> - Finds items in the directory that match the specified pattern.

Which <pattern> - Navigates to executable file that matches the pattern.

Whoami - Displays the current user of the computer.

Echo <input> - Echoes the input given to the screen. 

Touch <fileName> - Creates a new file with whatever fileName given.

Less <fileName> - View the file and scroll through content. Click ‘q’ to exit.

There are many more commands than these, but these are the pretty basic ones that we have been working with so far. Here is a screenshot of my terminal playing with these commands:

• • • You can see how results gets longer each time since as n gets bigger, the inside loop runs more time, outputting more numbers

• • Debug

    • Debugging is a way to test your code to find the errors

    • There are many ways to debug including cout statements, setting a variable to true to debug (what is done in code to the right), or using debugger programs such as gdb

    • My code sets a variable named idebug to false at the start of my code, then I change it to 1, saying I want to debug, and then in the loop it will output n so I can debug the code.

    • This is useful since only prints statements when you set your debug variable to true

Practical practice of loops and conditionals: 10/3/19

In order to get more comfortable coding in C++, especially with loops and conditionals, I decided I would do a mini project of estimating pi. I have done this before in python and I thought doing it in C++ would be good practice. 

The idea behind the calculation is that you have a unit square of side length 1 and a unit circle of radius 1 inscribed inside. The area of the square is 1 and the circle’s area is pi/4 (pi * ½^2). This allows us to use the relation (area of circle)/(area of square) = (# points inside circle)/(# points inside square), which gives us the equation pi = 4 * (# in circle / # in square) for a large quantity of points. In order to code this I needed to generate random points and see whether they lie inside or outside the circle. I can check this by seeing whether the equation x^2 + y^2 < 1 (or equal to), meaning it lies within the circle. To the side is my code, which approximated pi as 3.14134, which is a relatively accurate estimation. In order to accomplish this I needed to use a for loop to iterate over randomly generated points, and an if statement to check whether the point lies within the circle. Additionally, I needed to look up a couple other parts such as generating random numbers. This was overall a fun mini-project that helped give me a better grasp of how to code in C++.

• • • Here there is nested loops, which iterates over one loop on the outside, and each iteration of that loop the inner loop is fully executed.

    • Additionally, there is an if statement, checking whether n > 5 and m > 50. If both of those conditions are met, the code will output the values of m and n.

    • Throughout the loops I decrement m and n, and reset m as 100 after the loop finishes (it might have made more sense to use for loops so I wouldn’t need to reset the value of m).

• • Pointers

    • A pointer is a way to access the compartment where the computer stores the variable’s information

    • A pointer ‘points’ to the location of the object in memory, and can retrieve both the location and the information stored in that compartment. 

    • The most important aspect of pointers is that they allow for highly effective memory allocation, as to not use too much memory in computationally expensive tasks. 

• • • Here is my own code using the skills I learned in this homework

    • It begins by declaring a pointer with type double equal to pi. P2 is then made and is a pointer to p1, so therefore when I change the value of p1, p2’s value is changed as well

Homework 6: 10/10/19

In this homework I got a much deeper understanding of C++ and learned some more of its functionalities such as arrays, reading/writing files, generating random numbers, classes, and using it to solve real-world questions

• • Arrays:

    • Arrays are used to store bunches of related data of the same type in a single variable, with each element able to be accessed by calling it’s index

• • • Vectors:

    • The above demonstrates using 3 different files in a single code

    • The main script adds the name of the dot product code as to allow it to use the dot_prod method from it

    • Main code then opens the file stream, declares 2 arrays, and stores the data from the vectors.txt script in those arrays

    • Lastly, the code calls the dot_prod function with the vectors received from the txt file, and the dot product is calculated and displayed in the terminal

    • Output:

• • • The general method for producing random numbers is through the rand function and then multiplying that by whatever number you would want your random number to be between. For example, the following code produces a random number between 0 - 100:

• • • Resolutions.C:

    • In this code I needed to add a closing bracket at the end of the code. Initially I put it at the very end, but I realized then after each iteration the graph was saving and updating, causing it to take a very long time to run many iterations. Therefore, I moved the bracket to only update and save after all iterations are complete, and this greatly increased the speed.

• • • Another issue I found a lot of people had was that many people names the secretparameters file secretparameters.tx instead of .txt since there was a typo on the webpage

    • To the right is the output when I have N set to 1. This produces a single randomly generated mass in accordance with the secretparameters file. Since there is only a single observation, no real guess can be made for the true mass of the mother particle

• • • Here I ran the same code, just now with N = 10. Now we can see a bit more of a pattern. You can guess the true mass would probably be around 80-120 from these values, but there is still too little information to make a good guess.

• • • I ran the code again with N = 100, and again we see a similar output. I can make a better guess that the true mass is probably around 90ish now, but 100 data points is still too little information to get a really clear sense of the true mass.

• • • When I run it with N = 1000 we finally start seeing a nice Gaussian distribution. Here you can guess the mass of the mother particle is approximately 90, and almost definitely will fall in a range between 87 - 93. 

• • • Now we change the first number in secretparameters.txt to 1 (instead of 91). Below are the outputs: 

• • • With just 1 point we generated a negative number, and since those are not displayed on the graph, it just saves an empty graph. The more points we include, the clearer you can see the pattern, except from the last graph you can tell that it is a gaussian distribution, however, much of the left side is cut off since the plot does not display negative results.

Homework 7: 10/17/19

• • Madgraphs

    • First I opened firefox and signed up for an account to download madgraphs, and a zip file was downloaded onto my VM

    • I then unzipped the file, created the new directory, and moved my unzipped file into there and began madgraphs

• • •  Unzipping the file from the run:

    • I then downloaded lhe2root.py and ran the command to convert it to root, then ran the root command to see the final file (10/24/19)

• • • The code produced several output files

• • • 1st code:

      • Here we began by declaring new variables, doing a mathematical operation on the variables, and printing the result

    • 2nd code: 

      • We move onto a more useful task, solving for the area of a circle, by defining pi (I estimated it using the first 100 digits) and a diameter, in which I then wrote the formula to calculate the area.

    • 3rd code:

      • This code showed the difference between 2 attempts at changing values

        • The first method doesn’t work since after I set a = b, now all the data in a is the data in b. That means when I now go to set b = a, the data in a is already the same as b, and we lost the initial data that was in a that was intended to copy over

        • In the 2nd method we declare a temporary variable that holds onto the data in a, re-assigns the data in a to be b, then assigns b to the data in the temporary variable

        • The 2nd method is the right way to accomplish the goal

• • • Boolean and conditionals are an essential part of all languages since they provide a way for us to determine whether a condition is true, and then we can perform different operations based on the results

    • 1st code:

      • This is an example of some of the comparators such as ==, >, and !=. These are the core of boolean and conditional statements since they are the operators that will compare the variables whichever way you need

    • 2nd code:

      • This is an example of putting together the concepts of the built-in functions and boolean statements. Here I write a statement that will check whether the square of the minimum value times 10 in my list a is greater than the sum of all the elements in my list.

• • • This type of array can be very useful in certain scenarios, such as making a game board like chess, which can be represented as an 8x8 2d array.

• • • Here is another example of a 2d array, and this one stores information about soccer teams in order from best to worst (higher the row the worse the team).

    • My function returns the captain of the losing team by indexing the last row (pass in -1 as index and it will return the last item), and the 2nd item (index 1), which is where the captain is stored.

    • My use of the -1 allows this to extend to more general cases where you can have lists of 100’s of teams and the function will still return the captain of the worst team.

• • • Code 1:

      • This is a basic example of a for loop in python. We are using the loop to iterate over an array, which means that at each iteration the value of element will be the value of the nth element of the list. This is different from C++ where we used a variable i to count the current index and then get the value by calling my_list[i]. 

      • Since the return false is at the end of the loop, if the logic statement is triggered even once (1 value in the array is a 7), then the function will return true. 

    • Code 2:

      • This is an example of a while loop in python. This syntax is very similar to C++ and the code is a very simple function that will add 1 to a number until it reaches a value including or greater than 10.

    • Code 3:

      • Here is a program I wrote, which is pretty similar to code 1, except here the logic statement uses modulo to check if the number is divisible by 7, and adds 1 to a counter called frequency, which it returns after the loop iterated over all the elements of the list.

• • • Above is some code that uses some functionality from the numpy library to generate data, and create a graph with more than just 2 variables. This demonstrates how easy it is to generate cool data using numpy function such as randn and arange, and how matplotlib can incorporate plotting more variables by using new dimensions such as color and size.