Caleb Wheeler

__________________________________________________________________________________________________________________________________________________________________________________]

Search for KK Particles

Week 1:

The first week of our experiment involved meeting with Dr. Agashe to discuss the role that Kaluza-Klein particles might play in explaining the variation of gravitational influence between particles on the quantum scale, and their potential interactions with the Higgs Boson condensate.

            One of the greatest unexplained mysteries of the Standard Model is a phenomenon called the Hierarchy Problem. It is well known that, based on the scale of action between various particle systems, there is a difference between the forces carried by bosons. The influence of gluons is stronger than that of photons, which is stronger than that of W and Z bosons. What remains unaccounted for, however, is the vast difference between the scale of force when comparing electroweak interactions to gravitational interactions per every unit of rest energy in a system. This is the hierarchy problem. The mass of W-Z bosons per energy transferred is much less than that of force carriers for gravity. It is believed that there exists a scale small enough such that it contains the set of all fields of the fundamental forces, called the Planck scale. The Planck scale would be a potentially major unifier of the fundamental forces if they were all forced to interact with each other in the same space.

            There are many different proposals that may potentially explain the reason for such a difference. One reason involves the matter of supersymmetry. Supersymmetry holds that due to conservation of energy, momentum, and charge, when a particle is formed or undergoes dynamics, there is an opposing analog in either time, momentum, or energy such that the net quantity is always preserved. The idea is that the reason why gravity is limited in its influence is because Higgs Bosons have a strong tendency to interact with themselves, which may or may not suggest the presence of another particle.

            Nguyen and I will be studying a separate possibility; the possibility of there being an additional dimension, as the thought experiments physicists Kaluza and Klein suggested. The theory operates as follows: Einstein’s equations suggest that relativity has the capacity of interacting with a compressed space. Given nonlinear dynamics of particles moving at relativistic speeds, the compression of space about a changing center allows particles to interact with space in a way that changes its shape, and how vectors are projected onto it. This was the reasoning for the development of the 4-vector and relativistic changes in projection. There is a possibility that there exists a fifth-spatial dimension that contains some degree of curvature such that the path dynamics of the Higgs-Boson make its influence on the quantum scale much weaker.

            This phenomenon is possible if there exist particles that can compress and contract this fifth-dimensional space in a way that allows the influence of these bosons at different scales to vary. The theoretical particles are called Kaluza-Klein particles. In order to observe these particles, conditions would have to be observed where their decay products are observable and capable enough to interact with Higgs-Boson. Thus, this observation can only occur at energies in the TeV scale.

Week 2:

This week, we learned about the reaction mechanisms that are expected to supply evidence of Kaluza-Klein particles and their reaction mechanisms. The ultimate objective of this task is to simulate the potential production of KK particles so that the results can be experimentally searched for at the LHC. Kaluza-Klein graviton is suspected to be the particle that is responsible for the curvature in this supposed 5th dimension. It is suspected that if two gluons collided, they could produce a KK graviton, which would decay into two radeons, which further decays into two gluons per radeon (for a total of four).

In order to determine the occurrence of such a phenomenon, we would be looking for a rapid change in particles detections as the four-momenta increases.

Of course, other reactions are also capable of producing jets of gluons, so there must be a method of differentiating irrelevant signals (signals from reaction mechanisms that we are not studying), called "background", and the actual signal. This can be done through the analysis of a phenomenon called the four vector. The sum of the four-momenta squared is equal to the mass squared. If the four-momenta do not match that of the signal, than the data can be differentiated as background. The tools MadGraph and Pythia will be used to conduct such simulations.

Tasks for Week 3

-Install MadGraph and Pythia on UMDT3 Cluster

-Add packages that can simulate the collision of gluons

-Practice simulating certain reactions.

Week 3

Operations for this week primarily involved dealing with technical issues surrounding the installation of MadGraph and its dependencies.

First was the operation of installing gfortran. gfortran is an extension of the compiler gcc. A compiler is a program that converts user-input code into another language for readability by another system. In this case, MadGraph is dependent on Fortran in order to compile various dependencies. In order to install gfortran, go to the following site:

http://gfortran.meteodat.ch/download/

-Click x86_64/ 

-Click releases/

-Right-click gcc-8.3.0.tar.xz and click "copy link address"

From there, I typed in the following commands:

ssh cwheele2@hepcms.umd.edu

