{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# How to rediscover the Higgs boson yourself!\n", "This notebook uses ATLAS Open Data http://opendata.atlas.cern to show you the steps to rediscover the Higgs boson yourself!\n", "\n", "ATLAS Open Data provides open access to proton-proton collision data at the LHC for educational purposes. ATLAS Open Data resources are ideal for high-school, undergraduate and postgraduate students.\n", "\n", "Notebooks are web applications that allow you to create and share documents that can contain for example:\n", "1. live code\n", "2. visualisations\n", "3. narrative text\n", "\n", "This analysis loosely follows the discovery of the Higgs boson by ATLAS https://arxiv.org/pdf/1207.7214.pdf (mostly Section 5 and 5.1)\n", "\n", "By the end of this notebook you will be able to:\n", "1. rediscover the Higgs boson yourself!\n", "2. know some general principles of a particle physics analysis\n", "\n", "Feynman diagram pictures are borrowed from our friends at https://www.particlezoo.net" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Contents: \n", "\n", "[Running a Jupyter notebook](#running)
\n", "[First time setup on your computer (no need on mybinder)](#setup_computer)
\n", "[To setup everytime](#setup_everytime)
\n", "[Lumi, fraction, file path](#fraction)
\n", "[Samples](#samples)
\n", "[Changing a cut](#changing_cut)
\n", "[Applying a cut](#applying_cut)
\n", "[Plotting](#plotting)
\n", "[What can you do to explore this analysis?](#going_further)
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Running a Jupyter notebook\n", "\n", "To run the whole Jupyter notebook, in the top menu click Cell -> Run All.\n", "\n", "To propagate a change you've made to a piece of code, click Cell -> Run All Below.\n", "\n", "You can also run a single code cell, by clicking Cell -> Run Cells, or using the keyboard shortcut Shift+Enter." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## First time setup on your computer (no need on mybinder)\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": {}, "outputs": [], "source": [ "import sys\n", "!{sys.executable} -m pip install --upgrade --user pip # update the pip package installer\n", "!{sys.executable} -m pip install -U numpy pandas uproot3 matplotlib lmfit --user # install required packages" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "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\n", "\n", "We're going to be using a number of tools to help us:\n", "* uproot: lets us read .root files typically used in particle physics into data formats used in python\n", "* pandas: lets us store data as dataframes, a format widely used in python\n", "* numpy: provides numerical calculations such as histogramming\n", "* matplotlib: common tool for making plots, figures, images, visualisations\n", "* lmfit: tool for statistical fitting" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import uproot3 # 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 MaxNLocator,AutoMinorLocator # for minor ticks\n", "from lmfit.models import PolynomialModel, GaussianModel # for the signal and background fits" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Lumi, fraction, file path\n", "\n", "General definitions of luminosity, fraction of data used, where to access the input files" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "lumi = 0.5 # fb-1 # data_A only\n", "#lumi = 1.9 # fb-1 # data_B only\n", "#lumi = 2.9 # fb-1 # data_C only\n", "#lumi = 4.7 # fb-1 # data_D only\n", "#lumi = 10 # fb-1 # data_A,data_B,data_C,data_D\n", "\n", "fraction = 0.8 # reduce this is you want the code to run quicker\n", "\n", "#tuple_path = \"Input/GamGam/Data/\" # local \n", "tuple_path = \"https://atlas-opendata.web.cern.ch/atlas-opendata/samples/2020/GamGam/Data/\" # web address" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Samples\n", "\n", "Samples to process" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "samples_list = ['data_A'] #'data_B','data_C','data_D' # add if you want more data\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Define function to get data from files\n", "\n", "The datasets used in this notebook have already been filtered to include at least 2 photons per event, so that processing is quicker." ] }, { "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+\".GamGam.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 = pd.concat(frames) # concatenate list of dataframes together into one dataframe\n", " \n", " return data # return dataframe" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Define function to calculate diphoton invariant mass" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def calc_myy(photon_pt,photon_eta,photon_phi,photon_E):\n", " # first photon is [0], 2nd photon is [1] etc\n", " px_0 = photon_pt[0]*math.cos(photon_phi[0]) # x-component of photon[0] momentum\n", " py_0 = photon_pt[0]*math.sin(photon_phi[0]) # y-component of photon[0] momentum\n", " pz_0 = photon_pt[0]*math.sinh(photon_eta[0]) # z-component of photon[0] momentum\n", " px_1 = photon_pt[1]*math.cos(photon_phi[1]) # x-component of photon[1] momentum\n", " py_1 = photon_pt[1]*math.sin(photon_phi[1]) # y-component of photon[1] momentum\n", " pz_1 = photon_pt[1]*math.sinh(photon_eta[1]) # z-component of photon[1] momentum\n", " sumpx = px_0 + px_1 # x-component of diphoton momentum\n", " sumpy = py_0 + py_1 # y-component of diphoton momentum\n", " sumpz = pz_0 + pz_1 # z-component of diphoton momentum \n", " sump = math.sqrt(sumpx**2 + sumpy**2 + sumpz**2) # magnitude of diphoton momentum \n", " sumE = photon_E[0] + photon_E[1] # energy of diphoton system\n", " return math.sqrt(sumE**2 - sump**2)/1000 #/1000 to go from MeV to GeV" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Changing a cut\n", "\n", "If you change a cut: Cell -> Run All Below\n", "\n", "If you change a cut here, you also need to make sure the cut is applied in the \"[Applying a cut](#applying_cut)\" cell." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# Cut on photon reconstruction quality\n", "# paper: \"Photon candidates are required to pass identification criteria\"\n", "def cut_photon_reconstruction(photon_isTightID):\n", "# isTightID==True means a photon identified as being well reconstructed\n", "# want to keep events where True for both photons\n", "# first photon is [0], 2nd photon is [1] etc\n", " return photon_isTightID[0]==True and photon_isTightID[1]==True\n", " \n", "# Cut on Transverse momentum\n", "# paper: \"The leading (sub-leading) photon candidate is required to have ET > 40 GeV (30 GeV)\"\n", "def cut_photon_pt(photon_pt):\n", "# want to keep events where photon_pt[0]>40000 MeV and photon_pt[1]>30000 MeV\n", " return photon_pt[0]>40000 and photon_pt[1]>30000\n", "\n", "# Cut on energy isolation\n", "# paper: \"Photon candidates are required to have an isolation transverse energy of less than 4 GeV\"\n", "def cut_isolation_et(photon_etcone20):\n", "# want to keep events where isolation eT<4000 MeV\n", " return photon_etcone20[0]<4000 and photon_etcone20[1]<4000\n", "\n", "# Cut on pseudorapidity in barrel/end-cap transition region\n", "# paper: \"excluding the calorimeter barrel/end-cap transition region 1.37 < |η| < 1.52\"\n", "def cut_photon_eta_transition(photon_eta):\n", "# want to keep events where modulus of photon_eta is outside the range 1.37 to 1.52\n", " return (abs(photon_eta[0])>1.52 or abs(photon_eta[0])<1.37) and (abs(photon_eta[1])>1.52 or abs(photon_eta[1])<1.37)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Applying a cut \n", "\n", "If you add a cut: Cell -> Run All Below" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def read_file(path,sample):\n", " start = time.time() # start the clock\n", " print(\"Processing: \"+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 = uproot3.open(path)[\"mini\"] # open the tree called mini\n", " numevents = uproot3.numentries(path, \"mini\") # number of events\n", " for data in tree.iterate([\"photon_pt\",\"photon_eta\",\"photon_phi\",\"photon_E\",\n", " \"photon_isTightID\",\"photon_etcone20\"], # add more variables here if you want to use them\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 photon reconstruction quality using the function cut_photon_reconstruction defined above\n", " data = data[ np.vectorize(cut_photon_reconstruction)(data.photon_isTightID)]\n", " \n", " # Cut on transverse momentum of the photons using the function cut_photon_pt defined above\n", " data = data[ np.vectorize(cut_photon_pt)(data.photon_pt)]\n", " \n", " # Cut on energy isolation using the function cut_isolation_et defined above\n", " data = data[ np.vectorize(cut_isolation_et)(data.photon_etcone20)]\n", " \n", " # Cut on pseudorapidity inside barrel/end-cap transition region using the function cut_photon_eta_transition\n", " data = data[ np.vectorize(cut_photon_eta_transition)(data.photon_eta)]\n", " \n", " # Calculate reconstructed diphoton invariant mass using the function calc_myy defined above\n", " data['myy'] = np.vectorize(calc_myy)(data.photon_pt,data.photon_eta,data.photon_phi,data.photon_E)\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['photon_pt'])\n", "\n", " # multiple dataframe columns can be printed at any stage like this\n", " #print(data[['photon_pt','photon_eta']])\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 nIn: \"+str(nIn)+\",\\t nOut: \\t\"+str(nOut)+\"\\t in \"+str(round(elapsed,1))+\"s\") # events before and after\n", " \n", " return data_all # return dataframe containing events passing all cuts" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is where the processing happens (this will take some minutes)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processing: data_A\n", "\t nIn: 344275,\t nOut: \t17799\t in 202.3s\n", "Time taken: 203.0s\n" ] } ], "source": [ "start = time.time() # time at start of whole processing\n", "data = get_data_from_files() # process all files\n", "elapsed = time.time() - start # time after whole processing\n", "print(\"Time taken: \"+str(round(elapsed,1))+\"s\") # print total time taken to process every file" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plotting\n", "If you only want a make a change in the plot: Cell -> Run All Below\n", "\n", "Define function to plot the data." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def plot_data(data): \n", "\n", " xmin = 100 # GeV\n", " xmax = 160 # GeV\n", " step_size = 2 # GeV\n", " \n", " bin_edges = 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_x,_ = np.histogram(data['myy'], \n", " bins=bin_edges ) # histogram the data\n", " data_x_errors = np.sqrt( data_x ) # statistical error on the data\n", "\n", " # data fit\n", " polynomial_mod = PolynomialModel( 4 ) # 4th order polynomial\n", " gaussian_mod = GaussianModel() # Gaussian\n", " \n", " # set initial guesses for the parameters of the polynomial model\n", " # c0 + c1*x + c2*x^2 + c3*x^3 + c4*x^4\n", " pars = polynomial_mod.guess(data_x, # data to use to guess parameter values\n", " x=bin_centres, c0=data_x.max(), c1=0,\n", " c2=0, c3=0, c4=0 )\n", " \n", " # set initial guesses for the parameters of the Gaussian model\n", " pars += gaussian_mod.guess(data_x, # data to use to guess parameter values\n", " x=bin_centres, amplitude=100, \n", " center=125, sigma=2 )\n", " \n", " model = polynomial_mod + gaussian_mod # combined model\n", " \n", " # fit the model to the data\n", " out = model.fit(data_x, # data to be fit\n", " pars, # guesses for the parameters\n", " x=bin_centres, weights=1/data_x_errors ) \n", "\n", " # background part of fit\n", " params_dict = out.params.valuesdict() # get the parameters from the fit to data\n", " c0 = params_dict['c0'] # c0 of c0 + c1*x + c2*x^2 + c3*x^3 + c4*x^4\n", " c1 = params_dict['c1'] # c1 of c0 + c1*x + c2*x^2 + c3*x^3 + c4*x^4\n", " c2 = params_dict['c2'] # c2 of c0 + c1*x + c2*x^2 + c3*x^3 + c4*x^4\n", " c3 = params_dict['c3'] # c3 of c0 + c1*x + c2*x^2 + c3*x^3 + c4*x^4\n", " c4 = params_dict['c4'] # c4 of c0 + c1*x + c2*x^2 + c3*x^3 + c4*x^4\n", " \n", " # get the background only part of the fit to data\n", " background = c0 + c1*bin_centres + c2*bin_centres**2 + c3*bin_centres**3 + c4*bin_centres**4\n", "\n", " # data fit - background fit = signal fit\n", " signal_x = data_x - background \n", "\n", "\n", " # *************\n", " # Main plot \n", " # *************\n", " plt.axes([0.1,0.3,0.85,0.65]) # left, bottom, width, height \n", " main_axes = plt.gca() # get current axes\n", " \n", " # plot the data points\n", " main_axes.errorbar(x=bin_centres, y=data_x, yerr=data_x_errors, \n", " fmt='ko', # 'k' means black and 'o' means circles\n", " label='Data' ) \n", " \n", " # plot the signal + background fit\n", " main_axes.plot(bin_centres, # x\n", " out.best_fit, # y\n", " '-r', # single red line\n", " label='Sig+Bkg Fit ($m_H=125$ GeV)' )\n", " \n", " # plot the background only fit\n", " main_axes.plot(bin_centres, # x\n", " background, # y\n", " '--r', # dashed red line\n", " label='Bkg (4th order polynomial)' )\n", "\n", " # set the x-limit of the main axes\n", " main_axes.set_xlim( left=xmin, right=xmax ) \n", " \n", " # separation of x-axis minor ticks\n", " main_axes.xaxis.set_minor_locator( AutoMinorLocator() ) \n", " \n", " # set the axis tick parameters for the main axes\n", " main_axes.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", " labelbottom=False, # don't draw tick labels on bottom axis\n", " right=True ) # draw ticks on right axis\n", " \n", " # write y-axis label for main axes\n", " main_axes.set_ylabel('Events / '+str(step_size)+' GeV', \n", " horizontalalignment='right') \n", " \n", " # set the y-axis limit for the main axes\n", " main_axes.set_ylim( bottom=0, top=np.amax(data_x)*1.1 ) \n", " \n", " # set minor ticks on the y-axis of the main axes\n", " main_axes.yaxis.set_minor_locator( AutoMinorLocator() ) \n", " \n", " # avoid displaying y=0 on the main axes\n", " main_axes.yaxis.get_major_ticks()[0].set_visible(False) \n", "\n", " # Add text 'ATLAS Open Data' on plot\n", " plt.text(0.2, # x\n", " 0.92, # y\n", " 'ATLAS Open Data', # text\n", " transform=main_axes.transAxes, # coordinate system used is that of main_axes\n", " fontsize=13 ) \n", " \n", " # Add text 'for education' on plot\n", " plt.text(0.2, # x\n", " 0.86, # y\n", " 'for education', # text\n", " transform=main_axes.transAxes, # coordinate system used is that of main_axes\n", " style='italic',\n", " fontsize=8 ) \n", " \n", " # Add energy and luminosity\n", " lumi_used = str(lumi*fraction) # luminosity to write on the plot\n", " plt.text(0.2, # x\n", " 0.8, # y\n", " '$\\sqrt{s}$=13 TeV,$\\int$L dt = '+lumi_used+' fb$^{-1}$', # text\n", " transform=main_axes.transAxes ) # coordinate system used is that of main_axes \n", " \n", " # Add a label for the analysis carried out\n", " plt.text(0.2, # x\n", " 0.74, # y\n", " r'$H \\rightarrow \\gamma\\gamma$', # text \n", " transform=main_axes.transAxes ) # coordinate system used is that of main_axes\n", "\n", " # draw the legend\n", " main_axes.legend(frameon=False, # no box around the legend\n", " loc='lower left' ) # legend location \n", "\n", "\n", " # *************\n", " # Data-Bkg plot \n", " # *************\n", " plt.axes([0.1,0.1,0.85,0.2]) # left, bottom, width, height\n", " sub_axes = plt.gca() # get the current axes\n", " \n", " # set the y axis to be symmetric about Data-Background=0\n", " sub_axes.yaxis.set_major_locator( MaxNLocator(nbins='auto', \n", " symmetric=True) )\n", " \n", " # plot Data-Background\n", " sub_axes.errorbar(x=bin_centres, y=signal_x, yerr=data_x_errors,\n", " fmt='ko' ) # 'k' means black and 'o' means circles\n", " \n", " # draw the fit to data\n", " sub_axes.plot(bin_centres, # x\n", " out.best_fit-background, # y\n", " '-r' ) # single red line\n", " \n", " # draw the background only fit\n", " sub_axes.plot(bin_centres, # x\n", " background-background, # y\n", " '--r' ) # dashed red line\n", " \n", " # set the x-axis limits on the sub axes\n", " sub_axes.set_xlim( left=xmin, right=xmax ) \n", " \n", " # separation of x-axis minor ticks\n", " sub_axes.xaxis.set_minor_locator( AutoMinorLocator() ) \n", " \n", " # x-axis label\n", " sub_axes.set_xlabel(r'di-photon invariant mass $\\mathrm{m_{\\gamma\\gamma}}$ [GeV]',\n", " x=1, horizontalalignment='right', \n", " fontsize=13 ) \n", " \n", " # set the tick parameters for the sub axes\n", " sub_axes.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", " # separation of y-axis minor ticks\n", " sub_axes.yaxis.set_minor_locator( AutoMinorLocator() ) \n", " \n", " # y-axis label on the sub axes\n", " sub_axes.set_ylabel( 'Events-Bkg' ) \n", "\n", "\n", " # Generic features for both plots\n", " main_axes.yaxis.set_label_coords( -0.09, 1 ) # x,y coordinates of the y-axis label on the main axes\n", " sub_axes.yaxis.set_label_coords( -0.09, 0.5 ) # x,y coordinates of the y-axis label on the sub axes\n", " \n", " return" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Call the function to plot the data" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_data(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## What can you do to explore this analysis?\n", "\n", "* Increase the fraction of data used in '[Lumi, fraction, file path](#fraction)'\n", "* Use data_B, data_C and data_D in '[Samples](#samples)'\n", "* Check how many events are being thrown away by each cut in '[Applying a cut](#applying_cut)'\n", "* Add more cuts from the [Higgs discovery paper](https://www.sciencedirect.com/science/article/pii/S037026931200857X#se0090) in '[Changing a cut](#changing_cut)' and '[Applying a cut](#applying_cut)'\n", "* Find the reduced chi-squared for the fit in '[Plotting](#plotting)'\n", "* Find the mean of the fitted Gaussian in '[Plotting](#plotting)'\n", "* Find the width of the fitted Gaussian in '[Plotting](#plotting)'\n", "* Try different initial guesses for the parameters of the fit in '[Plotting](#plotting)'\n", "* Try different functions for the fit in '[Plotting](#plotting)'\n", "* Your idea!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "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.8.3" } }, "nbformat": 4, "nbformat_minor": 2 }