{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Moderne Methoden der Datenanalyse SS2024\n",
    "# Practical Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## A Short Introduction to Jupyter Notebooks\n",
    "\n",
    "You can find some detailed information on the jupyter notebook concept in the [documentation of the project](https://jupyter-notebook.readthedocs.io/en/stable/).\n",
    "\n",
    "**Here are some basic instructions:**\n",
    "- Each code block, a so called \"cell\", can be executed by pressing **shift + enter**.\n",
    "- You can run multiple cells by marking them and then pressing **shift + enter** or via the options in the \"Run\" menu in the top bar.\n",
    "- The order of execution matters! The order in which the cells have been executed is indicated by the integers in the brackets to the left of the cell. For instance `In [1]` was executed first. This means that code at the end of the notebook can affect the code at the beginning, if the cells at the beginning are executed after the cells at the end.\n",
    "- You can change between three cell types in Jupyter Lab: \"Code\", \"Markdown\" or \"Raw\".\n",
    "    * The \"Code\" cells will be interpreted by Python.\n",
    "    * The \"Markdown\" cells will be rendered with [Markdown](https://www.markdownguide.org/) and can be used for documentation and text, such as this cell. You can use them for your answers and also add LaTeX formulas such as $f(x) = \\frac{1}{x}$. If you double click **this** Markdown cell you can see the raw code of this LaTeX equation. By pressing **shift + enter** the cell will be rendered with Markdown again.\n",
    "    * The \"Raw\" cells won't be interpreted at all.\n",
    "- If you want to reset your notebook, to *\"forget\"* all the defined functions, classes and variables, go to `Kernel -> Restart Kernel` in the top bar. Your code and text will remain untouched when doing this.\n",
    "- If you write or read files and provide only the file name, the notebook will look for the file in the directory it is located itself. Use relative paths or absolute paths to read or write files from or to somewhere else.\n",
    "\n",
    "For some more information on the JupyterLab interface and some useful shortcuts you can check out:\n",
    "- [the JupyterLab interface documentation](https://jupyterlab.readthedocs.io/en/stable/user/interface.html)\n",
    "- [an overview of some shortcuts](https://yoursdata.net/jupyter-lab-shortcut-and-magic-functions-tips/)\n",
    "- [and another shortcut overview](https://blog.ja-ke.tech/2019/01/20/jupyterlab-shortcuts.html)\n",
    "\n",
    "If you have any issues with the notebook or additional questions, contact your tutors or try google."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Exercise 1\n",
    "\n",
    "To complete the exercises, follow the steps described within this notebook and fill in the blank parts of the code.\n",
    "\n",
    "You can make use of common Python packages such as numpy or pandas for handling of data and matplotlib for plotting. Alternatively, you can use CERN's ROOT to solve the exercises. Hints for both approaches will be provided.\n",
    "\n",
    "**Some of the cells in this template will throw errors, as some code is missing!**\n",
    "**It is your job to add the code!**\n",
    "\n",
    "**You do not have to implement both the Python and the ROOT approach to the exercises! Simply delete the cells containing the templates and hints containing the approach you choose not to use.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Exercise 1.1\n",
    "\n",
    "Write a code snippet (function, class, etc.) that\n",
    "- creates `N` Gaussian distributed random numbers with mean `m=0` and a standard deviation of sigma `s=1` and\n",
    "- plots these numbers as a histogram.\n",
    "\n",
    "The parameter `N` should be an argument of the code snippet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Python Approach:\n",
    "If you want to use the Python approach, you should have a look at the package `numpy` and the therein provided method [`numpy.random.normal`](https://numpy.org/doc/stable/reference/random/generated/numpy.random.normal.html) in particular. This method can create a numpy array of random numbers.\n",
    "\n",
    "A simple way to visualize these numbers is the [`hist`](https://matplotlib.org/3.2.1/api/_as_gen/matplotlib.pyplot.hist.html) method provided by the matplotlib sub-package pyplot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_gaussian_histogram(N, mean=0., sigma=1.):\n",
    "    # Create a numpy array with gaussian distributed numbers\n",
    "    random_numbers = np.random.normal(loc=mean, scale=sigma, size=(N))\n",
    "    # Visualize the content of the array as histogram with the help of matplotlib.\n",
    "    plt.hist(random_numbers, bins=30)\n",
    "    plt.show()\n",
    "    \n",
    "    # Return the numpy array\n",
    "    return random_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gaussian_numbers = create_gaussian_histogram(N=100000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### ROOT Approach:\n",
    "If you want to use `ROOT`, you should check out [`gRandom->Gaus()`](https://root.cern.ch/doc/master/classTRandom.html#a0e445e213eae1343b3d22086ecb87314). You can use this method to [fill](https://root.cern.ch/doc/master/classTH1.html#a77e71290a82517d317ea8d05e96b6c4a) a `ROOT` [`TH1F` histogram](https://root.cern.ch/doc/master/classTH1F.html) one by one with the random numbers.\n",
    "\n",
    "Alternatively you can use the [`FillRandom`](https://root.cern.ch/doc/master/classTH1.html#a1e9d6258ae798a0eb52aef58a72758a5) method to fill the histogram directly with Gaussian distributed numbers, e.g. `my_hist.FillRandom(\"gaus\", 1000)`. If you want to use a ROOT's gauss function with other values for mean and sigma than the default values, you have to define a [one dimensional function `TF1`](https://root.cern.ch/doc/master/classTF1.html) with the respective parameters first:\n",
    "```python\n",
    "gaussian = TF1(\"gaussian\",\"gaus\",-3,3)\n",
    "gaussian.SetParameters(1,0,1)  # last parameter is sigma, second to last is the mean of the gaussian.\n",
    "```\n",
    "\n",
    "Plotting with ROOT in jupyter notebooks is a bit tricky, which is why we will give you some detailed hints on how to do this.\n",
    "First of all, the plot will not be shown if it is created in a function. Thus, your function should return the created `TH1F` object and you can then draw it on a canvas:\n",
    "```python\n",
    "canvas = TCanvas(\"c1\", \"c1\")\n",
    "\n",
    "root_histogram = create_gaussian_histogram_with_root(N=1000)\n",
    "\n",
    "root_histogram.Draw()\n",
    "canvas.Modified()\n",
    "canvas.Update()\n",
    "canvas.Draw()\n",
    "```\n",
    "\n",
    "A second problem arises if you try to run the code a second time, because the created ROOT objects are still present in the notebook and jupyter will not be able to create them again unless you delete them first, e.g. with a code snippet such as:\n",
    "```python\n",
    "try:\n",
    "    del canvas\n",
    "except NameError:\n",
    "    pass\n",
    "```\n",
    "This will delete the ROOT object `canvas` if it was already created. If it has not been created, yet, the `try`-`except` approach will catch the `NameError` that will be thrown, as the object `canvas` does not exist, yet. In this case nothing will be done (look up what the python build-in keyword `pass` does). You can also restart the jupyter kernel to achieve this, but this is rather inconvenient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to JupyROOT 6.30/04\n"
     ]
    }
   ],
   "source": [
    "from ROOT import TH1F, gRandom, TFile, TCanvas, TF1, gROOT\n",
    "from IPython.display import display, HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_gaussian_histogram_with_root(N, mean=0., sigma=1.):\n",
    "    # Create an histogram with 20 bins from -3 to 3\n",
    "    root_histogram = TH1F(\"myHisto\", \"Histogram containing random numbers\", 20, -3, 3)\n",
    "  \n",
    "    # Initialize the random numbers generator\n",
    "    gRandom.SetSeed(1234)\n",
    "    gaussian = TF1(\"gaussian\",\"gaus\",-3,3)\n",
    "    gaussian.SetParameters(N,mean,sigma)\n",
    "  \n",
    "    # Generate N random numbers following a gaussian distribution and fill the histogram with them\n",
    "    root_histogram.Fill(gaussian.GetBinContent(bin))\n",
    "    \n",
    "    return root_histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'TF1' object has no attribute 'GetBinContent'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[10], line 13\u001b[0m\n\u001b[1;32m      9\u001b[0m     \u001b[38;5;28;01mpass\u001b[39;00m\n\u001b[1;32m     11\u001b[0m c1 \u001b[38;5;241m=\u001b[39m TCanvas(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mc1\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mc1\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m---> 13\u001b[0m root_histogram \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_gaussian_histogram_with_root\u001b[49m\u001b[43m(\u001b[49m\u001b[43mN\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m100000\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     15\u001b[0m root_histogram\u001b[38;5;241m.\u001b[39mDraw()\n\u001b[1;32m     16\u001b[0m c1\u001b[38;5;241m.\u001b[39mModified()\n",
      "Cell \u001b[0;32mIn[9], line 11\u001b[0m, in \u001b[0;36mcreate_gaussian_histogram_with_root\u001b[0;34m(N, mean, sigma)\u001b[0m\n\u001b[1;32m      8\u001b[0m gaussian\u001b[38;5;241m.\u001b[39mSetParameters(N,mean,sigma)\n\u001b[1;32m     10\u001b[0m \u001b[38;5;66;03m# Generate N random numbers following a gaussian distribution and fill the histogram with them\u001b[39;00m\n\u001b[0;32m---> 11\u001b[0m root_histogram\u001b[38;5;241m.\u001b[39mFill(\u001b[43mgaussian\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mGetBinContent\u001b[49m(\u001b[38;5;28mbin\u001b[39m))\n\u001b[1;32m     13\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m root_histogram\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'TF1' object has no attribute 'GetBinContent'"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning in <TROOT::Append>: Replacing existing TH1: myHisto (Potential memory leak).\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    del c1\n",
    "except NameError:\n",
    "    pass\n",
    "\n",
    "try:\n",
    "    del root_histogram\n",
    "except NameError:\n",
    "    pass\n",
    "\n",
    "c1 = TCanvas(\"c1\", \"c1\")\n",
    "\n",
    "root_histogram = create_gaussian_histogram_with_root(N=100000)\n",
    "\n",
    "root_histogram.Draw()\n",
    "c1.Modified()\n",
    "c1.Update()\n",
    "c1.Draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Exercise 1.2\n",
    "\n",
    "Extend your code from Exercise 1.1 so that the histogram data is written to a file.\n",
    "\n",
    "This step is a bit more tricky if you are following the python approach, so please take a look at the hints. If you are using ROOT, you can write your `TH1F` histogram directly to a ROOT file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Python Approach:\n",
    "\n",
    "Numpy does not provide a dedicated class for histograms as ROOT does. In Exercise 1.1 we created an array containing the random numbers and visualized these numbers as histogram.\n",
    "\n",
    "You can use numpy's [`numpy.histogram`](https://numpy.org/doc/stable/reference/generated/numpy.histogram.html) method to interpret the data as histogram. However, this method will not create or return a \"histogram\" object, it will simply give you the bin counts and the bin edges of the histogram in form of two numpy arrays. You will have to decide yourself how to handle these return values.\n",
    "\n",
    "**Option 1) Store the data, not the histogram.**\n",
    "    \n",
    "You can use [`numpy.save`](https://numpy.org/doc/stable/reference/generated/numpy.save.html) or [`pandas.to_hdf`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_hdf.html) (you have to convert your data into the [`pandas.DataFrame`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html) or the [`pandas.Series`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.html) format for this) to save the data you created directly. You can also write the data to a csv file or any other format you might be familiar with.\n",
    "Using this option, you have to recreate the histogram again, because you stored the raw data and not the histogram interpretation. This has the advantage of being able to reinterpret the data.\n",
    "    \n",
    "**Option 2) Define a histogram object that can be stored to a file.**\n",
    "\n",
    "Storing the data in form of a histogram has two advantages: Firstly, it is clear how the data should be interpreted, and secondly, when handling large amounts of data, the histogram is a storage efficient way to save the data. Instead of saving each individual data point, only the bin count and the bin edges are stored. This means, if you consider a histogram with `n` bins, `2*n+1` (1 bin count per bin -> `n` bin counts; and `n+1` bin edge positions) numbers have to be stored. Keep in mind, however, that the amount of information stored in the histogram is also reduced compared to the full raw data set, as you only store one interpretation of the data.\n",
    "\n",
    "You can also use Python's [`pickle`](https://docs.python.org/3/library/pickle.html) to directly dump the tuple of bin counts and bin edges returned by the numpy histogram method to store these python objects in a pickle file. See also the [example given on the python website](https://docs.python.org/3/library/pickle.html#examples) which shows how a python dictionary is written and loaded again.\n",
    "\n",
    "The downside of these methods is, that you have to put a bit more effort into defining the object that is stored.\n",
    "\n",
    "You can try to implement both options, but focus on the **Option 2)**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "np.save(\"data\", gaussian_numbers)\n",
    "\n",
    "with open(\"hist.pickle\", \"wb\") as outfile:\n",
    "    pickle.dump(np.histogram(gaussian_numbers), outfile)\n",
    "# Save the data..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**Have a look at the custom histogram class `HistogramClass` below and try to understand how it works and which features it provides!**\n",
    "\n",
    "You can use this class or try your own method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Define a histogram object\n",
    "import pandas as pd\n",
    "\n",
    "class HistogramClass:\n",
    "    def __init__(self, data, bins=20, bin_range=None):\n",
    "        if isinstance(data, tuple) and all(isinstance(e, pd.Series) for e in data):\n",
    "            self._bins = len(data[0].index)\n",
    "            self._bin_counts = data[0].values\n",
    "            self._bin_edges = data[1].values\n",
    "            self._mean = data[2].values[0]\n",
    "            self._std = data[2].values[1]\n",
    "            self._entries = data[2].values[2]\n",
    "            self._underflow = data[2].values[3]\n",
    "            self._overflow = data[2].values[4]\n",
    "        elif isinstance(data, np.ndarray) and isinstance(bins, int):\n",
    "            self._bins = bins\n",
    "            bin_counts, bin_edges = np.histogram(data, bins=bins, range=bin_range)\n",
    "            self._bin_counts = bin_counts\n",
    "            self._bin_edges = bin_edges\n",
    "            \n",
    "            if bin_range is not None:\n",
    "                bounds = (data >= bin_range[0]) & (data <= bin_range[1])\n",
    "            else:\n",
    "                bounds = np.full(shape=data.shape, fill_value=True)\n",
    "            self._mean = np.mean(data[bounds])\n",
    "            self._std = np.std(data[bounds])\n",
    "            self._entries = len(data[bounds])\n",
    "            \n",
    "            self._underflow = 0 if bin_range is None else len(data[data < bin_range[0]])\n",
    "            self._overflow = 0 if bin_range is None else len(data[data > bin_range[1]])\n",
    "        else:\n",
    "            raise ValueError(\"The parameter 'data' must be a 1 dimensional numpy array and the parameter 'bins' an integer!\")\n",
    "    \n",
    "    @property\n",
    "    def bins(self):\n",
    "        return self._bins\n",
    "    \n",
    "    @property\n",
    "    def bin_edges(self):\n",
    "        return self._bin_edges\n",
    "    \n",
    "    @property\n",
    "    def bin_mids(self):\n",
    "        return (self._bin_edges[1:] + self._bin_edges[:-1]) / 2.\n",
    "    \n",
    "    @property\n",
    "    def bin_counts(self):\n",
    "        return self._bin_counts\n",
    "    \n",
    "    @property\n",
    "    def mean(self):\n",
    "        return self._mean\n",
    "    \n",
    "    @property\n",
    "    def std(self):\n",
    "        return self._std\n",
    "    \n",
    "    @property\n",
    "    def entries(self):\n",
    "        return self._entries\n",
    "    \n",
    "    @property\n",
    "    def underflow(self):\n",
    "        return self._underflow\n",
    "    \n",
    "    @property\n",
    "    def overflow(self):\n",
    "        return self._overflow\n",
    "    \n",
    "    def draw(self, *args, **kwargs):\n",
    "        plt.hist(x=self.bin_mids, bins=self.bin_edges, weights=self.bin_counts, *args, **kwargs)\n",
    "        \n",
    "    def save(self, file_path):\n",
    "        with pd.HDFStore(path=file_path, mode=\"w\") as hdf5store:\n",
    "            hdf5store.append(key=\"bin_edges\", value=pd.Series(self.bin_edges))\n",
    "            hdf5store.append(key=\"bin_counts\", value=pd.Series(self.bin_counts))\n",
    "            meta_info = pd.Series([self.mean, self.std, self.entries, self.underflow, self.overflow])\n",
    "            hdf5store.append(key=\"meta_info\", value=meta_info)\n",
    "        \n",
    "    @classmethod\n",
    "    def load(cls, file_path):\n",
    "        with pd.HDFStore(path=file_path, mode=\"r\") as hdf5store:\n",
    "            bin_edges = hdf5store.get(key=\"bin_edges\")\n",
    "            bin_counts = hdf5store.get(key=\"bin_counts\")\n",
    "            meta_info = hdf5store.get(key=\"meta_info\")\n",
    "        assert len(bin_counts.index) + 1 == len(bin_edges.index)\n",
    "        \n",
    "        instance = cls(data=(bin_counts, bin_edges, meta_info))\n",
    "        return instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist = HistogramClass(gaussian_numbers, bins=20)\n",
    "hist.draw()\n",
    "hist.save(\"hist.hist\")\n",
    "# TODO: Initialize a HistogramClass filled with your data\n",
    "# TODO: Draw and save the histogram."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### ROOT Approach:\n",
    "\n",
    "With ROOT you can just store the `TH1F` object to a ROOT file using the build-in methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "root_file = TFile(\"root_histogram_with_gaussian_random_numbers.root\", \"recreate\")\n",
    "\n",
    "# TODO: Write the ROOT histogram to the root_file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Exercise 1.3\n",
    "\n",
    "Load the histogram you wrote to disk in Exercise 1.2 again and plot it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Python Approach:\n",
    "\n",
    "Using the interface of the `HistogramClass` this is now easy. You can initialize a `HistogramClass` instance from a given file by using the class method `HistogramClass.load`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist = HistogramClass.load('hist.hist')\n",
    "hist.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### ROOT Approach:\n",
    "\n",
    "Create the `TFile` object for the file you saved earlier and get your ROOT `TH1F` histogram from it. Use a canvas as described in Exercise 1.1 to draw the loaded histogram."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# TODO: Load and your ROOT histogram again and draw it to a new canvas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Compare the sizes of the different files, if you made the effort to implement more than one approach to store a histogram and/or the raw data\n",
    "\n",
    "You can use for instance [`os.path.getsize`](https://docs.python.org/3/library/os.path.html#os.path.getsize) or `!ls -lh` to do this. Evaluate the file sizes for different amounts of gaussian random numbers `N`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "# TODO: Try any of the methods to check the file sizes of your histograms or raw data,\n",
    "#       if you saved them in different formats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Exercise 1.4\n",
    "\n",
    "Fit a Gaussian function to the histogram(s) you created in the previous exercises."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Python Approach:\n",
    "\n",
    "To perform a fit to your numpy histogram, you can use the fitting tools provided in the [`scipy.optimize` package](https://docs.scipy.org/doc/scipy/reference/optimize.html), for instance the [`curve_fit` method](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html). You can find an example on how to use it [here](https://riptutorial.com/scipy/example/31081/fitting-a-function-to-data-from-a-histogram).\n",
    "\n",
    "You will have to define the function describing the gaussian distribution you want to fit to the histogram. To plot this function you can use the [`matplotlib.pyplot.plot` plot function](https://matplotlib.org/3.2.1/api/_as_gen/matplotlib.pyplot.plot.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.optimize import curve_fit\n",
    "import scipy.stats as stats\n",
    "\n",
    "# TODO: Define your Gaussian fit function\n",
    "#stats.norm.pdf(x, mu, sigma)\n",
    "\n",
    "# TODO: Implement the fit\n",
    "centers = (hist.bin_edges[:-1] + hist.bin_edges[1:])/2\n",
    "binwidth = hist.bin_edges[1] - hist.bin_edges[0]\n",
    "(mu, sigma), ((Dmu,_),(_,Dsigma)) = curve_fit(stats.norm.pdf, centers, hist.bin_counts/np.sum(hist.bin_counts)/binwidth, p0=(0,1))\n",
    "\n",
    "# Plot the histogram and the fitted function.\n",
    "hist.draw(density=True)\n",
    "x = np.linspace(np.min(hist.bin_edges), np.max(hist.bin_edges), 200)\n",
    "plt.plot(x, stats.norm.pdf(x, mu, sigma))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### ROOT Approach:\n",
    "\n",
    "Define a ROOT `TF1` `gaus` function to be fitted to the ROOT histogram. To perform the fit, use the predefined [`Fit` method of the ROOT histogram](https://root.cern.ch/doc/master/classTH1.html#a63eb028df86bc86c8e20c989eb23fb2a).\n",
    "\n",
    "Draw the histogram again onto a new canvas using the same approach as above to visualize the result of the fit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Define a gaussian function\n",
    "# TODO: Define the TF1 gaussian function to be fitted to the histogram\n",
    "\n",
    "# Fit the histogram with this function\n",
    "# TODO: Perform the fit of the gaussian to the ROOT root_histogram\n",
    "\n",
    "c3 = TCanvas(\"c3\", \"c3\")\n",
    "# TODO: Draw the histogram to the canvas c3 to show the fitted function and the histogram itself"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Exercise 1.5\n",
    "\n",
    "Make the plot nicer and save it as vector graphic, e.g. eps or pdf. The latter can be displayed within jupyter lab by clicking on it in your file browser on the left.\n",
    "\n",
    "The plot should:\n",
    "- use blue filled boxes for the histogram with horizontal error bars to indicate the bin width\n",
    "- show the fitted gaussian function as red line with a thickness/width of 3\n",
    "- label the `x` and `y` axes with \"x\" and \"Entries\", respectively\n",
    "- display the mean and standard deviation of the histogram in the legend\n",
    "- display the fitted parameters with uncertainties as well as the fit probability in the legend."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Python Approach\n",
    "\n",
    "Matplotlib provides a lot of information about the available plot style options in the documentation of the respective plot functions. You will also find a lot of matplotlib examples when googling for certain key words.\n",
    "To get change the style of your plot more drastically, you might have to change the plot function you are using. Have a look at `matplotlib.pyplot.errorbar` instead of `matplotlib.pyplot.hist`, for instance.\n",
    "\n",
    "Obtaining the fit probability in python is not as simple as with ROOT, so you can skip it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10,8))\n",
    "from scipy.optimize import curve_fit\n",
    "import scipy.stats as stats\n",
    "\n",
    "# TODO: Define your Gaussian fit function\n",
    "#stats.norm.pdf(x, mu, sigma)\n",
    "plt.errorbar(hist.bin_mids, \n",
    "             hist.bin_counts, \n",
    "             color=\"blue\", \n",
    "             fmt=\".\", \n",
    "             xerr=binwidth/2, \n",
    "             capsize=2, \n",
    "             label=f\"$\\mu$={hist.mean:.4f}, $\\sigma$={hist.std:.3f}\")\n",
    "#hist.draw(rwidth=0.5)\n",
    "\n",
    "x = np.linspace(np.min(hist.bin_edges), np.max(hist.bin_edges), 200)\n",
    "plt.plot(x, \n",
    "         stats.norm.pdf(x, 0, 1)*np.sum(hist.bin_counts)*binwidth, \n",
    "         linewidth=3, \n",
    "         color=\"red\",\n",
    "         label=f\"$\\mu$={mu:.4f}$\\pm${np.sqrt(Dmu):.4f}, $\\sigma$={sigma:.4f}$\\pm${np.sqrt(Dsigma):.4f}\")\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "plt.ylabel(\"Entries\")\n",
    "plt.xlabel(\"x\")\n",
    "plt.savefig(\"plt.pdf\", format=\"pdf\", bbox_inches=\"tight\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"800\"\n",
       "            height=\"600\"\n",
       "            src=\"plt.pdf\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "            \n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7efc91a147c0>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame(\"plt.pdf\", width=800, height=600)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### ROOT Approach\n",
    "\n",
    "To improve the histogram plot, you can for instance have a look at the options described in [the overview of ROOT's `TStyle` Class](https://root.cern.ch/doc/master/classTStyle.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from ROOT import TH1F, TFile, TF1, gStyle\n",
    "\n",
    "# TODO: Change the properties of gStyle, the ROOT histogram and the gaussian fit function\n",
    "#       to improve the style of the plot\n",
    "\n",
    "c4 = TCanvas(\"c4\", \"c4\")\n",
    "\n",
    "# TODO: Draw the histogram to the canvas c4 and save it as vector graphic (pdf files can be viewed with JupyterLab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### **Exercise 1.6 (Obligatory)**\n",
    "\n",
    "Fill a histogram with the quotient $f(x_1,x_2) = x_1/x_2$ of two Gaussian distributed random numbers $x_1$ and $x_2$ with the mean $m_1 = 2$ and standard deviation $\\sigma_1 = 1.5$ and $m_2 = 3$, $\\sigma_2 = 2.2$, respectively.\n",
    "\n",
    "Assuming standard error propagation without correlations\n",
    "$$ \\sigma_f^2 = \\sum_i \\left( \\frac{\\partial f}{\\partial x_i} \\right)^2 \\sigma^2_i $$\n",
    "calculate the propagated uncertainty for this function $f(x_1,x_2)$ (using the mean values of $x_1$ and $x_2$).\n",
    "\n",
    "How does the result compare with the properties of the created histogram?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Theoretical Calculation\n",
    "\n",
    "$$ \\sigma_f^2\n",
    "= \\left( \\frac{\\partial f}{\\partial x_1} \\right)^2 \\sigma^2_1 + \\left( \\frac{\\partial f}{\\partial x_2} \\right)^2 \\sigma^2_2 \n",
    "= \\left( \\frac{1}{m_2} \\right)^2 \\sigma^2_1 + \\left( -\\frac{m_1}{ m_2^2} \\right)^2 \\sigma^2_2 \n",
    "= \\left( \\frac{1.5}{3} \\right)^2 + \\left( \\frac{2 \\cdot 2.2}{ 3^2} \\right)^2 = 3961/8100 \\approx 0.4890\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Python Approach\n",
    "\n",
    "Use the methods you learned in the previous exercises to create three numpy arrays containing the random numbers with the properties of $x_1$, $x_2$ and $f(x_1, x_2)$ where the last is simply the quotient of the first two arrays. Plot and evaluate the histograms of these random numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_histograms(N, mean1=2., sigma1=1.5, mean2=3., sigma2=2.2, bins=100):\n",
    "    # Create numpy arrays with gaussian distributed numbers for x_1 and x_2\n",
    "    # TODO: Create the arrays gauss1 and gauss2 with the random numbers\n",
    "    gauss1 = np.random.normal(loc=mean1, scale=sigma1, size=(N))\n",
    "    gauss2 = np.random.normal(loc=mean2, scale=sigma2, size=(N))\n",
    "    \n",
    "    # Calculate the array containing the quotient of x_1 and x_2\n",
    "    f = gauss1/gauss2\n",
    "    \n",
    "    fig, ax = plt.subplots(nrows=3, ncols=1, sharex=True)\n",
    "    print\n",
    "    ax[0].hist(gauss1, bins=bins)\n",
    "    ax[1].hist(gauss2, bins=bins)\n",
    "    ax[2].hist(f, bins=bins, range=(-5,10))\n",
    "    \n",
    "    plt.show()\n",
    "    # Return the numpy arrays\n",
    "    return gauss1, gauss2, f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x1, x2, quotient = create_histograms(N=1000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hist1: mean=2.0021(Theo: 2), std=1.4986(Theo: 1.5)\n",
      "hist1: mean=2.9957(Theo: 3), std=2.1904(Theo: 2.2)\n",
      "hist1: mean=0.6628(Theo: 0.6666), std=1.6497(Theo: 0.4890)\n"
     ]
    }
   ],
   "source": [
    "# TODO: Create three HistogramClass instances from the three arrays you created.\n",
    "#       Use 100 bins and a range from -10 to 10.\n",
    "hist1 = HistogramClass(x1, bins=100, bin_range=(-10,10))\n",
    "hist1.draw()\n",
    "plt.show()\n",
    "hist2 = HistogramClass(x2, bins=100, bin_range=(-10,10))\n",
    "hist2.draw()\n",
    "plt.show()\n",
    "histf = HistogramClass(quotient, bins=100, bin_range=(-10,10))\n",
    "histf.draw()\n",
    "plt.show()\n",
    "\n",
    "print(f\"hist1: mean={hist1.mean:.4f}(Theo: 2), std={hist1.std:.4f}(Theo: 1.5)\")\n",
    "print(f\"hist1: mean={hist2.mean:.4f}(Theo: 3), std={hist2.std:.4f}(Theo: 2.2)\")\n",
    "print(f\"hist1: mean={histf.mean:.4f}(Theo: 0.6666), std={histf.std:.4f}(Theo: 0.4890)\")\n",
    "      \n",
    "\n",
    "# TODO: Plot the histograms and determine their mean and standard deviation to be\n",
    "#       able to compare them with the original values and the theoretical calculation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Root Approach\n",
    "\n",
    "Similar to the methods used in Exercise 1.1, use the ROOT method `gRandom.Gaus` to generate the random numbers $x_1$ and $x_2$ and fill `TH1F` histograms with them. Fill also a histogram with the quotient `f = x_1/x_2`.\n",
    "Draw and evaluate the three histograms with the methods you learned in the previous exercises."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_root_histograms(N, bins=100, bin_range=(-10., 10.)):\n",
    "    # Create histogram for the distribution of x, y and f(x,y) = x/y with 100 bins from -10 to 10\n",
    "    min_bin, max_bin = bin_range\n",
    "    # Initialize three TH1F ROOT histograms for x_1, x_2 and f\n",
    "\n",
    "    # Initialize the random numbers generator\n",
    "    gRandom.SetSeed()\n",
    "\n",
    "    # Generate 2 x N random numbers following a gaussian distribution\n",
    "    # one with mean = 2 and sigma = 1.5 and\n",
    "    # one with mean = 3 and sigma = 2.2 and\n",
    "\n",
    "    for i in range(N):\n",
    "        pass # TODO: Fill the three histograms with the TH1F.Fill method\n",
    "    \n",
    "    # TODO: Return the three ROOT histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "cannot unpack non-iterable NoneType object",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[25], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m x1_hist, x2_hist, f_hist \u001b[38;5;241m=\u001b[39m create_root_histograms(N\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m100000\u001b[39m)\n\u001b[1;32m      3\u001b[0m \u001b[38;5;66;03m# Draw the three histograms onto the canvases c5, c6 and c7\u001b[39;00m\n\u001b[1;32m      5\u001b[0m c5 \u001b[38;5;241m=\u001b[39m TCanvas(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mc5\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mc5\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mTypeError\u001b[0m: cannot unpack non-iterable NoneType object"
     ]
    }
   ],
   "source": [
    "x1_hist, x2_hist, f_hist = create_root_histograms(N=100000)\n",
    "\n",
    "# Draw the three histograms onto the canvases c5, c6 and c7\n",
    "\n",
    "c5 = TCanvas(\"c5\", \"c5\")\n",
    "\n",
    "c6 = TCanvas(\"c6\", \"c6\")\n",
    "\n",
    "c7 = TCanvas(\"c7\", \"c7\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**Write down what you observe when you compare the result of the theoretical calculation with what you obtained using the random numbers.**\n",
    "\n",
    "Die Standardabweichung für den Quotienten der gaussverteilten Zufallszahlen entspricht nicht dem nach gausscher Fehlerfortpflanzung errechnetem Wert. Dies liegt daran, dass die gaussche Fehlerfortpflanzung in dieser Art nur für lineare berechnungen funktioniert. Da hier durch eine der größen Geteilt wird liefert die Fehlerfortpflanzung falsche ergebnisse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}