(for whoever might be reading this, you will put your username before the @ sign.

In my home directory, I typed

wget http://gfortran.meteodat.ch/download/x86_64/releases/gcc-8.3.0.tar.xz 

(this is a paste of the copied address)

This song downloads the specified files at the listed address. From there, I ran:

tar -xvzf gcc-8.3.0.tar.xz

The end result should be:

From there I did cd MG5_aMC_v2_6_7/ and then ran /bin/mg5_aMC

This launches the MadGraph menu. From there, we were tasked with running a couple of trial simulations to practice using Madgraph. The particular commands that were entered were:

p p > t t~ , t > b e+ ve , t~ > b~ mu- vm~

Which produced these graphs:

After that, I attempted to install Delphes and Pythia by using these commands in MadGraph:

install pythia 

install delphes

Unfortunately, errors returned that prevented the downloaded files from even compiling. After looking up the error, I resolved that the reason was likely rooted in a root version that lacked the necessary build binaries in order to conduct the installation.

Thus, I ran 

wget -O root_v6.06.08.tar.gz https://root.cern.ch/download/root_v6.06.08.Linux-slc6-x86_64-gcc4.9.tar.gz

gunzip root_v6.06.08.tar.gz

tar xvf root_v6.06.08.tar

This was about the extent of the operations that I conducted for this week.

For the following week, these were the operations that we were tasked with:

-Running test simulations after adding the packages provided by Mr. Soubhik Kumar

-Begin direct experimentation by running commands with the Kaluza-Klein particles.

Week 4

Problems:

For the first half of the week, experimentation was interrupted by significant technical problems. Delphes and Pythia have continued to fail to install, and cmsenv would not effectively work, so as a result, I had to interrupt the main section of the research to resolve this problem. This was the process that I used in this task:

This error resulted from the command "install delphes". Notice that various files that are imported into the structure are missing. From this, I have determined that whichever environment in which MadGraph was running did not have access to some set of files. The first thing I thought to do was manually install older versions of delphes, as the command installs the newer versions. This was done through running:

wget http://cp3.irmp.ucl.ac.be/downloads/Delphes-2.8.0.tar.gz tar -zxf Delphes-2.8.0.tar.gz  cd Delphes-2.8.0 make -j 4

However, the make command failed to properly operate, which led me to believe that the make required updating. Thus, I attempted to install a newer version of cmake and then set it

to a path variable in my .bashrc file so that I could easily access the command.

I did this to install cmake:

wget -O cmake-3.9.6.tar.gz https://github.com/Kitware/CMake/releases/download/v3.17.0-rc2/cmake-3.9.6-rc2-Linux-x86_64.tar.gz

tar -xzvf cmake-3.9.6.tar.gz

Here, I set cmake to my path variable so that I can override the already available cmake in the Cluster. Testing the call failed, so I did this:

I then proceeded to run the new command, where I then came across another error.

The Solution

As it turns out, my original assessment that there was an issue with the environment in having access to the necessary operating files was correct, but I was directed to the wrong issue. The matter was as simple as installing CMSSW to my home directory, and then moving MadGraph inside of it. CMSSW contains a container that can be launched with cmsenv, and it turned out that it was the necessary command to launch the program. Thus I ran:

cmsrel CMSSW_10_2_6

mv [CMSSW_10_2_6/src/new name of my MadGraph directory] [current path of MadGraph directory]

Afterwards, I ran cmsenv and then proceeded to launch MadGraph by cd'ing into the MadGraph directory and then using ./bin/mg5_aMC. Finally, I ran "install pythia-pgs" and "install delphes"

Next, I used scp [my IP (or personal computer)]:[the file given to us by Mr. Kumar] cwheele2@umd.edu to transfer the Kaluza-Klein particle configuration file, and then moved it to my MadGraph directory.

Week 5

Experimentation

MadGraph was launched with ./bin/mg5_aMC

I ran the following commands:

import KKGravNoFreeLag_v2_1

generate p p > gr, (gr > r r, r > j j, r > j j)

output name of the output file you want to make

launch

From there, 1 was pressed in order to turn on particle shower analysis. Enter was pressed afterwards. Next, 2 was pressed to start the run_card

The top three screenshots show some of the results of actions that were done.

In the run_card, there are four different jets that symbolize the minimum energy that must be carried by the particles to be counted as the signal. The default, in order of jet 1 to jet 4, is 1600 1200 1000 800. From there, the file was saved and closed with Esc->:wq and then enter was pressed to run it. Afterwards, data was collected on the cross-sections. The following combinations were tried, in the same order:

Default -> 1000 runs

Default -> 10,000 runs

1000 1600 1200 800 -> 10,000

800 1000 1600 1200 -> 10,000 -----> Does not develop a cross-section (implying that a KK particle cannot be produced at these energy levels)

1200 800 1000 1600 -> 10,000 -----> Does not develop a cross-section (implying that a particle cannot be produced at these energy levels)

1600 1200 1000 1000 -> 10,000

1600 1200 1200 1200 -> 10,000 ----> Does not develop a cross-section (implying that a particle cannot be produced at these energy levels)

2400 2100 1200 1200 -> 10,000 ----> Does not develop a cross-section (implying that a particle cannot be produced at these energy levels)

The implication is that the KK graviton can only generate signals for energies in the first two jets above 2000 GeV, and 1000 GeV.

______________________________________________________________________________________________________________________________________________________________________

HONR268N: Learning UNIX Commands

Date Completed: 9/15/2019

Date Added to Notebook: 9/23/2019

Here I am practicing with using the commands pwd, ls and its various modifiers, cd, and rmdir. “Print Working Directory”, or pwd, shows the path and name of the current directory that the user is in. List, or ls, shows the size, entry type, read/write permissions, modification date, and executables of entries in a directory. It shows both files and folders. Remove directory, or rmdir, is used to delete directory. Unlike in the Windows system, removed directories are not saved into the recycle bin, so it should not be used carelessly. In the following examples, I am listing the files that are contained within the bin folder in the root directory. The bin is where all the programs that allow Unix commands to operate are stored. As I am dealing with these files, I am using a command called cd, or “change directory”. That command switches my working directory to the path-name that I specify.

Here I am using pwd to show the directory, or folder, that I am working in. I then use ls to display files that are visible to me, and then I use ls -l to display the size of the files, the permissions of the file, and date it was last edited, whether it is a file or directory, and its permissions.

Here, I am listing the long format of the directories and files in this path.

In the image above, the find command is being used to display the path of the file or directory entered into the arguments. Afterwards, I am using which. That command displays the path of a command. The command whoami displays the username of the current user on the system. Echo causes the screen to print whatever input is filtered to the command.

Touch is used to enter data or create the specified file. “cat” has multiple uses, including concatenation, creating files, and most usually, editing them.

Emacs is a text editor. It can be used to script and write prompts, which are then entered into files. By entering emacs -nw, it allows text to be edited in a "new window".

___________________________________________________________________________________________________________________________________________________________________________________

HONR268N: Bash Scripting

Date Completed: 9/25/2019

Date Added to Notebook: 10/1/2019

The objective of this lesson was to learn about developing scripts for the purpose of being able to develop executable commands. This project began by creating a script with emacs -nw testscript.tcsh, which creates a script file that can be edited with Emacs in a new window. The script is identified with the descriptor #!/bin/tcsh. Next, a variable ARG is set to some input, indicated by $1, that is entered in through the terminal. echo $ARG will give the output of the input that was given to ARG. echo "$ARG" will only print "$ARG" since it is given a direct quote. The find command will look in the /usr directory for the value that was input into arg.

#!/bin/tcsh                                                                                                                  

set ARG=$1                                    

echo $ARG                                                                

find /usr  -name "*$ARG*" -print

The first picture is me making and initializing my script. tcsh adds the script to the bin so that it can be used as a command. The second picture shows the result.

These were the next series of commands that were executed:

./testscript.tcsh <argument>

ls –l testscript.tcsh

chmod +x testscript.tcsh

ls –l testscript.tcsh

./testscript.tcsh  <argument>

./testscript.tcsh will have the program look through the previous directory. ls -l will display the permissions of the script file. By using chmod +x, we are able to change permission. In this case in particular, it is making the scriptfile an executable.

______________________________________________________________________________________________________________________________________________________________________

HONR268N: C - Variables and Loops

Date Completed 9/27/2019

Date Added to Notebook: 10/3/2019

In C, g++ compiles the C files, and /a.out (or anything set up as the out file) runs the program.

__________________________________________________________________________________________________________________________________________________________________________________

HONR268N: Pointer

Date Completed 10/1/2019

Date Added to Notebook: 10/3/2019

___________________________________________________________________________________________________________________________________________________________________________________

HONR268N: Arrays and ROOT

Date Completed:

Date Added to Notebook:

The & sign stores the object to memory, instead of creating a new object that has no value from the randomization.

Binary stores values at 2n. Each bit of 1 represents an addition of 2n, with n being the decimal place. 27 + 25 + 24 + 23 + 22 + 21 + 20 = 28-1. Therefore, since there are 8 bits in a byte, if there are n bytes, between 28n-1 and the negative equivalent can be stored.

When the seed is changed, a different random value is generated.

The histogram appears to maintain a flat distribution (roughly) as the calls increase.

___________________________________________________________________________________________________________________________________________________________________________________

HONR HW7: MadGraph

___________________________________________________________________________________________________________________________________________________________________________________

HONR HW8

___________________________________________________________________________________________________________________________________________________________________________________

HONR 268N HW9

pandas = 10

zebras = 20

total_animals_in_zoo = pandas + zebras

print(total_animals_in_zoo)

Output: 30

pi = 3.14159 #Approx.

diameter = 10

#Calculate area of circle

area = pi * (diameter/2)**2

print(area)

Question 1: Method 1 does not work because b is copied into a first, and the values are permanently lost because nothing stores their previous configuration. Method 2 works because there is another variable to store the contents of the array after the original variable is modified.

value = input("Enter a number: ")

numOfDigits = input("How many digits should it be rounded to: ")

def round_to_n_places(val , digits):

  val = float(val)

  digits = int (digits)

  test = val

  space = 0

  #countR (count rational) represents rational digits

  countR = 0

  #holds decimal digits

  dec = 0

  while test > 0:

    test = test // 10

    countR = countR + 1

  test = val

  space = digits - countR

  if test - int(test) > 0 and space > 0:

    print("ree")

    test = test - int(test)

    if (test * (10**space)) - int((test * (10**space))) > 0.5:

      test = int((test * (10**space))) + 1

      test = test * (10**(-1 * space))

    else:

      test = int((test * (10**space))) * (10**(-1 * space))

    return int(val) + test

  else:

    test = test / (10**(countR - digits))

    if test > int(test) + 0.5:

      test = (int(test) + 1) * (10**(countR - digits)) 

    else:

      test = int(test)

    return test 

print(round_to_n_places(value, numOfDigits))

This is what I see when the following code is executed

·            -abs returns the absolute value

·            -min returns the minimum in the array

·            -max returns the maximum in the array

·            -sum adds up the array

·            -length takes the length of the array

·            -sorted sorts the array

\\

a=[3243,645645,54346]

b=[7,3,2]

def product_of_maxes():

  return (max(a) * max(b))

print(product_of_maxes())

Booleans and Logic

print(3 == 10) returns false

print(len('abc')==3) returns true

print(max([10,40,53]) < 25) returns false

print (5 != 3) returns false

Code:

a = [3, 23, 10]

print(min(a) < 5)

print(max(a) > 20)

print(sum(a) % 6 == 0)

The output for a & b is “20 is greater than 10”

a = 30 and b = 20 to meet the first condition

a = 20 and b = 20 to meet the third condition

Output of code set:

print(can_make_cake(10, True, False, True))

Implies that the parameters to the method are booleans and that a cake can’t be made because there is no milk

Redone code with 0 eggs:

print(can_make_cake(0, True, False, True))

a = [-35423,-5432654,-352435,53252]

def abs_of_min_is_odd():

  if abs(min(a)) % 2 == 1:

    print("odd")

  else:

    print("even")

abs_of_min_is_odd()

real_madrid=['zidane', 'ramos', 'marcelo']

barcelona=['valverde', 'messi', 'pique']

teams = [real_madrid, barcelona]

def losing_team_captain(team_list):

  print(teams[1][1])

losing_team_captain(teams)

standings=['mario', 'bowser', 'luigi','peach']

def purple_shell(racers):

  temp = racers[0]

  racers[0] = racers[3]

  racers[3] = temp

  print(racers)

purple_shell(standings)

list=[1,21,7,-14,49,74,700]

def seven_counter(my_list):

  count = 0

  for i in my_list:

    if i % 7 == 0:

      count = count + 1

  print(count)

seven_counter(list)

Dictionary Code

deck={} #represents a deck of cards where the keys are the suits and values are lists of card values

hearts=[]

clubs=[]

diamonds=[]

spades=[]

values=['ace', 'two', 'three', 'four', 'five', 'six','seven', 'eight', 'nine', 'ten', 'jack', 'queen', 'king']

def create_cards(suit):

  for value in values:

    suit.append(value)

create_cards(hearts)

create_cards(clubs)

create_cards(diamonds)

create_cards(spades)

#Use the strings 'h', 's', 'c', 'd' as keys, and add the lists of values to the dictionary.

deck = {

    "h" : hearts,

    "s" : spades,

    "c" : clubs,

    "d" : diamonds

}

#Print a view of dictionary (key, value) pairs

print(deck)

#Print a view of all of the keys

for i in deck:

  print(i)

#Print a view of all of the values

for i in deck:

  for j in deck[i]:

    print(j)

#Remove all of the spades from the deck

deck.pop("s")

#Add a new entry to the dictionary with key 'j' and values 'joker1' and 'joker2'

deck["j"] = ["joker1", "joker2"]

#Clear the dictionary

deck.clear()

The column headings indicate a type of particle. There are 9,509,300 events.

__________________________________________________________________________________________________________________________________________________________________________________