4-Explore.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Discover your own subatomic particle!\n",
    "\n",
    "You're now ready for the main exercise, to try to discover a particle in the data from the ATLAS experiment! There are a few short-lived particles that you can find in the provided dataset, and we have discussed one recently discovered particle more than others.\n",
    "\n",
    "Many particles can also be discovered through several different decay channels, and by looking at [for what final states](https://atlas-opendata.web.cern.ch/atlas-opendata/samples/2020/) data and simulations are provided and combining with recent lecture notes, you can get some ideas. \n",
    "\n",
    "If you are having trouble getting started, the slides from the last two lectures provide some inspiration!\n",
    "\n",
    "It's a good idea to read through [5-Report](5-Report.ipynb) already now - then you know what you're expected to include in your report, and the instructions might also include some ideas that could help you. As these instructions explain, you can choose your level of ambition depending on what final grade you want to try to get for the full course:\n",
    "* For grades E, D or C: identifying a peak corresponding to the particle in the invariant-mass spectrum in the data is sufficient, if you can argue well that the peak can not be due to background processes.\n",
    "* For grades B or A: in addition to the above, use MC simulations to predict what the signal you're searching for will look like (if they are available - ask me if you're not sure!), and for the main background processes - this helps to build confidence that you're interpreting the data correctly.\n",
    "\n",
    "*Don't hesitate to get in touch if you get stuck or run into problems!*\n",
    "\n",
    "Best,\n",
    "Christian (chohm@kth.se)\n",
    "\n",
    "PS. The $Z$ boson does not count since we used it as an example, but all other short-lived particles you can reconstruct from their decay products are ok! Decays that can be reconstructed fully, i.e. where all the decay products are measured, are generally easier, and those with low backgrounds from other processes are strongly recommended too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Install ROOT if working in Google Colab (if using this notebook via our docker image it's already there)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# install the ROOT libraries if you're using Google Colab - this usually takes a minute or two\n",
    "# if not we assume we're running in the docker container where it is already available\n",
    "try:\n",
    "  import google.colab\n",
    "  IN_COLAB = True\n",
    "except:\n",
    "  IN_COLAB = False\n",
    "\n",
    "if IN_COLAB:\n",
    "    # install ROOT and update a few other packages\n",
    "    !wget https://github.com/MohamedElashri/ROOT/releases/download/ubuntu/root_v6.28.04_Ubuntu_20.04.zip\n",
    "    !unzip /content/root_v6.28.04_Ubuntu_20.04.zip\n",
    "    !apt-get install git dpkg-dev cmake g++ gcc binutils libx11-dev libxpm-dev libxft-dev libxext-dev tar gfortran subversion\n",
    "    #!apt-get install libpython3.6-dev # seems to not be needed\n",
    "    # the following is needed because colab upgraded the openssl library\n",
    "    !wget http://archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.1_1.1.1f-1ubuntu2_amd64.deb\n",
    "    !sudo dpkg -i libssl1.1_1.1.1f-1ubuntu2_amd64.deb\n",
    "    # add some paths etc so that libraries can be found\n",
    "    import sys\n",
    "    sys.path.append(\"/content/root_build/\")\n",
    "    sys.path.append(\"/content/root_build/bin/\")\n",
    "    sys.path.append(\"/content/root_build/include/\")\n",
    "    sys.path.append(\"/content/root_build/lib/\")\n",
    "    import ctypes\n",
    "    ctypes.cdll.LoadLibrary('/content/root_build/lib//libCore.so')\n",
    "    ctypes.cdll.LoadLibrary('/content/root_build/lib//libThread.so')\n",
    "    ctypes.cdll.LoadLibrary('/content/root_build/lib//libTreePlayer.so')\n",
    "    print(\"Done installing ROOT - check that there were no error messages above!\")\n",
    "else:\n",
    "    print(\"Not running the notebook in Google Colab, so assuming ROOT is already available\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now you need to write the code - feel free to take inspiration from the previous exercises, \n",
    "# but make sure you understand what the code does!\n",
    "\n",
    "# let's start by importing the ROOT library\n",
    "import ROOT\n",
    "\n",
    "# make dictionary that holds TChains for data, and maybe simulated MC samples\n",
    "trees = {}\n",
    "trees[\"data\"] = ROOT.TChain(\"mini\")\n",
    "\n",
    "# there are several files for the data, add the paths to the list below to analyze more\n",
    "for file in [\"...\"]:\n",
    "    # the file needs to be downloaded if you're in Google Colab, which will take a while depending on its size\n",
    "    if IN_COLAB:\n",
    "        !wget $file # download the file locally\n",
    "        print(file)\n",
    "        !ls -l\n",
    "        file = file.split('/')[-1] # add the file without the path since it's now local\n",
    "    trees[\"data\"].Add(file)\n",
    "\n",
    "for s in trees:\n",
    "    print(\"Sample %s has %d events\" % (s, trees[s].GetEntries()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# quick info about the added files\n",
    "trees[\"data\"].ls()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You may want to use the handy TLorentzVector class for conveniently calculating \n",
    "# the invariant mass of many-particle systems, here's how\n",
    "\n",
    "# lepton masses can come in handy, in MeV\n",
    "leptonMasses = {11: 0.511, 13: 105.7}\n",
    "\n",
    "# example showing how to use TLorentzVectors, more details of what else you can easily\n",
    "# calculate for a many-particle system with the help of this class can be found at\n",
    "# https://root.cern.ch/doc/v606/classTLorentzVector.html\n",
    "tlv1 = ROOT.TLorentzVector()\n",
    "tlv1.SetPtEtaPhiM(..., ..., ..., leptonMasses[13]) # set the pT, eta, phi and rest mass of particle 1\n",
    "tlv1 = ROOT.TLorentzVector()\n",
    "tlv1.SetPtEtaPhiM(..., ..., ..., leptonMasses[13]) # do the same for particle 2\n",
    "invariantMass = (tlv1+tlv2).M() # calculate the invariant mass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a histogram for the invariant mass of the four-lepton systems found in the events, one for each sample\n",
    "histos = {}\n",
    "for sample in trees:\n",
    "    histos[sample] = ROOT.TH1F(\"myhisto\", \"Title; x-axis title [unit]; y-axis title [unit]\", 50, 0, 200.) \n",
    "\n",
    "# now loop over the events in each sample, look for events with the signature you're looking for,\n",
    "# and for those events calculate e.g. the invariant mass of the decay products from your particle\n",
    "for sample in trees:\n",
    "\n",
    "    processedEvents = 0\n",
    "    maxEvents = 1000 # handy while developing the code\n",
    "    for event in trees[sample]:\n",
    "        if processedEvents > maxEvents:\n",
    "            break\n",
    "\n",
    "        if event.lep_n >= ...: # for example - this of course depends on what particle/decay you look for!\n",
    "            ...\n",
    "            histos[sample].Fill(...)\n",
    "            \n",
    "        ...\n",
    "        processedEvents += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# open a canvas to draw the histogram on\n",
    "canvas = ROOT.TCanvas(\"Canvas\", \"Title\", 800, 600)\n",
    "# draw the histograms\n",
    "histos[\"data\"].Draw()\n",
    "\n",
    "...\n",
    "\n",
    "canvas.Draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try to fit a function to the invariant mass distribution, possibly including terms for both \n",
    "# the background shape and the particle you found\n",
    "\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now write up your work and results in a report - see [5-Report](5-Report.ipynb) for detailed instructions!"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}