How-to-rediscover-the-Z.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<CENTER><img src=\"images/ATLASOD.gif\" style=\"width:50%\"></CENTER>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How to rediscover the Z boson yourself!\n",
    "This notebook uses ATLAS Open Data http://opendata.atlas.cern to show you the steps to rediscover the Z boson yourself!\n",
    "\n",
    "The idea is that you run this notebook as-is, then go through the tasks at the bottom to improve your study of the Z boson.\n",
    "\n",
    "The datasets used in this notebook have already been filtered to include exactly 2 leptons per event, so that processing is quicker.\n",
    "\n",
    "Feynman diagram pictures are borrowed from our friends at https://www.particlezoo.net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<CENTER><img src=\"images/Zee_feynman.png\" style=\"width:50%\"></CENTER>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First time setup on your computer (no need on a web browser)\n",
    "This first cell only needs to be run the first time you open this notebook on your computer. \n",
    "\n",
    "If you close Jupyter and re-open on the same computer, you won't need to run this first cell again.\n",
    "\n",
    "If you open on binder, you don't need to run this cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "!{sys.executable} -m pip install --upgrade --user pip\n",
    "!{sys.executable} -m pip install -U numpy pandas uproot matplotlib --user"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## To setup everytime\n",
    "Cell -> Run All Below\n",
    "\n",
    "to be done every time you re-open this notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import uproot # for reading .root files\n",
    "import pandas as pd # to store data as dataframe\n",
    "import time # to measure time to analyse\n",
    "import math # for mathematical functions such as square root\n",
    "import numpy as np # # for numerical calculations such as histogramming\n",
    "import matplotlib.pyplot as plt # for plotting\n",
    "from matplotlib.ticker import MultipleLocator # for axis ticks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='fraction'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "General definitions for fraction of data used, where to access the input files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "fraction = 0.01 # reduce this is you want the code to run quicker\n",
    "                                                                                                                                  \n",
    "tuple_path = \"Input/Data/exactly2lep.\" # local\n",
    "#tuple_path = \"http://opendata.atlas.cern/release/samples/Data/\" # web address"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='samples'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "samples to process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "samples_list = ['DataEgamma'] # di-electron pairs only\n",
    "#samples_list = ['DataEgamma','DataMuons'] # also available if you want to add data for di-muon pairs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define function to get data from files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data_from_files():\n",
    "    \n",
    "    frames = [] # define empty list to hold data\n",
    "    for val in samples_list: # loop over each file\n",
    "        fileString = tuple_path+val+\".root\" # file name to open\n",
    "        temp = read_file(fileString,val) # call the function read_file defined below\n",
    "        frames.append(temp) # append dataframe returned from read_file to list of dataframes\n",
    "        data_frame = pd.concat(frames) # concatenate list of dataframes together into one dataframe\n",
    "    \n",
    "    return data_frame # return single dataframe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define function to calculate diphoton invariant mass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_mll(lep_pt,lep_eta,lep_phi):\n",
    "    # first lepton is [0], 2nd lepton is [1] etc\n",
    "    \n",
    "    px_0 = lep_pt[0]*math.cos(lep_phi[0]) # x-component of lepton[0] momentum\n",
    "    py_0 = lep_pt[0]*math.sin(lep_phi[0]) # y-component of lepton[0] momentum\n",
    "    pz_0 = lep_pt[0]*math.sinh(lep_eta[0]) # z-component of lepton[0] momentum\n",
    "    px_1 = lep_pt[1]*math.cos(lep_phi[1]) # x-component of lepton[1] momentum\n",
    "    py_1 = lep_pt[1]*math.sin(lep_phi[1]) # y-component of lepton[1] momentum\n",
    "    pz_1 = lep_pt[1]*math.sinh(lep_eta[1]) # z-component of lepton[1] momentum\n",
    "    sumpx = px_0 + px_1 # x-component of di-lepton momentum\n",
    "    sumpy = py_0 + py_1 # y-component of di-lepton momentum\n",
    "    sumpz = pz_0 + pz_1 # z-component of di-lepton momentum\n",
    "    sump = math.sqrt(sumpx**2 + sumpy**2 + sumpz**2) # magnitude of di-lepton momentum\n",
    "    \n",
    "    # we can use momentum components to calculate energy since p >> m\n",
    "    E_0 = math.sqrt(px_0**2 + py_0**2 + pz_0**2) # lepton[0] energy\n",
    "    E_1 = math.sqrt(px_1**2 + py_1**2 + pz_1**2) # lepton[1] energy\n",
    "    sumE = E_0 + E_1 # di-lepton energy\n",
    "    \n",
    "    return math.sqrt(sumE**2 - sump**2)/1000 #/1000 to go from MeV to GeV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='changing_cut'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing a cut\n",
    "If you change a cut: Cell -> Run All Below\n",
    "\n",
    "If you change a cut here, you also need to uncomment the corresponding cut in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cut on number of leptons\n",
    "def cut_n_lep(lep_n):\n",
    "    # want to keep events where there are 2 leptons\n",
    "    return lep_n == 2\n",
    "\n",
    "# cut on lepton charge\n",
    "def cut_lep_charge(lep_charge):\n",
    "    # want to keep events when sum of lepton charges is equal 0\n",
    "    # first lepton is [0], 2nd lepton is [1]\n",
    "    return # which events to return is for you to fill in\n",
    "\n",
    "# cut on lepton type\n",
    "def cut_lep_type(lep_type):\n",
    "    # want to keep events with either 2 electron types or 2 muon types\n",
    "    return # which events to return is for you to fill in\n",
    "\n",
    "# cut on lepton pt\n",
    "def cut_lep_pt(lep_pt):\n",
    "    # want to keep events where the leptons have lep_pt[] > 25000 MeV \n",
    "    return # which events to return is for you to fill in"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='applying_cut'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Applying a cut\n",
    "If you add a cut: Cell -> Run All Below\n",
    "\n",
    "If you apply a cut here, it also needs to be defined in the cell above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_file(path,sample):\n",
    "    start = time.time() # start the clock\n",
    "    print(\"\\tProcessing: \"+sample) # print which sample is being processed\n",
    "    data_all = pd.DataFrame() # define empty pandas DataFrame to hold all data for this sample\n",
    "    tree = uproot.open(path)[\"mini\"] # open the tree called mini\n",
    "    numevents = uproot.numentries(path, \"mini\") # number of events\n",
    "    for data in tree.iterate([\"lep_n\",\"lep_pt\",\"lep_eta\",\"lep_phi\",\n",
    "                              'lep_E',\"lep_charge\",\"lep_type\", \n",
    "                              # add more variables here if you make cuts on them\n",
    "                             ], entrysteps=2500000, # number of events in a batch to process\n",
    "                             outputtype=pd.DataFrame, # choose output type as pandas DataFrame\n",
    "                             entrystop=numevents*fraction): # process up to numevents*fraction\n",
    "\n",
    "        nIn = len(data.index) # number of events in this batch\n",
    "\n",
    "        # cut on number of leptons\n",
    "        data = data[ np.vectorize(cut_n_lep)(data.lep_n) ]\n",
    "\n",
    "        # dataframe contents can be printed at any stage like this\n",
    "        #print(data)\n",
    "\n",
    "        # dataframe column can be printed at any stage like this\n",
    "        #print(data['lep_charge'])\n",
    "\n",
    "        # dataframe columns can be printed at any stage like this\n",
    "        #print(data[['lep_charge','lep_type']])\n",
    "\n",
    "        # cut on lepton charge\n",
    "        #data = data[ np.vectorize(cut_lep_charge)(data.lep_charge) ]\n",
    "\n",
    "        # cut on lepton type\n",
    "        #data = data[ np.vectorize(cut_lep_type)(data.lep_type) ]\n",
    "\n",
    "        # cut on lepton pt\n",
    "        #data = data[ np.vectorize(cut_lep_pt)(data.lep_pt) ]\n",
    "\n",
    "        # calculation of 2-lepton invariant mass\n",
    "        data['mll'] = np.vectorize(calc_mll)(data.lep_pt,data.lep_eta,\n",
    "                                             data.lep_phi)\n",
    "\n",
    "        nOut = len(data.index) # number of events passing cuts in this batch\n",
    "        data_all = data_all.append(data) # append dataframe from this batch to the dataframe for the whole sample\n",
    "        elapsed = time.time() - start # time taken to process\n",
    "        print(\"\\t\\tTime taken: \"+str(elapsed)+\", nIn: \"+str(nIn)+\", nOut: \"+str(nOut)) # events before and after\n",
    "\n",
    "    return data_all # return dataframe containing events passing all cuts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is where the processing happens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tProcessing: DataEgamma\n",
      "\t\tTime taken: 0.7316741943359375, nIn: 4293, nOut: 4293\n",
      "Time taken: 0.7366559505462646\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "data_frame = get_data_from_files()\n",
    "elapsed = time.time() - start\n",
    "print(\"Time taken: \"+str(elapsed))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Make a change to plotting\n",
    "If you only want a make a change in the plot: Cell -> Run All Below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_data(data):\n",
    "    \n",
    "    xmin = 0\n",
    "    xmax = 220\n",
    "    step_size = 5\n",
    "    \n",
    "    bins = np.arange(start=xmin, # The interval includes this value\n",
    "                     stop=xmax+step_size, # The interval doesn't include this value\n",
    "                     step=step_size ) # Spacing between values\n",
    "    bin_centres = np.arange(start=xmin+step_size/2, # The interval includes this value\n",
    "                            stop=xmax+step_size/2, # The interval doesn't include this value\n",
    "                            step=step_size ) # Spacing between values\n",
    "\n",
    "    data_mll,_ = np.histogram( data_frame['mll'].values, bins=bins ) # histogram the data\n",
    "    data_mll_errors = np.sqrt( data_mll ) # statistical error on the data\n",
    "\n",
    "    plt.errorbar(x=bin_centres, y=data_mll, yerr=data_mll_errors, \n",
    "                 fmt='ko' ) # plot format\n",
    "\n",
    "    plt.ylabel( 'Events', horizontalalignment='right', y=1 ) # write y-axis label\n",
    "    plt.yscale( 'log' ) # log scale on y-axis\n",
    "\n",
    "    plt.xlabel('Di-lepton invariant mass $m_{\\ell\\ell}$ [GeV]', # x-axis label\n",
    "               horizontalalignment='right', x=1 )\n",
    "    plt.xlim( left=bins[0], right=bins[-1] ) # no margin on x-axis\n",
    "    plt.gca().xaxis.set_major_locator( MultipleLocator(20) ) # separation of x-axis major ticks\n",
    "    plt.gca().xaxis.set_minor_locator( MultipleLocator(5) ) # separation of x-axis minor ticks\n",
    "    \n",
    "    plt.tick_params(which='both', # ticks on both x and y axes\n",
    "                    direction='in', # Put ticks inside and outside the axes\n",
    "                    top=True, # draw ticks on the top axis\n",
    "                    right=True ) # draw ticks on right axis\n",
    "    \n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Call the function to plot the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_data(data_frame)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Your tasks\n",
    "\n",
    "* Discuss any difference when you increase the fraction [here](#fraction)\n",
    "* Discuss any difference when you use DataMuons rather than DataEgamma [here](#samples)\n",
    "* Discuss any difference when you use DataMuons and DataEgamma [here](#samples)\n",
    "* Discuss any difference when you uncomment the cut on lepton charge in line 10 of '[Changing a cut](#changing_cut)' and line 29 of '[Applying a cut](#applying_cut)'\n",
    "* Discuss any difference when you uncomment the cut on lepton type in line 15 of '[Changing a cut](#changing_cut)' and line 32 of '[Applying a cut](#applying_cut)'\n",
    "* Discuss any difference when you uncomment the cut on lepton pt in line 20 of '[Changing a cut](#changing_cut)' and line 35 of '[Applying a cut](#applying_cut)'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}