2-Fitting-with-ROOT.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <CENTER> Fitting functions to distributions in ROOT"
   ]
  },
  {
   "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": [
    "# import several types of objects we'll need (the ones starting with k represent predefined colors)\n",
    "from ROOT import TH1F, TCanvas, TF1, TLegend, kRed, kBlue, kGreen, kBlack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  2.1 Histograms, functions and uncertainties\n",
    "\n",
    "In this section you'll familiarize yourselves with the ROOT classes for\n",
    "* drawing distributions in [histograms](https://en.wikipedia.org/wiki/Histogram): see [the documentation for the TH1 classes](https://root.cern.ch/doc/master/classTH1.html)\n",
    "* describing mathematical functions: see [the documentation for the TF1 class](https://root.cern.ch/doc/master/classTF1.html)\n",
    "________________________"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a histogram with object name \"histo\", title and axis labels as listed, \n",
    "# containing 20 bins in the range 0 to 3\n",
    "histo = TH1F(\"histo\", \"Events; x; Number of random numbers\", 20, 0., 3.)\n",
    "\n",
    "# create a function that can be used to generate random numbers, in this case we use an exponential function\n",
    "myFunctionName = \"myExponential\"\n",
    "myFunction = TF1(myFunctionName, \"exp(-2.7*x)\", 0, 3) # defined on interval 0 < x < 3\n",
    "myFunction.Print() # prints out some info about the function object, including the actual expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# number of random numbers to generate\n",
    "N = 500\n",
    "\n",
    "# fill the histogram with random values following a distribution defined by the function\n",
    "histo.FillRandom(myFunctionName, N)\n",
    "\n",
    "# check how many entries were filled into the histogram\n",
    "print(\"Number of entries: %d\" % histo.GetEntries())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a canvas object that we can draw things on\n",
    "canvas = TCanvas(\"MyCanvas\", \"Test fits\", 800, 600)\n",
    "\n",
    "# draw the histogram\n",
    "histo.Draw(\"e1\")\n",
    "canvas.Draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note that each point is drawn with a vertical bar representing the uncertainty of the value. Find out what this uncertainty comes from. The bar in the x-direction shows the size of each bin and does not correspond to an uncertainty in the same way."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hint:** Hold the cursor over a data point to see its value and the associated uncertainty."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____________________________________________________________________________________\n",
    "\n",
    "### 2.2 Make a fit\n",
    "Now let's fit a function to the data in the histogram. The function used is `TH1F::Fit(func, fit_opt, draw_opt, xlow, xup)` where\n",
    "* `func` is either a string with the internal ROOT object name of a function (i.e. a `ROOT::TF1` object), like `myExponential` in the example above, or a function object itself, like `myFunction` above. \n",
    "* `fit_opt` is a string which describes the fit options to use (e.g. `fit_opt = \"V\"` for verbose), and `draw_opt` defines the draw options (e.g. `draw_opt=\"E\"` to draw the histogram with errors). Several options can be given simultaneously by combining several letters into a string.\n",
    "* `x_low` and `x_up` define x-axis range to use for the fit. \n",
    "\n",
    "See further info in [the documentation for TH1::Fit()](https://root.cern.ch/doc/master/classTH1.html#a7e7d34c91d5ebab4fc9bba3ca47dabdd). You can read e.g. about the different fit options to control the fit (more on this soon).\n",
    "\n",
    "Here we'll try to fit the same function we used to fill the histogram (should by definition work well).\n",
    "By calling `histo.Fit()` the fit is performed and the resulting curve is drawn in the canvas on top of the histogram.\n",
    "By default a weighted least-squares fit is used, also denoted $\\chi^2$-fit.\n",
    "___________________________________________"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Side note: how `TF1` functions can be defined\n",
    "\n",
    "As we saw above, a function can be defined by entering the corresponding mathematical expression as a string. Free parameters can be defined in with placeholders in square brackets, e.g. an arbitrary second-degree polynominal can be be specified with the following line of code, where `[n]` represents parameter `n`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "functionWithParameters = TF1(\"myFunction\", \"[0] + [1]*x + [2]*x^2\")\n",
    "functionWithParameters.Print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The free parameters can the be assigned (starting) values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sets all parameters, i.e. 0, 1 and 2, in that order\n",
    "print(\"Will set all parameters\")\n",
    "functionWithParameters.SetParameters(4.3, -2, 0.3) \n",
    "for p in range(functionWithParameters.GetNpar()):\n",
    "    print(\"Parameter %d = %.2f\" % (p, functionWithParameters.GetParameter(p)))\n",
    "\n",
    "# set the value of the 2nd parameter (index = 1) to 10\n",
    "print(\"Will now set only parameter 1\")\n",
    "functionWithParameters.SetParameter(1, 10) \n",
    "for p in range(functionWithParameters.GetNpar()):\n",
    "    print(\"Parameter %d = %.2f\" % (p, functionWithParameters.GetParameter(p)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two other ways to define functions that can come in handy (especially the latter):\n",
    "* Use predefined functions through reserved keywords for the name, e.g. `expo` (exponential), `gaus` (for a Gauss distribution), etc (see below)\n",
    "* Use the functions defined in `TMath` (see [documentation](https://root.cern.ch/doc/master/namespaceTMath.html)), e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fMin = TF1(\"myFunction\", \"TMath::Min(x, 3.1)\", 0, 10)\n",
    "fMin.Draw(\"l\")\n",
    "canvas.Draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fMin.Eval(4.3) # evaluate for a given value of x (try putting in other values, does it behave like you expect?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now make a different version of this function, one that has a free parameter for the cut-off value\n",
    "fMin2 = TF1(\"myFunc\", \"TMath::Min(x, [threshold])\", 0, 10) # the free parameter \"threshold\" is defined\n",
    "fMin2.Print()\n",
    "\n",
    "print(\"By default unspecified parameters get the value %f\" % fMin2.GetParameter(0))\n",
    "\n",
    "# set the value of the parameter to what you want, here we try 1.7 just to change something\n",
    "fMin2.SetParameter(0, 1.7)\n",
    "fMin2.SetLineColor(3) # let's draw this second one with a green line\n",
    "fMin2.Draw(\"SAME\")\n",
    "canvas.Draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's try a Landau distribution, with free parameters for the most probable value and the width\n",
    "fLandau = TF1(\"landauFunction\", \"TMath::Landau(x, [MPV], [width])\", 0, 10)\n",
    "# now let's give the parameters values: MPV of 4.5 and a width of 0.7\n",
    "fLandau.SetParameter(\"MPV\", 4.5)\n",
    "fLandau.SetParameter(\"width\", 0.7)\n",
    "fLandau.Draw()\n",
    "canvas.Draw()\n",
    "fLandau.Print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Back to making a fit\n",
    "\n",
    "Let us now fit an exponential function with free parameters to the histogram we generated and see if we can determine the original function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# \"expo\" used here is shorthand for \"exp([0]+[1]*x)\"\n",
    "fitFunction = TF1(\"myFitFunction\", \"expo\", 0, 3)\n",
    "fitFunction.Print()\n",
    "\n",
    "# this is where the magic happens, ROOT adjusts the free parameters of the function to the values\n",
    "# that make it best describe the distribution in the histogram\n",
    "fitresult = histo.Fit(fitFunction, \"S\") # option \"S\" makes sure the fit result is returned\n",
    "\n",
    "canvas.Draw() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above the figure the parameters result of the fit is printed. Note in particular the `STATUS` which shows if the fit converged (found a minimum) or not. The best-fit values of the parameters and their corresponding uncertainties are printed. By passing fit option `\"V\"` more verbose output will be given.\n",
    "\n",
    "Print out the relative uncertainty on the `Slope` parameter below!\n",
    "\n",
    "Hint: `fitresult` is an object of type `TFitResult`, and you can access the value for parameter `i` by calling the function `Parameter(i)` on this object. Check out [the documentation for TFitResult](https://root.cern.ch/doc/master/classROOT_1_1Fit_1_1FitResult.html) to find the function which returns the uncertainty on the parameter values that the fit converged on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(\"Relative uncertainty Slope = ....\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now go back and increase the number of entries in the histogram by a factor of two and rerun the fit. What happens to the uncertainty? What if you increase by a factor of four? Explain.\n",
    "\n",
    "___________________________________________________________________________"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3   Goodness-of-fit: how well does the model fit the data?\n",
    "How can we quantify how good a fit is? \n",
    "One way is to use the fact that the least-squares sum follows a $\\chi^2$ distribution, provided certain conditions are fulfilled.\n",
    "The number of degress of freedom $N_\\rm{DoF}$ is equal to the number of data points (bins) minus the number of parameters to be determined.\n",
    "With this, the probability to get the observed value for the sum can be evaluated.\n",
    "With enough bins, one can consider the ratio between the $\\chi^2$ sum and the number of degrees of freedom. \n",
    "Since each term in the sum should on average contribute around one, the ratio should be close to one for a good fit. \n",
    "The ratio is called the \"reduced chi-square\".\n",
    "Use the measure with care: the $\\chi^2$ assumption only holds if the model is correct, linear in the parameters, and the data points are approximately Gaussian with uncertainties estimated correctly.\n",
    "\n",
    "Below we investigate this by making a fit to a square wave form.\n",
    "A short assignment follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "# create a histogram and populate it to look like a square pulse that we can then use to generate random values\n",
    "squareWave = TH1F(\"squareWave\", \"Square; x; y\", 3, 0.5, 3.5)\n",
    "squareWave.SetBinContent(1, 5.); squareWave.SetBinError(1, math.sqrt(5.))\n",
    "squareWave.SetBinContent(2, 15.); squareWave.SetBinError(2, math.sqrt(15.))\n",
    "squareWave.SetBinContent(3, 5.); squareWave.SetBinError(3, math.sqrt(5.))\n",
    "squareWave.SetLineColor(kBlack)\n",
    "\n",
    "# sample the histogram and fill the random values into another histogram\n",
    "sample_squareWave = TH1F(\"sample_squareWave\", \"; x; y\", 15, 0.5, 3.5)\n",
    "n=8000\n",
    "sample_squareWave.FillRandom(squareWave, n)\n",
    "\n",
    "# draw the original model and the sampled distribution\n",
    "sample_squareWave.Draw(\"e1\")\n",
    "squareWave.Scale(float(n)/((15.+5.+5.)/3)/sample_squareWave.GetNbinsX()) \n",
    "squareWave.Draw(\"hist same\")\n",
    "canvas.Draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now let's fit a constant function to this distribution, i.e. f = C\n",
    "const = TF1(\"const\", \"[0]\", 0.5, 3.5, 1) # the function just has one constant parameter and does not depend on x\n",
    "const.SetParameter(0, 10.) # set the initial guess to 10\n",
    "fitresult = sample_squareWave.Fit(\"const\", \"S\", \"SAME\", 0.5, 3.5)\n",
    "print(\"\\n*** Chi-square sum = {:.1f}, Number of degrees of freedom = {}, ratio = {:.1f}\".format(fitresult.Chi2(), \n",
    "                                                                                                fitresult.Ndf(), \n",
    "                                                                                                fitresult.Chi2()/fitresult.Ndf()))\n",
    "\n",
    "canvas.Draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, the fit puts the line somewhere in between the upper and lower part of the pulse.\n",
    "From the print-out we note that the $\\chi^2/N_\\rm{DOF}$ is far from one.\n",
    "The model does not describe the data well.\n",
    "\n",
    "<b> Now try to fit only a range in which a constant should be a good description of the data.\n",
    "    Evaluate $\\chi^2/N_\\rm{DOF}$. Is it closer to one? </b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____________________________________________________________________________\n",
    "### 2.4 Configuring the fit\n",
    "By default, the fit is done by minimizing the sum of weighted least-squares ($\\chi^2$). This is based on the assumption that the measured values come from a Gaussian distribution. In our case, they are counts, and come from the Poisson distribution. But from courses in statistics we know that the Poisson distribution becomes increasingly Gaussian-like with increasing expectation value. \n",
    "\n",
    "You can give the fit option `\"L\"` to instead make a maximum likelihood fit. In this case, a likelihood function is maximised, where the function is equal to the product of Poisson factors, where each bin contributes with one factor.\n",
    "\n",
    "Let's compare the two alternatives using an example. Consider a model equal to a straight line. We generate a number of events from the model and draw the histogram, corresponding to the observation made by an experiment. The goal is to measure the model's slope by performing a fit.\n",
    "_______________________________________________________________________________"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# a simple straight-line model, y = kx + m\n",
    "xlow = 3.; xup = 10.\n",
    "fmodel = TF1(\"lin\", \"[0]*x+[1]\", xlow, xup)\n",
    "# set initial parameter values\n",
    "fmodel.SetParameters(1., 1.)\n",
    "# create a histogram\n",
    "hist = TH1F(\"exp\", \"; x; Number of events\", 10, xlow, xup)\n",
    "n = 30\n",
    "hist.FillRandom(\"lin\", n) # fill histogram with n randomly generated numbers from the function\n",
    "\n",
    "# fit with the default least squares method\n",
    "fitresult = hist.Fit(\"lin\", \"S\", \"e1\") # store fit results using fit option \"S\"\n",
    "\n",
    "# get parameters and their uncertainties\n",
    "print(fitresult.Parameter(0))\n",
    "print(fitresult.ParError(0))\n",
    "\n",
    "# save the function and draw it again in blue (to prevent it from disappearing when drawing the same function again later)\n",
    "fitresultLeastSquares = hist.GetFunction(\"lin\").Clone(\"linLeastSquares\") # Clone() creates a copy of the function\n",
    "fitresultLeastSquares.SetLineColor(kBlue)\n",
    "fitresultLeastSquares.Draw(\"SAME\")\n",
    "print(\"\\nSlope least squares = {:.3f}\".format(fitresultLeastSquares.GetParameter(0)))\n",
    "\n",
    "# re-run the fit, this time with option \"L\". The resulting curve is shown in red\n",
    "hist.Fit(\"lin\", \"L\", \"e1 SAME\")\n",
    "print(\"Slope likelihood = {:.3f}\\n\".format(hist.GetFunction(\"lin\").GetParameter(0)))\n",
    "canvas.Draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note that the two fitted lines are not identical. Try what happens if you increase the number of events - do you understand why?\n",
    "_______________________________________________________________________________"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5 Define your own functions\n",
    "______________________________________________________________________"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NB! The interactive feature unfortunately does not work for all functions. \n",
    "# We'll turn it off to make sure everything is drawn correctly.\n",
    "%jsroot off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define your own function, starting with a*(x-b)^2\n",
    "\n",
    "# alternative 1: write the formula as a string using \"TFormula\"-syntax\n",
    "# in the below, [i] represent free parameters, the last two arguments \n",
    "# are the range for the function\n",
    "f1 = TF1(\"f1\", \"[0]*(x-[1])*(x-[1])\", -10., 10.) \n",
    "\n",
    "# alternative 2: write with already existing functions (pre-defined eller user defined)\n",
    "f2 = TF1(\"f2\", \"gaus + f1\", -10., 10.)\n",
    "\n",
    "# alternative 3: using your own python function (for info, you likely won't need this)\n",
    "def myfunc(x, params):\n",
    "    x = x[0]\n",
    "    a = params[0]; b = params[1]\n",
    "    return a*(x-b)**2\n",
    "f3 = TF1(\"f3\", myfunc, -10., 10., 2) # the last argument specifies the number of parameters\n",
    "\n",
    "# set parameter values\n",
    "f1.SetParameters(1., 2.)\n",
    "f2.SetParameters(100., -2., 4., 1., 2.) # the first three parameters are for the Gaussian, the last two for the f1 function\n",
    "f3.SetParameters(1., 3.)\n",
    "\n",
    "# set limits for the parameters (that they are forced to stay inside) Useful to fitting\n",
    "f1.SetParLimits(0, -3., 5.) # parameter0 must lie inside [-3., 5.] \n",
    "\n",
    "# colors for drawing\n",
    "f1.SetLineColor(kBlue)\n",
    "f2.SetLineColor(kBlack)\n",
    "f3.SetLineColor(kRed)\n",
    "\n",
    "# draw\n",
    "f1.Draw()\n",
    "f2.Draw(\"SAME\")\n",
    "f3.Draw(\"SAME\")\n",
    "canvas.Draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___________________________________________________"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6 Add a legend\n",
    "In general, figures should always have legends specifying what the different curves/histograms shown in it represent. Below is an example, see [the TLegend documentation](https://root.cern.ch/doc/master/classTLegend.html) for further details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### create the legend object\n",
    "leg = TLegend(0.5, 0.5, 0.8, 0.8) # the arguments are x1, y1, x2, y2 coordinates, given as fractions of the canvas size\n",
    "\n",
    "### add the curves we drew above to the legend. Syntax is TLegend::AddEntry(drawn_object, title, plot_style)\n",
    "leg.AddEntry(f1, \"Parabola, defined with TFormula\", \"l\") # \"l\" means \"line\", i.e. the line of f1 will be shown in the legend\n",
    "leg.AddEntry(f2, \"Parabola + Gaussian\", \"l\")\n",
    "leg.AddEntry(f3, \"Parabola, user defined\", \"l\")\n",
    "\n",
    "## make legend prettier (see below)\n",
    "# ...\n",
    "\n",
    "## draw legend\n",
    "leg.Draw()\n",
    "canvas.Draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_______________________________________________________________\n",
    "Make sure the font in the legend is not too small. This can be set with `leg.SetTextSize(x)` where `x` is fraction of canvas size (try something like 0.03). The legend border can be removed with `leg.SetBorderSize(0)`. Change the code block above to make the legend prettier.\n",
    "_______________________________________________________________"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### See if you can answer the following questions - you will need to understand them to properly explain the fit procedure and results for the report.\n",
    "* In a histogram, if drawn with with some `e` option, data points will be displayed with an uncertainty. ROOT has automatically evaluated the uncertainty to... what?\n",
    "* What determines the uncertainty on the fitted parameters? How can they be reduced?\n",
    "* ROOT uses the weighted least squares ($\\chi^2$) fit by default. When is this appropriate? What happens if we use the option `\"L\"`?\n",
    "\n",
    "Now you're ready to find an example particle in the data, the $Z^0$ boson - gå vidare till [3-TheMassOfTheZ](3-TheMassOfTheZ.ipynb)!"
   ]
  }
 ],
 "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
}