{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Coffea Histograms (deprecated)\n",
    "\n",
    "_This feature is deprecated in favor of [hist](https://hist.readthedocs.io/en/latest/) and [mplhep](https://mplhep.readthedocs.io/en/latest/). A migration guide can be found in discussion [CoffeaTeam/coffea#705](https://github.com/CoffeaTeam/coffea/discussions/705)_\n",
    "\n",
    "This is a rendered copy of [histograms.ipynb](https://github.com/CoffeaTeam/coffea/blob/master/binder/histograms.ipynb). You can optionally run it interactively on [binder at this link](https://mybinder.org/v2/gh/coffeateam/coffea/master?filepath=binder%2Fhistograms.ipynb)\n",
    "\n",
    "In scientific python, histograms seem to be considered as a plot style, on equal footing with, e.g. scatter plots.\n",
    "It may well be that HEP is the only place where users need to plot *pre-binned* data, and thus must use histograms as persistent objects representing reduced data.  In Coffea, the [hist](https://coffeateam.github.io/coffea/modules/coffea.hist.html) subpackage provides a persistable mergable histogram object. This notebook will discuss a few ways that such objects can be manipulated.\n",
    "\n",
    "A histogram object roughly goes through three stages in its life:\n",
    "\n",
    "   - Filling\n",
    "   - Transformation (projection, rebinning, integrating)\n",
    "   - Plotting\n",
    "\n",
    "We'll go over examples of each stage in this notebook, and conclude with some styling examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filling\n",
    "Let's start with filling.  We'll use a random distribution [near and dear](https://en.wikipedia.org/wiki/ARGUS_distribution) to of b and c factory physicists, and have the numpy builtin [histogram function](https://numpy.org/doc/stable/reference/generated/numpy.histogram.html) do the work for us:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([ 16,  47,  66,  95, 125, 113, 137, 167, 143,  91]), array([0.002894  , 0.10257766, 0.20226132, 0.30194498, 0.40162865,\n",
      "       0.50131231, 0.60099597, 0.70067963, 0.80036329, 0.90004695,\n",
      "       0.99973061]))\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy.stats import argus\n",
    "\n",
    "vals = argus(chi=.5).rvs(size=1000)\n",
    "\n",
    "hist = np.histogram(vals)\n",
    "print(hist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we're done, right?\n",
    "Probably not: we have more than 1000 events, and probably need to use some map-reduce paradigm to fill the histogram because we can't keep all 1 billion `vals` in memory.  So we need two things: a binning, so that all histograms that were independently created can be added, and the ability to add two histograms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "binning = np.linspace(0, 1, 50)\n",
    "\n",
    "def add_histos(h1, h2):\n",
    "    h1sumw, h1binning = h1\n",
    "    h2sumw, h2binning = h2\n",
    "    if h1binning.shape == h2binning.shape and np.all(h1binning==h2binning):\n",
    "        return h1sumw+h2sumw, h1binning\n",
    "    else:\n",
    "        raise ValueError(\"The histograms have inconsistent binning\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([ 2,  6,  6,  6, 12, 18, 20, 16, 14, 28, 22, 26, 28, 42, 18, 34, 28,\n",
      "       48, 40, 42, 42, 60, 46, 62, 46, 52, 46, 38, 52, 54, 50, 58, 72, 54,\n",
      "       50, 74, 80, 58, 70, 70, 42, 64, 68, 52, 60, 32, 44, 30, 18]), array([0.        , 0.02040816, 0.04081633, 0.06122449, 0.08163265,\n",
      "       0.10204082, 0.12244898, 0.14285714, 0.16326531, 0.18367347,\n",
      "       0.20408163, 0.2244898 , 0.24489796, 0.26530612, 0.28571429,\n",
      "       0.30612245, 0.32653061, 0.34693878, 0.36734694, 0.3877551 ,\n",
      "       0.40816327, 0.42857143, 0.44897959, 0.46938776, 0.48979592,\n",
      "       0.51020408, 0.53061224, 0.55102041, 0.57142857, 0.59183673,\n",
      "       0.6122449 , 0.63265306, 0.65306122, 0.67346939, 0.69387755,\n",
      "       0.71428571, 0.73469388, 0.75510204, 0.7755102 , 0.79591837,\n",
      "       0.81632653, 0.83673469, 0.85714286, 0.87755102, 0.89795918,\n",
      "       0.91836735, 0.93877551, 0.95918367, 0.97959184, 1.        ]))\n"
     ]
    }
   ],
   "source": [
    "vals2 = argus(chi=.5).rvs(size=1000)\n",
    "\n",
    "hist1 = np.histogram(vals, bins=binning)\n",
    "hist2 = np.histogram(vals, bins=binning)\n",
    "\n",
    "hist = add_histos(hist1, hist2)\n",
    "print(hist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So now we have everything we need to make our own equivalent to ROOT TH1, from a filling perspective:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class myTH1:\n",
    "    def __init__(self, binning):\n",
    "        self._binning = binning\n",
    "        self._sumw = np.zeros(binning.size - 1)\n",
    "    \n",
    "    def fill(self, values, weights=None):\n",
    "        sumw, _ = np.histogram(values, bins=self._binning, weights=weights)\n",
    "        self._sumw += sumw\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        if not isinstance(other, myTH1):\n",
    "            raise ValueError\n",
    "        if not np.array_equal(other._binning, self._binning):\n",
    "            raise ValueError(\"The histograms have inconsistent binning\")\n",
    "        out = myTH1(self._binning)\n",
    "        out._sumw = self._sumw + other._sumw\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3.  3.  7.  5.  9. 18. 16. 17. 15. 24. 26. 27. 34. 37. 23. 38. 29. 46.\n",
      " 40. 40. 36. 50. 47. 49. 57. 49. 50. 44. 59. 69. 55. 52. 68. 54. 48. 72.\n",
      " 72. 64. 55. 74. 57. 64. 63. 55. 49. 39. 39. 31. 22.]\n"
     ]
    }
   ],
   "source": [
    "binning = np.linspace(0, 1, 50)\n",
    "\n",
    "h1 = myTH1(binning)\n",
    "h1.fill(vals)\n",
    "\n",
    "h2 = myTH1(binning)\n",
    "h2.fill(vals2)\n",
    "\n",
    "h = h1 + h2\n",
    "print(h._sumw)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Homework: add `sumw2` support.\n",
    "\n",
    "Of course, we might want multidimensional histograms.  There is `np.histogramdd`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "xyz = np.random.multivariate_normal(mean=[1, 3, 7], cov=np.eye(3), size=10000)\n",
    "\n",
    "xbins = np.linspace(-10, 10, 20)\n",
    "ybins = np.linspace(-10, 10, 20)\n",
    "zbins = np.linspace(-10, 10, 20)\n",
    "hnumpy = np.histogramdd(xyz, bins=(xbins, ybins, zbins))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but we are becoming challenged by book-keeping of the variables.\n",
    "The [histogram class](https://coffeateam.github.io/coffea/api/coffea.hist.Hist.html#coffea.hist.Hist) in Coffea is designed to simplify this operation, and the eventual successor (for filling purposes) [boost-histogram](https://github.com/scikit-hep/boost-histogram#usage) has similar syntax.\n",
    "\n",
    "In the constructor you specify each axis, either as a numeric `Bin` axis or a categorical `Cat` axis. Each axis constructor takes arguments similar to ROOT TH1 constructors. One can pass an array to the `Bin` axis for non-uniform binning. Then the fill call is as simple as passing the respective arrays to `histo.fill`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Hist (sample,x,y,z) instance at 0x7fa15cf61390>\n"
     ]
    }
   ],
   "source": [
    "import coffea.hist as hist\n",
    "\n",
    "histo = hist.Hist(\"Counts\",\n",
    "                  hist.Cat(\"sample\", \"sample name\"),\n",
    "                  hist.Bin(\"x\", \"x value\", 20, -10, 10),\n",
    "                  hist.Bin(\"y\", \"y value\", 20, -10, 10),\n",
    "                  hist.Bin(\"z\", \"z value\", 20, -10, 10),\n",
    "                 )\n",
    "\n",
    "histo.fill(sample=\"sample 1\", x=xyz[:,0], y=xyz[:,1], z=xyz[:,2])\n",
    "\n",
    "# suppose we have another sample of xyz values\n",
    "xyz_sample2 = np.random.multivariate_normal(mean=[1, 3, 7], cov=np.eye(3), size=10000)\n",
    "\n",
    "# additionally, lets assume entries in sample 2 have some non-uniform weight equal to atan(distance from origin)\n",
    "weight = np.arctan(np.sqrt(np.power(xyz_sample2, 2).sum(axis=1)))\n",
    "\n",
    "# weight is a reserved keyword in Hist, and can be added to any fill() call\n",
    "histo.fill(sample=\"sample 2\", x=xyz_sample2[:,0], y=xyz_sample2[:,1], z=xyz_sample2[:,2], weight=weight)\n",
    "\n",
    "print(histo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For more details, look at:\n",
    "# help(hist.Hist)\n",
    "# help(hist.Bin)\n",
    "# help(hist.Cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transformation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are a few examples of transformations on multidimensional histograms in Coffea.  For each, the docstring (`help(function)` or shift+tab in Jupyter) provides useful info."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Hist (sample,y,z) instance at 0x7fa15ba1af10>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sum all x bins within nominal range (-10, 10)\n",
    "histo.sum(\"x\", overflow='none')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is some analog to fancy array slicing for histogram objects, which is supported (with reasonable consistency) in Coffea, where the slice boundaries are physical axis values, rather than bin indices.  All values outside the slice range are merged into overflow bins.\n",
    "\n",
    "For a lengthy discussion on possible slicing syntax for the future, see [boost-histogram#35](https://github.com/scikit-hep/boost-histogram/issues/35)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Hist (sample,x,y,z) instance at 0x7fa15de8e650>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[<Interval ((-inf, 4)) instance at 0x7fa15ea2c710>,\n",
       " <Interval ([4, 5)) instance at 0x7fa15ea2c790>,\n",
       " <Interval ([5, 6)) instance at 0x7fa15ea2c7d0>,\n",
       " <Interval ([6, 7)) instance at 0x7fa15ea2c810>,\n",
       " <Interval ([7, 8)) instance at 0x7fa15ea2c850>,\n",
       " <Interval ([8, 9)) instance at 0x7fa15ea2c8d0>,\n",
       " <Interval ([9, 10)) instance at 0x7fa15ea2c910>,\n",
       " <Interval ([10, inf)) instance at 0x7fa15ea2c950>]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sliced = histo[:,0:,4:,0:]\n",
    "display(sliced)\n",
    "display(sliced.identifiers(\"y\", overflow='all'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Hist (sample,x,z) instance at 0x7fa15ea2cd50>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# integrate y bins from -2 to +10\n",
    "histo.integrate(\"y\", slice(0, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Hist (sample,x,y,znew) instance at 0x7fa15eb2d710>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# rebin z axis by providing a new axis definition\n",
    "histo.rebin(\"z\", hist.Bin(\"znew\", \"rebinned z value\", [-10, -6, 6, 10]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Hist (cat,x,y,z) instance at 0x7fa15eb307d0>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# merge categorical axes\n",
    "mapping = {\n",
    "    'all samples': ['sample 1', 'sample 2'],\n",
    "    'just sample 1': ['sample 1'],\n",
    "}\n",
    "histo.group(\"sample\", hist.Cat(\"cat\", \"new category\"), mapping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# scale entire histogram by 3 (in-place)\n",
    "histo.scale(3.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# scale samples by different values (also in-place)\n",
    "scales = {\n",
    "    'sample 1': 1.2,\n",
    "    'sample 2': 0.2,\n",
    "}\n",
    "histo.scale(scales, axis='sample')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<StringBin (sample 1) instance at 0x7fa15e7ab7d0>,\n",
       " <StringBin (sample 2) instance at 0x7fa15e7ab810>]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[<Interval ([-10, -9)) instance at 0x7fa15ceadfd0>,\n",
       " <Interval ([-9, -8)) instance at 0x7fa15ceadd90>,\n",
       " <Interval ([-8, -7)) instance at 0x7fa15cead350>,\n",
       " <Interval ([-7, -6)) instance at 0x7fa15cead750>,\n",
       " <Interval ([-6, -5)) instance at 0x7fa15ceadb50>,\n",
       " <Interval ([-5, -4)) instance at 0x7fa15cead1d0>,\n",
       " <Interval ([-4, -3)) instance at 0x7fa15ceade90>,\n",
       " <Interval ([-3, -2)) instance at 0x7fa15cead250>,\n",
       " <Interval ([-2, -1)) instance at 0x7fa15ceada90>,\n",
       " <Interval ([-1, 0)) instance at 0x7fa15cead210>,\n",
       " <Interval ([0, 1)) instance at 0x7fa15cead090>,\n",
       " <Interval ([1, 2)) instance at 0x7fa15cead710>,\n",
       " <Interval ([2, 3)) instance at 0x7fa15cead610>,\n",
       " <Interval ([3, 4)) instance at 0x7fa15cead0d0>,\n",
       " <Interval ([4, 5)) instance at 0x7fa15bec6710>,\n",
       " <Interval ([5, 6)) instance at 0x7fa15ce87f90>,\n",
       " <Interval ([6, 7)) instance at 0x7fa15eb361d0>,\n",
       " <Interval ([7, 8)) instance at 0x7fa15eb36250>,\n",
       " <Interval ([8, 9)) instance at 0x7fa15eb36310>,\n",
       " <Interval ([9, 10)) instance at 0x7fa15eb363d0>]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# useful debugging tool: print bins, aka 'identifiers'\n",
    "display(histo.identifiers('sample'))\n",
    "display(histo.identifiers('x'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('sample 1',): array([0.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00,\n",
       "        0.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00, 0.00000e+00,\n",
       "        0.00000e+00, 0.00000e+00, 3.60000e+00, 5.40000e+01, 7.23600e+02,\n",
       "        4.83120e+03, 1.24164e+04, 1.24344e+04, 4.68720e+03, 8.13600e+02]),\n",
       " ('sample 2',): array([0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
       "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
       "        7.67352230e-01, 1.23975181e+01, 1.91084135e+02, 1.16950599e+03,\n",
       "        3.00209800e+03, 2.88614286e+03, 1.20687727e+03, 1.68492970e+02])}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# bin contents are accessed using values\n",
    "histo.sum('x', 'y').values(sumw2=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/lagray/miniconda3/envs/coffea-work/lib/python3.7/site-packages/uproot3/__init__.py:138: FutureWarning: Consider switching from 'uproot3' to 'uproot', since the new interface became the default in 2020.\n",
      "\n",
      "    pip install -U uproot\n",
      "\n",
      "In Python:\n",
      "\n",
      "    >>> import uproot\n",
      "    >>> with uproot.open(...) as file:\n",
      "    ...\n",
      "\n",
      "  FutureWarning\n"
     ]
    }
   ],
   "source": [
    "# data can be exported to ROOT via uproot3 (soon uproot v4 as well), but only 1D\n",
    "import uproot3\n",
    "import os\n",
    "\n",
    "if os.path.exists(\"output.root\"):\n",
    "    os.remove(\"output.root\")\n",
    "\n",
    "outputfile = uproot3.create(\"output.root\")\n",
    "h = histo.sum('x', 'y')\n",
    "for sample in h.identifiers('sample'):\n",
    "    outputfile[sample.name] = hist.export1d(h.integrate('sample', sample))\n",
    "outputfile.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting\n",
    "The most integrated plotting utility in the scientific python ecosystem, by far, is [matplotlib](https://matplotlib.org/).  However, as we will see, it is not tailored to HEP needs.\n",
    "\n",
    "Let's start by looking at basic mpl histogramming."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "vals = argus(chi=.5).rvs(size=1000)\n",
    "\n",
    "# notice the semicolon, which prevents display of the return values\n",
    "plt.hist(vals);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we want to plot pre-binned data, for example from our earlier `np.histogram` usage.  Here we start running into the edge of typical mpl usage.  As mentioned before, apparently HEP is the only regular user of pre-binned histograms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "binning = np.linspace(0, 1, 50)\n",
    "\n",
    "h1vals, h1bins = np.histogram(vals, bins=binning)\n",
    "plt.step(x=h1bins[:-1], y=h1vals, where='post');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To facilitate these operations, there is a package called [mplhep](https://github.com/scikit-hep/mplhep). This package is available standlaone, but it is also used internally by the `coffea.hist` subpackage to provide several convenience functions to aid in plotting `Hist` objects:\n",
    "\n",
    " * [plot1d](https://coffeateam.github.io/coffea/api/coffea.hist.plot1d.html#coffea.hist.plot1d): Create a 1D plot from a 1D or 2D Hist object\n",
    "\n",
    " * [plotratio](https://coffeateam.github.io/coffea/api/coffea.hist.plotratio.html#coffea.hist.plotratio): Create a ratio plot, dividing two compatible histograms\n",
    "\n",
    " * [plot2d](https://coffeateam.github.io/coffea/api/coffea.hist.plot2d.html#coffea.hist.plot2d): Create a 2D plot from a 2D Hist object\n",
    "\n",
    " * [plotgrid](https://coffeateam.github.io/coffea/api/coffea.hist.plotgrid.html#coffea.hist.plotgrid): Create a grid of plots, enumerating identifiers on up to 3 axes\n",
    " \n",
    "Below are some simple examples of using each function on our `histo` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist.plot1d(histo.sum(\"x\", \"y\"), overlay='sample');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist.plot1d(histo.sum(\"x\", \"y\"), overlay='sample', stack=True);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist.plot2d(histo.sum('x', 'sample'), xaxis='y');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# make coarse binned hist and look at several distributions\n",
    "hnew = (\n",
    "    histo\n",
    "    .rebin(\"y\", hist.Bin(\"ynew\", \"rebinned y value\", [0, 3, 5]))\n",
    "    .rebin(\"z\", hist.Bin(\"znew\", \"rebinned z value\", [5, 8, 10]))\n",
    ")\n",
    "\n",
    "hist.plotgrid(hnew, row='ynew', col='znew', overlay='sample');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/lagray/coffea/coffea/binder/coffea/hist/plot.py:357: RuntimeWarning: invalid value encountered in true_divide\n",
      "  rsumw = sumw_num / sumw_denom\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(-10.0, 10.0)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "numerator = histo.integrate('sample', 'sample 1').sum('y', 'z')\n",
    "denominator = histo.sum('sample', 'y', 'z')\n",
    "\n",
    "numerator.label = r'$\\epsilon$'\n",
    "ax = hist.plotratio(\n",
    "    num=numerator,\n",
    "    denom=denominator,\n",
    "    error_opts={'color': 'k', 'marker': '.'},\n",
    "    unc='clopper-pearson'\n",
    ")\n",
    "ax.set_ylim(0.6, 1.)\n",
    "ax.set_xlim(-10, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Styling\n",
    "\n",
    "We've covered the basics of plotting, now let's go over some styling options. To make things more interesting, we'll load some electron and muon Lorentz vectors from simulated $H\\rightarrow ZZ^{*}$ events into awkward arrays and then plot some kinematic quantities for them, making liberal use of the matplotlib styling options which are exposed through the coffea plotting utilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\r\n",
      "                                 Dload  Upload   Total   Spent    Left  Speed\r\n",
      "\r",
      "  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0\r",
      "100  212k  100  212k    0     0  7601k      0 --:--:-- --:--:-- --:--:-- 7601k\r\n"
     ]
    }
   ],
   "source": [
    "!curl -OL http://scikit-hep.org/uproot3/examples/HZZ.root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Avg. electrons/event: 0.07063197026022305\n",
      "Avg. muons/event: 1.579925650557621\n"
     ]
    }
   ],
   "source": [
    "import uproot\n",
    "import awkward as ak\n",
    "from coffea.nanoevents.methods import vector\n",
    "ak.behavior.update(vector.behavior)\n",
    "\n",
    "fin = uproot.open(\"HZZ.root\")\n",
    "tree = fin[\"events\"]\n",
    "\n",
    "# let's build the lepton arrays back into objects\n",
    "# in the future, some of this verbosity can be reduced\n",
    "arrays = {k.replace('Electron_', ''): v for k, v in tree.arrays(filter_name=\"Electron_*\", how=dict).items()}\n",
    "electrons = ak.zip({'x': arrays.pop('Px'), \n",
    "                    'y': arrays.pop('Py'), \n",
    "                    'z': arrays.pop(\"Pz\"),\n",
    "                    't': arrays.pop(\"E\"),\n",
    "                    },\n",
    "                    with_name=\"LorentzVector\"\n",
    ")\n",
    "\n",
    "\n",
    "arrays = {k.replace('Muon_', ''): v for k,v in tree.arrays(filter_name=\"Muon_*\", how=dict).items()}\n",
    "muons = ak.zip({'x': arrays.pop('Px'), \n",
    "                'y': arrays.pop('Py'), \n",
    "                'z': arrays.pop(\"Pz\"),\n",
    "                't': arrays.pop(\"E\"),\n",
    "                },\n",
    "                with_name=\"LorentzVector\"\n",
    ")\n",
    "\n",
    "print(\"Avg. electrons/event:\", ak.sum(ak.num(electrons))/tree.num_entries)\n",
    "print(\"Avg. muons/event:\", ak.sum(ak.num(muons))/tree.num_entries)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "lepton_kinematics = hist.Hist(\n",
    "    \"Events\",\n",
    "    hist.Cat(\"flavor\", \"Lepton flavor\"),\n",
    "    hist.Bin(\"pt\", \"$p_{T}$\", 19, 10, 100),\n",
    "    hist.Bin(\"eta\", \"$\\eta$\", [-2.5, -1.4, 0, 1.4, 2.5]),\n",
    ")\n",
    "\n",
    "# Pass keyword arguments to fill, all arrays must be flat numpy arrays\n",
    "# User is responsible for ensuring all arrays have same jagged structure!\n",
    "lepton_kinematics.fill(\n",
    "    flavor=\"electron\",\n",
    "    pt=ak.flatten(electrons.pt),\n",
    "    eta=ak.flatten(electrons.eta)\n",
    ")\n",
    "lepton_kinematics.fill(\n",
    "    flavor=\"muon\",\n",
    "    pt=ak.flatten(muons.pt),\n",
    "    eta=ak.flatten(muons.eta)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEICAYAAABI7RO5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAh20lEQVR4nO3de5gV1Znv8e+vm5vcBAQ9CEg7yMR4iaIdBgJxiAlqHAUyMRFPZmIiOegjRI2JBj3HJIw6SMJIvBw1eNdhMA5GwHuICSoeJaIBRRkDA4IQFAj3IAj0e/7YRafBht5F72vz+zzPfnbVqqrVb+/evd9da61apYjAzMwsWxXFDsDMzMqLE4eZmaXixGFmZqk4cZiZWSpOHGZmlkqzYgfQGJ07d46qqqpih2FmVlZef/31tRHR5UCPL+vEUVVVxdy5c4sdhplZWZG0rDHHu6nKzMxSceIwM7NUnDjMzCyVsu7jMLODy44dO1ixYgXbtm0rdihloVWrVnTv3p3mzZvntF4nDjMrGytWrKBdu3ZUVVUREXiuvX2LCNatW8fy5cvp1atXTut24jCzsrFt2zaqqqr4+OOP2bhxoxNHAyKCtWvX8uGHH9K/f38k5aReJw4zKys1NTVs2LCBysrKnH0QNmUVFRW8/PLLHHnkkeTqujd3jptZWampqQFw0siSJCSxefPmnNXpxGFmTULPnj0bXcdbb73FzJkzcxBNxvTp0+nfvz9Dhw5l9uzZXHDBBTmru5jcVGV5d82Pr2f1+sZ/2zm8YzvGjb0uBxGZ1W/BggXMmzePwYMH56S+yZMnM3HiRPr168fs2bNzUue+7Ny5k2bNCvOR7sRhebd6/WZOOPc7ja5nwRP35CAaO5gsXbqUH/7wh6xdu5bWrVszceJEevfuzejRo2nZsiXz5s1j8+bNXH/99XzhC1/gpptuYtu2bcyZM4fLL7+cQYMGcdlll7Fs2TIOOeQQbr75Zo4//njGjx/PypUree+991i5ciUXX3wxI0eO3ONn/+xnP6ut56yzztojGb3xxhtce+21bN++nVatWnHrrbfSu3dvzjzzTG655RaOPfZYAIYMGcLYsWOpqqraZxzvvfcey5Yto1u3btx9990FeV2dOMysybryyiuZMGECvXr14vXXX+eqq65i2rRpALz//vvMnDmTpUuXMmzYMF577TXGjBnDvHnzGD9+PABjxozhxBNP5OGHH+bFF19k1KhRzJo1C4BFixYxbdo0tmzZQr9+/fj2t7+9x/USV111FS+99BJjx46lT58+e5xx9O7dmyeffJJmzZrxwgsvcOONN/LAAw8wbNgwpk2bxpgxY/jggw/48MMP6dOnz37jePfdd3nqqac45JBDCvKaghOHmTVRW7Zs4bXXXmPEiBG1Zdu3b69dHjp0KBUVFfTq1YuePXuyaNGiT9QxZ84c7r//fgBOO+001q1bV9vJPHjwYFq2bEnLli3p3Lkza9as4cgjj8wqtk2bNjFq1CiWLFmCJHbs2AHAsGHDOO+88xgzZgzTp09nyJAhDcZx1llnFTRpgBOHmTVREUH79u1rv5nvbe9RWWlHabVo0aJ2ubKykp07d2Z97Lhx4xg4cCAPPfQQy5cvZ+jQoQB07dqVjh078vbbbzNt2jQmTJjQYF2tW7dOFXcueFSVmTVJ7dq1o2fPnkyfPh3IJJIFCxbUbp8xYwY1NTUsXbqUZcuWccwxx9C2bVu2bNlSu0+/fv2YOnUqALNnz+awww6jXbt2jY5t06ZNdO3aFYApU6bsse0rX/kKt912G5s2beL444/PaxwHyonDzJqErVu3cuKJJ9Y+7rjjDu666y4mT57M3//93zNgwACeeeaZ2v27devG4MGDOf/885kwYQKtWrVi4MCBvPvuuwwaNIjHH3+cq6++mvnz53Paaadx/fXXc/vtt+ck1u9+97u1HfK7du3aY9u5557L448/XnsWAuQtjgOlcr5kv7q6Onwjp9I34rKrczaq6t5bf5qDiKxcLVy4kGOOOYZ169Y1aujp6NGjOeOMM2r7EJqypUuX8tJLL/GlL32JE088EQBJr0dE9YHWmfczDkmVkv4g6clk/WhJcyQtlvRLSS2S8pbJ+uJke1W+YzMzs/QK0VR1ObCwzvp4YGJEHAOsB3YPeRgBrE/KJyb7mZnl3O23335QnG3kS14Th6TuwD8A9yTrAk4Hpia7PAgMS5aHJusk278oT0ZjZlZy8n3G8XPgaqAmWT8M2BARu8etrQC6JcvdgPcBku0bk/33IGmkpLmS5q5ZsyaPoZuZWX3yljgknQOsjojXc1lvREyKiOqIqO7SpUsuqzYzsyzk8wLAAcAQSWcDrYD2wC1AB0nNkrOK7sDKZP+VQA9ghaRmwKHAn/MYn5mZHYC8JY6IuAa4BkDSIOAHEfENSf8JnAc8AlwITE8OmZGsv5Js/22U81hhM8u78T+/nT+tXpez+o48vBM/vGJ0zuprqoox5cgPgUck3QD8Abg3Kb8XeFjSYmAdMLwIsZlZGfnT6nUc9w/fzll97zx1f87qasoKcuV4RMyKiHOS5SUR0TcijomIr0XE9qR8W7J+TLJ9SSFiMzNLY/ny5fTr14/Ro0fTt29fLr74Yl544QXOPvtsPvvZz/LGG28wfvz4Pa7uHjhwIMuXLwfgjjvuYODAgQwcOJC77rqrts7+/ftzxRVXMGDAAM477zw++uijovx+2fCUI2ZmKS1dupRLL72UV199lUWLFvHYY4/x1FNPMXbsWCZOnLjP4+bNm8eUKVN47rnnePbZZ3n44Yd58803AViyZAkjRozg5Zdf5tBDD+WJJ54o1K+TmhOHmVlKRx11FMcddxwVFRUce+yxfP7zn0cSxx13HO+///4+j5szZw5nn302bdq0oW3btpxzzjm8+uqrtXXunhLkpJNO2m89xebEYWaWUsuWLWuXKyoqatcrKipqb+FaU1NTu0/d+4BkW2eaadoLzYnDzCzHevToUdsENX/+fJYtWwZkpkd/5pln2Lp1K3/5y1946qmn6NevXzFDPSC+kZOZla0jD++U05FQRx7eKSf1nHvuuTz66KMMGDCAU089lV69egGZJqjhw4dzxhlnAPBP//RPfOYzn6ntOC8Xnlbd8i5X06rPnXE/rbSr4R334/CO7Rg39rpGx2LFkatp1Q8m+ZhW3a+87dM1P76e1es3N7qebVGZg2igekjjx+sveOKeHERidnBz4rB9Wr1+c07OFMysaXHnuJmZpeLEYWZmqThxmJlZKk4cZmaWijvHm6hcjIjK1Wgos3z5xc9vYtOalQ3vmKX2Xbpx8RVjDujYPn368Jvf/IbDDvvEjUv3a/bs2bRo0YK+ffse0M8tBieOJsojouxgsGnNSn40pFfO6vuXGf+ds7qy9fLLL9OmTZt6E8fu6UtKTelFZGZW4h599FHuvvtuduzYwSmnnMLPfvazBrdXVlby/PPPc8MNN1BTU0OnTp245ZZbePDBB6moqGDq1KmMGzeOyZMn07JlS9566y369u3L+eefzw9+8AM++ugjqqqquPXWW+nQoQNDhgzh1FNPZfbs2WzcuJFbbrmF/v37F+T3z+c9x1tJ+r2k+ZLeljQ2KX9A0lJJ85LHyUm5JN0qabGkNyWdkq/YzMwO1B//+EemTZvG008/zaxZs6isrGTq1KkNbl+7di3f+973eOCBB3jhhRe47777OOqoo7jwwgu55JJLmDVrVu0H/5/+9CeeeeYZbrjhBkaNGsWPfvQjXnzxRT796U/vkaR27tzJzJkzufHGGz+RvPIpn2cc24HTI2KLpObAbEnPJNuuioipe+3/ZaB38vg74M7k2cysZLz44ovMnz+fwYMHA/DRRx/RuXPnBrfPnTuX/v3707NnTwA6duy4z58xdOhQKisr2bRpExs3bmTAgAEADB8+nIsuuqh2v3POOQco/DTs+bzneABbktXmyWN/E2MNBR5KjntVUgdJXSNiVb5iNDNLKyIYPnw4112355xnjzzyyH63P/vss1n/jNatW2e1X4sWLQCorKws6DTseR2OK6lS0jxgNTAzIuYkm25MmqMmSto9CX03oG7KXJGU7V3nSElzJc1ds2ZNPsM3M/uE0047jRkzZrD782f9+vV7fNvf1/bq6mpeeeWV2inW169fD0Dbtm3ZsmUL9Wnfvj0dOnTglVdeATJ9J5/73Ofy9rtlK6+d4xGxCzhZUgfgcUknANcAHwAtgEnAD4F/SVHnpOQ4qqury3dqXzNrtPZduuV0JFT7Lp/4rvoJn/rUp7j22mv52te+Rk1NDc2aNeOnP/1pg9urq6u5+eab+da3vkVNTQ2dO3fmscce48wzz+Siiy7i2WefZdy4cZ/4ebfffntt53jPnj257bbbcvb7HqiCTasu6UfA1oiYUKdsEPCDiDhH0i+AWRExJdn2LjBof01VnlZ933I1lXlTs+CJe7j31p82vKOVJE+rnl5ZTasuqQuwIyI2SDoEGAyM391vIUnAMGBBcsgMYLSkR8h0im88GPs3Sm0qczOzveUzZXcFHpRUSaYv5dGIeFLSb5OkImAecEmy/9PA2cBiYCvQ+JsvlCFfuGdmpS6fo6reBPrUU376PvYPYFS+4jGzpqGc71paaBGRl9fLjYRmVjZatWrFunXrih1GWYgINm/ezPbt23NetxOHmZWN7t27s2TJEjZs2EBlpfvx9ici2L59OytXrkQSFRW5u/rCicPMykbz5s05+uij+fd//3e2bt1KmzZtih1Syfv444+pqKjg8MMPz1mdThxmVlZatGjBV7/6VWbNmsWGDRvc59GADh060K9fP7p06ZKzOp04zKzsHHrooQwdOrTYYRy0fAdAMzNLxYnDzMxSceIwM7NUnDjMzCwVJw4zM0vFicPMzFJx4jAzs1ScOMzMLBUnDjMzS8WJw8zMUnHiMDOzVPKWOCS1kvR7SfMlvS1pbFJ+tKQ5khZL+qWkFkl5y2R9cbK9Kl+xmZnZgcvnJIfbgdMjYouk5sBsSc8AVwITI+IRSXcBI4A7k+f1EXGMpOHAeOD8PMZnB6FtUcmIy65udD2Hd2zHuLHX5SAis/KTz1vHBrAlWW2ePAI4HfifSfmDwE/IJI6hyTLAVOB2SQrPmWw5VD0kN7eyX/DEPTmpx6wc5bWPQ1KlpHnAamAm8N/AhojYmeyyAuiWLHcD3gdItm8EDqunzpGS5kqau2bNmnyGb2Zm9chr4oiIXRFxMtAd6Ascm4M6J0VEdURU5/LGJGZmlp2CjKqKiA3A74D+QAdJu5vIugMrk+WVQA+AZPuhwJ8LEZ+ZmWUvn6OqukjqkCwfAgwGFpJJIOclu10ITE+WZyTrJNt/6/4NM7PSk89RVV2BByVVkklQj0bEk5LeAR6RdAPwB+DeZP97gYclLQbWAcPzGJuZmR2gfI6qehPoU0/5EjL9HXuXbwO+lq94zMwsN3zluJmZpeLEYWZmqThxmJlZKk4cZmaWihOHmZml4sRhZmapOHGYmVkqThxmZpaKE4eZmaWSzylHzJqsXNwQyjeDsnLlxGF2AHJxQyjfDMrKlZuqzMwsFScOMzNLxYnDzMxSceIwM7NU8nkHwB6SfifpHUlvS7o8Kf+JpJWS5iWPs+scc42kxZLelXRmvmIzM7MDl89RVTuB70fEG5LaAa9LmplsmxgRE+ruLOk4Mnf9Ox44EviNpL+NiF15jNHMzFLK2xlHRKyKiDeS5c1k7jfebT+HDAUeiYjtEbEUWEw9dwo0M7PiSp04JHWU9JmUx1SRuY3snKRotKQ3Jd0nqWNS1g14v85hK6gn0UgaKWmupLlr1qxJG76ZmTVSVolD0ixJ7SV1At4A7pZ0c5bHtgUeA66IiE3AnUAv4GRgFfBvaQKOiEkRUR0R1V26dElzqJmZ5UC2ZxyHJh/6/wg8FBF/B3ypoYMkNSeTNCZHxK8AIuLDiNgVETXA3fy1OWol0KPO4d2TMjMzKyHZJo5mkroCXweezOYASQLuBRZGxM11yrvW2e0rwIJkeQYwXFJLSUcDvYHfZxmfmZkVSLajqsYCzwGzI+I1SX8DLGrgmAHAPwNvSZqXlF0LXCDpZCCA94CLASLibUmPAu+QGZE1yiOqzMxKT7aJY1VE1HaIR8SShvo4ImI2oHo2Pb2fY24EbswyJjMzK4Jsm6puy7LMzMyauP2ecUjqD3wO6CLpyjqb2gOV+QzMzMxKU0NNVS2Atsl+7eqUbwLOy1dQZmZWuvabOCLiBeAFSQ9ExLICxWRmZiUs287xlpImAVV1j4mI0/MRlJmZla5sE8d/AncB9wAeImtmdhDLNnHsjIg78xqJmZmVhWyH4z4h6VJJXSV12v3Ia2RmZlaSsj3juDB5vqpOWQB/k9twzMys1GWVOCLi6HwHYmZm5SHbadVbS/o/ycgqJPWWdE5+QzMzs1KUbR/H/cDHZK4ih8x05zfkJSIzMytp2SaOXhHxU2AHQERspf4JDM3MrInLtnP8Y0mHkOkQR1IvYHveojI7CGyLSkZcdnWj6zm8YzvGjb0uBxGZZSfbxPET4Fmgh6TJZO618a08xWR2UKge8u2c1LPgiXtyUo9ZtrIdVfVrSa8D/cg0UV0eEWvzGpmZmZWkbEdVPQGcAcyKiCezSRqSekj6naR3JL0t6fKkvJOkmZIWJc8dk3JJulXSYklvSjqlMb+YmZnlR7ad4xOAzwPvSJoq6TxJrRo4Zifw/Yg4jsyZyihJxwFjgOcjojfwfLIO8GUy9xnvDYwEPMWJmVkJyipxRMQLEXEpmSvFfwF8HVjdwDGrIuKNZHkzsBDoBgwFHkx2exAYliwPBR6KjFeBDpK6pvt1zMws37I94yAZVfVV4BLgs/z1wz+bY6uAPsAc4IiIWJVs+gA4IlnuBrxf57AVSdnedY2UNFfS3DVr1mQbgpmZ5Ui2fRyPkjljOB24ncx1Hd/N8ti2wGPAFRGxqe62iAiSIb7ZiohJEVEdEdVdunRJc6iZmeVAtsNx7wUuiIhU9+KQ1JxM0pgcEb9Kij+U1DUiViVNUbubvFYCPeoc3j0pMzOzErLfMw5JVwNExHPAP+617V8bOFZkEs7CiLi5zqYZ/HW23QuB6XXKv5mMruoHbKzTpGVmZiWioaaq4XWWr9lr21kNHDsA+GfgdEnzksfZwE3AYEmLgC8l6wBPA0uAxcDdwKVZxG9mZgXWUFOV9rFc3/oeImL2fvb5Yj37BzCqgXjMzKzIGjrjiH0s17duZmYHgYbOOE6StInMmcMhyTLJekMXAJqZWRO038QREZWFCsTMzMpD1hcAmpmZgROHmZml5MRhZmapOHGYmVkqThxmZpaKE4eZmaXixGFmZqk4cZiZWSpOHGZmlooTh5mZpeLEYWZmqThxmJlZKtneOjY1SfcB5wCrI+KEpOwnwP8C1iS7XRsRTyfbrgFGALuAy5K7DppZA7ZFJSMuu7rR9RzesR3jxl6Xg4isqctb4gAeAG4HHtqrfGJETKhbIOk4MncbPB44EviNpL9Ne4/zYrrmx9ezev3mRtezzRMSW0rVQ76dk3oWPHFPTuqxpi9viSMiXpRUleXuQ4FHImI7sFTSYqAv8Eq+4su11es3c8K53yl2GGYHLBdnLj5rOTjk84xjX0ZL+iYwF/h+RKwHugGv1tlnRVL2CZJGAiMBjjrqqDyHanbwyMWZi89aDg6F7hy/E+gFnAysAv4tbQURMSkiqiOiukuXLjkOz8zMGlLQxBERH0bEroioAe4m0xwFsBLoUWfX7kmZmZmVmIImDkld66x+BViQLM8AhktqKelooDfw+0LGZmZm2cnncNwpwCCgs6QVwI+BQZJOBgJ4D7gYICLelvQo8A6wExhVTiOqzMwOJvkcVXVBPcX37mf/G4Eb8xWPmZnlhq8cNzOzVJw4zMwsFScOMzNLxYnDzMxSceIwM7NUnDjMzCwVJw4zM0vFicPMzFJx4jAzs1ScOMzMLBUnDjMzS6UYN3IysybK9z8/ODhxmFnO+P7nBwc3VZmZWSpOHGZmlooTh5mZpZK3xCHpPkmrJS2oU9ZJ0kxJi5Lnjkm5JN0qabGkNyWdkq+4zMyscfJ5xvEAcNZeZWOA5yOiN/B8sg7wZTL3Ge8NjATuzGNcZmbWCHlLHBHxIrBur+KhwIPJ8oPAsDrlD0XGq0AHSV3zFZuZmR24QvdxHBERq5LlD4AjkuVuwPt19luRlH2CpJGS5kqau2bNmvxFamZm9SradRwREZLiAI6bBEwCqK6uTn28mZU+X0hY2gqdOD6U1DUiViVNUauT8pVAjzr7dU/KzOwg5AsJS1uhm6pmABcmyxcC0+uUfzMZXdUP2FinScvMzEpI3s44JE0BBgGdJa0AfgzcBDwqaQSwDPh6svvTwNnAYmArkJuvG2ZmlnN5SxwRccE+Nn2xnn0DGJWvWBpyzY+vZ/X6zY2qY1tU5igaM7PS5kkOgdXrN3PCud8pdhhmZmXBU46YmVkqThxmZpZKWTdVrfzTqpyM9Xb/hJlZ9so6cezYtct9E2ZmBeamKjMzS8WJw8zMUnHiMDOzVJw4zMwsFScOMzNLpaxHVZmZ7U+upmfPhaY0xbsTh5k1Wbmanj0XmtIU726qMjOzVJw4zMwsFScOMzNLpSh9HJLeAzYDu4CdEVEtqRPwS6AKeA/4ekSsL0Z8Zma2b8U84/hCRJwcEdXJ+hjg+YjoDTyfrJuZWYkppaaqocCDyfKDwLDihWJmZvtSrOG4AfxaUgC/iIhJwBERsSrZ/gFwRH0HShoJjARo0659IWI1M2u0XFxTUirXghQrcQyMiJWSDgdmSvqvuhsjIpKk8glJkpkE0PmI/1HvPmZmpSYX15SUyrUgRWmqioiVyfNq4HGgL/ChpK4AyfPqYsRmZmb7V/DEIamNpHa7l4EzgAXADODCZLcLgemFjs3MzBpWjKaqI4DHJe3++f8REc9Keg14VNIIYBnw9SLEZmZmDSh44oiIJcBJ9ZT/GfhioeMxM7N0Smk4rpmZlQHPjmtmViZyNk28Kro15nAnDjOzMpGzaeLvmNi8MYe7qcrMzFJx4jAzs1ScOMzMLBUnDjMzS8WJw8zMUnHiMDOzVDwct4l6efK/oa1rG1VHtO7MgG98P0cRmVlT4cSRI7n4oIbcfVhr61quPPPoRtVx83NLGx2HmTU9Thw5kosPaiitD+v2Fdv4f3df0+h6fOZi1rSUdeLY/pctTe6DLVcf1u0rtjW6ju8M/nSj6wC4Z+bCJvd3MjuYlXXiEDVN7lt+rj6sS0mufqdS+juZHczKOnHYwSUXZ2O5Omvx4AM7mDlxWNnIxZlLrprNDq3YxnfObFw8bsKzclVyiUPSWcAtQCVwT0TclO+fmYtvsrnoU7D8K6WmwFLrQyolToalTRFR7BhqSaoE/ggMBlYArwEXRMQ79e3fvm3reO6WSwsYoZkVwj0zF7KpplWxwwCaZhK78svH/zl27uh8oMeX2hlHX2BxcntZJD0CDAXqTRxm1jSV0plhUzyjq6SmdWOOL7XE0Q14v876CuDv6u4gaSQwMlmNQZfc/HGBYsvKrhoqKyvYVew49laKcTmm7Dim7JViXCUZ065o2ZjjSy1xNCgiJgGTACTN3b6jprrIIe1B0tydu6KkYoLSjMsxZccxZa8U4yrVmBpzfKlNcrgS6FFnvXtSZmZmJaLUEsdrQG9JR0tqAQwHZhQ5JjMzq6OkmqoiYqek0cBzZIbj3hcRb+/nkEmFiSyVUowJSjMux5Qdx5S9UoyrycVUUsNxzcys9JVaU5WZmZU4Jw4zM0ulbBKHpPskrZa0oE5ZJ0kzJS1KnjsWOKYekn4n6R1Jb0u6vNhxSWol6feS5icxjU3Kj5Y0R9JiSb9MBh8UlKRKSX+Q9GQpxCTpPUlvSZq3e3hisd9TSQwdJE2V9F+SFkrqX+T31KeS12j3Y5OkK4r9Wkn6XvIeXyBpSvLeL/Z76vIknrclXZGUFfx1SvN5qYxbk9fsTUmnNFR/2SQO4AHgrL3KxgDPR0Rv4PlkvZB2At+PiOOAfsAoSccVOa7twOkRcRJwMnCWpH7AeGBiRBwDrAdGFDCm3S4HFtZZL4WYvhARJ0fUjrMv9nsKMnO1PRsRxwInkXnNihZXRLybvEYnA6cCW4HHixmTpG7AZUB1RJxAZjDNcIr4npJ0AvC/yMyAcRJwjqRjKM7r9ADZf15+GeidPEYCdzZYe0SUzQOoAhbUWX8X6JosdwXeLXJ808nMs1UScQGtgTfIXH2/FmiWlPcHnitwLN2TN+vpwJOASiCm94DOe5UV9W8HHAosJRm4Uipx1YnjDODlYsfEX2eZ6ERmdOiTwJnFfE8BXwPurbN+HXB1sV6nbD8vgV+QmRPwE/vt61FOZxz1OSIiViXLHwBHFCsQSVVAH2BOseNKmoTmAauBmcB/AxsiYmeyywoy/3iF9HMy/0Q1yfphJRBTAL+W9LoyU9lA8d9TRwNrgPuTZr17JLUpgbh2Gw5MSZaLFlNErAQmAMuBVcBG4HWK+55aAHxe0mGSWgNnk7mguVT+dvuKo76pnvb7upV74qgVmVRZlLHFktoCjwFXRMSmYscVEbsi06zQncxp87GF/Pl7k3QOsDoiXi9mHPUYGBGnkDlVHyXptLobi/SeagacAtwZEX2Av7BX00ax3utJf8EQ4D/33lbomJL2+aFkEu2RQBs+2TRTUBGxkExT2a+BZ4F5sOccVcX8nMplHOWeOD6U1BUgeV5d6AAkNSeTNCZHxK9KJS6AiNgA/I7MKXsHSbsv+Cz0VC4DgCGS3gMeIdNcdUuRY9r9rZWIWE2mzb4vxf/brQBWRMScZH0qmURS7Lggk2DfiIgPk/VixvQlYGlErImIHcCvyLzPiv2eujciTo2I08j0sfyR0vjbsZ84Uk/1VO6JYwZwYbJ8IZk+hoKRJOBeYGFE3FwKcUnqIqlDsnwImT6XhWQSyHnFiCkiromI7hFRRaap47cR8Y1ixiSpjaR2u5fJtN0voMjvqYj4AHhf0qeSoi+Sua1AUeNKXMBfm6mguDEtB/pJap38H+5+nYr2ngKQdHjyfBTwj8B/UBp/O/YTxwzgm8noqn7AxjpNWvUrVMdRDjp6ppBpy9xB5lvZCDLt5M8Di4DfAJ0KHNNAMqd7b5I5LZ1Hpl2zaHEBnwH+kMS0APhRUv43wO+BxWSaGloW6e84CHiy2DElP3t+8ngb+N9JeVHfU0kMJwNzk7/hNKBjseMi0xT0Z+DQOmXFjmks8F/J+/xhoGWx3+fAS2QS2Hzgi8V6ndJ8XpIZqPJ/yfSFvkVmpNp+6/eUI2Zmlkq5N1WZmVmBOXGYmVkqThxmZpaKE4eZmaXixGFmZqk4cZiZWSpOHGZmlkpJ3XPcrFxJmkLmi9jRZCaPuzQinipuVGb54TMOs9w4CVgSEX2BbwA/LnI8ZnnjK8fNGklSKzLTUveIiG2SOpGZXv9fydwL5UzgOeAPEfGL4kVqlhtuqjJrvBOARRGxLVk/BZgfEfdLmg40j4hLiheeWW45cZg13knAUcmZRyWZyfeuTradSuYGQ2ZNhhOHWeOdROZ+EHOA5sC/RsTLybZTyUz1bdZkuI/DrJEkvQCMjIh369k2BbgoIj4qfGRm+eHEYdZIklYAR0VETYM7mzUBThxmZpaKr+MwM7NUnDjMzCwVJw4zM0vFicPMzFJx4jAzs1ScOMzMLBUnDjMzS+X/A2JbFRc0TuYpAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Now we can start to manipulate this single histogram to plot different views of the data\n",
    "# here we look at lepton pt for all eta\n",
    "lepton_pt = lepton_kinematics.integrate(\"eta\")\n",
    "\n",
    "ax = hist.plot1d(\n",
    "    lepton_pt,\n",
    "    overlay=\"flavor\",\n",
    "    stack=True,\n",
    "    fill_opts={'alpha': .5, 'edgecolor': (0,0,0,0.3)}\n",
    ")\n",
    "# all plot calls return the matplotlib axes object, from which\n",
    "# you can edit features afterwards using matplotlib object-oriented syntax\n",
    "# e.g. maybe you really miss '90s graphics...\n",
    "ax.get_legend().shadow = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Clearly the yields are much different, are the shapes similar? We can check by setting `density=True`\n",
    "lepton_pt.label = \"Density\"\n",
    "ax = hist.plot1d(lepton_pt, overlay=\"flavor\", density=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x1152 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's stack them, after defining some nice styling\n",
    "stack_fill_opts = {\n",
    "    'alpha': 0.8,\n",
    "    'edgecolor':(0,0,0,.5)\n",
    "}\n",
    "stack_error_opts = {\n",
    "    'label':'Stat. Unc.',\n",
    "    'hatch':'///',\n",
    "    'facecolor':'none',\n",
    "    'edgecolor':(0,0,0,.5),\n",
    "    'linewidth': 0\n",
    "}\n",
    "# maybe we want to compare different eta regions\n",
    "# plotgrid accepts row and column axes, and creates a grid of 1d plots as appropriate\n",
    "ax = hist.plotgrid(\n",
    "    lepton_kinematics,\n",
    "    row=\"eta\",\n",
    "    overlay=\"flavor\",\n",
    "    stack=True,\n",
    "    fill_opts=stack_fill_opts,\n",
    "    error_opts=stack_error_opts,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here we create some pseudodata for the pt histogram so we can make a nice data/mc plot\n",
    "pthist = lepton_kinematics.sum('eta')\n",
    "bin_values = pthist.axis('pt').centers()\n",
    "poisson_means = pthist.sum('flavor').values()[()]\n",
    "values = np.repeat(bin_values, np.random.poisson(poisson_means))\n",
    "pthist.fill(flavor='pseudodata', pt=values)\n",
    "\n",
    "# Set nicer labels, by accessing the string bins' label property\n",
    "pthist.axis('flavor').index('electron').label = 'e Flavor'\n",
    "pthist.axis('flavor').index('muon').label = r'$\\mu$ Flavor'\n",
    "pthist.axis('flavor').index('pseudodata').label = r'Pseudodata from e/$\\mu$'\n",
    "\n",
    "# using regular expressions on flavor name to select just the data\n",
    "# another method would be to fill a separate data histogram\n",
    "import re\n",
    "notdata = re.compile('(?!pseudodata)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# make a nice ratio plot, adjusting some font sizes\n",
    "plt.rcParams.update({\n",
    "    'font.size': 14,\n",
    "    'axes.titlesize': 18,\n",
    "    'axes.labelsize': 18,\n",
    "    'xtick.labelsize': 12,\n",
    "    'ytick.labelsize': 12\n",
    "})\n",
    "fig, (ax, rax) = plt.subplots(\n",
    "    nrows=2,\n",
    "    ncols=1,\n",
    "    figsize=(7,7),\n",
    "    gridspec_kw={\"height_ratios\": (3, 1)},\n",
    "    sharex=True\n",
    ")\n",
    "fig.subplots_adjust(hspace=.07)\n",
    "\n",
    "# Here is an example of setting up a color cycler to color the various fill patches\n",
    "# We get the colors from this useful utility: http://colorbrewer2.org/#type=qualitative&scheme=Paired&n=6\n",
    "from cycler import cycler\n",
    "colors = ['#a6cee3','#1f78b4','#b2df8a','#33a02c','#fb9a99','#e31a1c']\n",
    "ax.set_prop_cycle(cycler(color=colors))\n",
    "\n",
    "fill_opts = {\n",
    "    'edgecolor': (0,0,0,0.3),\n",
    "    'alpha': 0.8\n",
    "}\n",
    "error_opts = {\n",
    "    'label': 'Stat. Unc.',\n",
    "    'hatch': '///',\n",
    "    'facecolor': 'none',\n",
    "    'edgecolor': (0,0,0,.5),\n",
    "    'linewidth': 0\n",
    "}\n",
    "data_err_opts = {\n",
    "    'linestyle': 'none',\n",
    "    'marker': '.',\n",
    "    'markersize': 10.,\n",
    "    'color': 'k',\n",
    "    'elinewidth': 1,\n",
    "}\n",
    "\n",
    "# plot the MC first\n",
    "hist.plot1d(\n",
    "    pthist[notdata], \n",
    "    overlay=\"flavor\", \n",
    "    ax=ax,\n",
    "    clear=False,\n",
    "    stack=True, \n",
    "    line_opts=None,\n",
    "    fill_opts=fill_opts,\n",
    "    error_opts=error_opts\n",
    ")\n",
    "# now the pseudodata, setting clear=False to avoid overwriting the previous plot\n",
    "hist.plot1d(\n",
    "    pthist['pseudodata'],\n",
    "    overlay=\"flavor\",\n",
    "    ax=ax,\n",
    "    clear=False,\n",
    "    error_opts=data_err_opts\n",
    ")\n",
    "\n",
    "ax.autoscale(axis='x', tight=True)\n",
    "ax.set_ylim(0, None)\n",
    "ax.set_xlabel(None)\n",
    "leg = ax.legend()\n",
    "\n",
    "# now we build the ratio plot\n",
    "hist.plotratio(\n",
    "    num=pthist['pseudodata'].sum(\"flavor\"),\n",
    "    denom=pthist[notdata].sum(\"flavor\"), \n",
    "    ax=rax,\n",
    "    error_opts=data_err_opts, \n",
    "    denom_fill_opts={},\n",
    "    guide_opts={},\n",
    "    unc='num'\n",
    ")\n",
    "rax.set_ylabel('Ratio')\n",
    "rax.set_ylim(0,2)\n",
    "\n",
    "# add some labels\n",
    "coffee = plt.text(0., 1., u\"☕\",\n",
    "                  fontsize=28, \n",
    "                  horizontalalignment='left', \n",
    "                  verticalalignment='bottom', \n",
    "                  transform=ax.transAxes\n",
    "                 )\n",
    "lumi = plt.text(1., 1., r\"1 fb$^{-1}$ (?? TeV)\",\n",
    "                fontsize=16, \n",
    "                horizontalalignment='right', \n",
    "                verticalalignment='bottom', \n",
    "                transform=ax.transAxes\n",
    "               )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some further styling tools are available through the `mplhep` package. In particular, there are several stylesheets that update `plt.rcParams` to conform with experiment style recommendations regarding font face, font sizes, tick mark styles, and other such things. Below is an example application."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import mplhep\n",
    "plt.style.use(mplhep.style.ROOT)\n",
    "\n",
    "# Compare this to the style of the plot drawn previously\n",
    "ax = hist.plot1d(lepton_pt, overlay=\"flavor\", density=True)"
   ]
  }
 ],
 "metadata": {
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}