{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Coffea Histograms\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([ 26,  38,  80,  90, 129, 130, 155, 131, 140,  81]), array([0.01914583, 0.11693371, 0.21472158, 0.31250945, 0.41029732,\n",
      "       0.50808519, 0.60587306, 0.70366094, 0.80144881, 0.89923668,\n",
      "       0.99702455]))\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,  4, 12, 18, 10, 18, 10, 18, 20, 24, 28, 24, 38, 42, 48, 40,\n",
      "       30, 40, 34, 48, 38, 48, 64, 62, 54, 56, 50, 60, 68, 60, 62, 76, 60,\n",
      "       62, 54, 54, 50, 54, 54, 56, 58, 52, 62, 62, 34, 20, 40, 16]), 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": [
      "[ 1.  5.  9. 10. 13. 15. 17. 11. 18. 19. 24. 28. 28. 38. 40. 41. 31. 30.\n",
      " 39. 34. 38. 49. 49. 57. 48. 61. 62. 61. 52. 68. 65. 52. 70. 55. 64. 57.\n",
      " 65. 46. 57. 58. 55. 60. 58. 59. 50. 44. 32. 39. 18.]\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 0x124bb33d0>\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 0x12aa49350>"
      ]
     },
     "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 0x124bb3410>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[<Interval ((-inf, 4)) instance at 0x12aa65650>,\n",
       " <Interval ([4, 5)) instance at 0x12aa658d0>,\n",
       " <Interval ([5, 6)) instance at 0x12aa65910>,\n",
       " <Interval ([6, 7)) instance at 0x12aa65950>,\n",
       " <Interval ([7, 8)) instance at 0x12aa65990>,\n",
       " <Interval ([8, 9)) instance at 0x12aa65a10>,\n",
       " <Interval ([9, 10)) instance at 0x12aa65a50>,\n",
       " <Interval ([10, inf)) instance at 0x12aa65a90>]"
      ]
     },
     "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 0x12aa49ad0>"
      ]
     },
     "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 0x124b8c090>"
      ]
     },
     "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 0x12aaabd50>"
      ]
     },
     "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 0x124bb3610>,\n",
       " <StringBin (sample 2) instance at 0x12aa2b090>]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[<Interval ([-10, -9)) instance at 0x12aab4850>,\n",
       " <Interval ([-9, -8)) instance at 0x12aab4890>,\n",
       " <Interval ([-8, -7)) instance at 0x12aab48d0>,\n",
       " <Interval ([-7, -6)) instance at 0x12aab4950>,\n",
       " <Interval ([-6, -5)) instance at 0x12aab49d0>,\n",
       " <Interval ([-5, -4)) instance at 0x12aab4a10>,\n",
       " <Interval ([-4, -3)) instance at 0x12aab4910>,\n",
       " <Interval ([-3, -2)) instance at 0x12aab4a90>,\n",
       " <Interval ([-2, -1)) instance at 0x12aab4990>,\n",
       " <Interval ([-1, 0)) instance at 0x12aab4ad0>,\n",
       " <Interval ([0, 1)) instance at 0x12aab4b10>,\n",
       " <Interval ([1, 2)) instance at 0x12aab4b50>,\n",
       " <Interval ([2, 3)) instance at 0x12aab4b90>,\n",
       " <Interval ([3, 4)) instance at 0x12aab4bd0>,\n",
       " <Interval ([4, 5)) instance at 0x12aab4c10>,\n",
       " <Interval ([5, 6)) instance at 0x12aab4c50>,\n",
       " <Interval ([6, 7)) instance at 0x12aab4c90>,\n",
       " <Interval ([7, 8)) instance at 0x12aab4cd0>,\n",
       " <Interval ([8, 9)) instance at 0x12aab4d10>,\n",
       " <Interval ([9, 10)) instance at 0x12aab4d50>]"
      ]
     },
     "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, 6.12000e+01, 7.38000e+02,\n",
       "        4.78080e+03, 1.21896e+04, 1.25676e+04, 4.85640e+03, 7.81200e+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",
       "        1.64347162e+00, 6.62728465e+00, 1.83584033e+02, 1.18763061e+03,\n",
       "        2.89423034e+03, 2.96761253e+03, 1.20685741e+03, 1.92266759e+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": [],
   "source": [
    "# data can be exported to ROOT via uproot, but only 1D\n",
    "import uproot\n",
    "import os\n",
    "\n",
    "if os.path.exists(\"output.root\"):\n",
    "    os.remove(\"output.root\")\n",
    "\n",
    "outputfile = uproot.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": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAPwUlEQVR4nO3df6zdd13H8efL1YFDYINeltlu3qEFrahhuZkjJIiU4NjIukSybBEp2NgAE1FIoEDijIZkRAUhwWFlc8Xg2JzoGgfqHFsWCR12bOwnP+rYj9ZuvTg2f6BA9e0f5wu5ubvdPfd87zmn/fT5SG7u9/v5/np/em5f/dzP95xvU1VIktryA9MuQJK0+gx3SWqQ4S5JDTLcJalBhrskNWjNtAsAWLt2bc3Ozk67DEk6qtx2223fqKqZpbYdEeE+OzvLnj17pl2GJB1Vkjx4uG1Oy0hSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoOOiE+oSjpyzG6/fmrXfuDSc6d27dY4cpekBhnuktQgw12SGmS4S1KDvKEqLWNaNxi9uag+HLlLUoMMd0lqkOEuSQ1aNtyTXJHkYJK7l9j2jiSVZG23niQfTrI3yZ1JzhhH0ZKkpzbMyP1K4OzFjUlOBV4FPLSg+dXAhu5rG3BZ/xIlSSu1bLhX1S3AY0ts+iDwTqAWtG0GPl4Du4ETk5yyKpVKkoY20lshk2wG9lfVl5Is3LQOeHjB+r6u7cAS59jGYHTPaaedNkoZUtOm+YwXHf1WfEM1yQnAe4Df7nPhqtpRVXNVNTczM9PnVJKkRUYZuf8YcDrwvVH7euCLSc4E9gOnLth3fdcmSZqgFY/cq+quqnpeVc1W1SyDqZczquoRYBfw+u5dM2cBT1TVk6ZkJEnjNcxbIa8CPg+8MMm+JFufYvdPA/cDe4E/Bd6yKlVKklZk2WmZqrpome2zC5YLuLh/WZKkPvyEqiQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGjfQ8d0kah2k9w/6BS8+dynXHyZG7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUHD/AfZVyQ5mOTuBW2/n+TLSe5M8tdJTlyw7d1J9ib5SpJfHFfhkqTDG2bkfiVw9qK2G4AXVdXPAF8F3g2QZCNwIfBT3TF/nOS4VatWkjSUZcO9qm4BHlvU9g9Vdahb3Q2s75Y3A5+sqm9X1deBvcCZq1ivJGkIqzHn/qvAZ7rldcDDC7bt69qeJMm2JHuS7Jmfn1+FMiRJ39Mr3JO8FzgEfGKlx1bVjqqaq6q5mZmZPmVIkhYZ+amQSd4AvAbYVFXVNe8HTl2w2/quTZI0QSON3JOcDbwTOK+qvrVg0y7gwiRPS3I6sAH4Qv8yJUkrsezIPclVwMuBtUn2AZcweHfM04AbkgDsrqo3VdU9Sa4B7mUwXXNxVf3vuIqXJC1t2XCvqouWaL78KfZ/H/C+PkVJkvrxE6qS1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJatDIz3OXJml2+/XTLkE6qjhyl6QGGe6S1CDDXZIa5Jy7VsS5b+no4MhdkhpkuEtSg5YN9yRXJDmY5O4Fbc9JckOSr3XfT+rak+TDSfYmuTPJGeMsXpK0tGFG7lcCZy9q2w7cWFUbgBu7dYBXAxu6r23AZatTpiRpJZYN96q6BXhsUfNmYGe3vBM4f0H7x2tgN3BiklNWq1hJ0nBGnXM/uaoOdMuPACd3y+uAhxfst69re5Ik25LsSbJnfn5+xDIkSUvpfUO1qgqoEY7bUVVzVTU3MzPTtwxJ0gKjhvuj35tu6b4f7Nr3A6cu2G991yZJmqBRw30XsKVb3gJct6D99d27Zs4CnlgwfSNJmpBlP6Ga5Crg5cDaJPuAS4BLgWuSbAUeBC7odv80cA6wF/gW8MYx1CxJWsay4V5VFx1m06Yl9i3g4r5FSZL68ROqktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNWjZ57lLUutmt18/tWs/cOm5YzmvI3dJapDhLkkN6hXuSX4ryT1J7k5yVZKnJzk9ya1J9ia5Osnxq1WsJGk4I8+5J1kH/Aawsar+O8k1wIUM/oPsD1bVJ5N8FNgKXLYq1QqY7vygpKND32mZNcAPJVkDnAAcAF4BXNtt3wmc3/MakqQVGjncq2o/8AfAQwxC/QngNuDxqjrU7bYPWNe3SEnSyowc7klOAjYDpwM/AjwDOHsFx29LsifJnvn5+VHLkCQtoc+0zCuBr1fVfFV9F/gU8FLgxG6aBmA9sH+pg6tqR1XNVdXczMxMjzIkSYv1CfeHgLOSnJAkwCbgXuAm4LXdPluA6/qVKElaqT5z7rcyuHH6ReCu7lw7gHcBb0+yF3gucPkq1ClJWoFejx+oqkuASxY13w+c2ee8kqR+/ISqJDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1KBe4Z7kxCTXJvlykvuSvCTJc5LckORr3feTVqtYSdJw+o7cPwT8XVX9BPCzwH3AduDGqtoA3NitS5ImaORwT/Js4GXA5QBV9Z2qehzYDOzsdtsJnN+3SEnSyvQZuZ8OzAN/luT2JB9L8gzg5Ko60O3zCHDyUgcn2ZZkT5I98/PzPcqQJC3WJ9zXAGcAl1XVi4H/YtEUTFUVUEsdXFU7qmququZmZmZ6lCFJWqxPuO8D9lXVrd36tQzC/tEkpwB03w/2K1GStFIjh3tVPQI8nOSFXdMm4F5gF7Cla9sCXNerQknSiq3pefxbgU8kOR64H3gjg38wrkmyFXgQuKDnNSRJK9Qr3KvqDmBuiU2b+pxXktSPn1CVpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGtQ73JMcl+T2JH/brZ+e5NYke5Nc3f3n2ZKkCVqNkfvbgPsWrL8f+GBV/TjwTWDrKlxDkrQCvcI9yXrgXOBj3XqAVwDXdrvsBM7vcw1J0sqt6Xn8HwHvBJ7ZrT8XeLyqDnXr+4B1Sx2YZBuwDeC0007rWcZ0zG6/ftolSNKSRh65J3kNcLCqbhvl+KraUVVzVTU3MzMzahmSpCX0Gbm/FDgvyTnA04FnAR8CTkyyphu9rwf29y9TkrQSI4/cq+rdVbW+qmaBC4HPVtUvAzcBr+122wJc17tKSdKKjON97u8C3p5kL4M5+MvHcA1J0lPoe0MVgKq6Gbi5W74fOHM1zitJGo2fUJWkBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaNHK4Jzk1yU1J7k1yT5K3de3PSXJDkq91309avXIlScPoM3I/BLyjqjYCZwEXJ9kIbAdurKoNwI3duiRpgkYO96o6UFVf7Jb/A7gPWAdsBnZ2u+0Ezu9bpCRpZVZlzj3JLPBi4Fbg5Ko60G16BDj5MMdsS7InyZ75+fnVKEOS1FnT9wRJfhj4K+A3q+rfk3x/W1VVklrquKraAewAmJubW3KfYcxuv37UQyWpWb1G7kl+kEGwf6KqPtU1P5rklG77KcDBfiVKklaqz7tlAlwO3FdVH1iwaRewpVveAlw3enmSpFH0mZZ5KfArwF1J7uja3gNcClyTZCvwIHBBvxIlSSs1crhX1T8BOczmTaOeV5LUn59QlaQGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkho0tnBPcnaSryTZm2T7uK4jSXqysYR7kuOAjwCvBjYCFyXZOI5rSZKebFwj9zOBvVV1f1V9B/gksHlM15IkLbJmTOddBzy8YH0f8HMLd0iyDdjWrf5nkq88xfnWAt9Y1QqPDsdqv+HY7fux2m84Rvue9/fq948ebsO4wn1ZVbUD2DHMvkn2VNXcmEs64hyr/YZjt+/Har/h2O37uPo9rmmZ/cCpC9bXd22SpAkYV7j/M7AhyelJjgcuBHaN6VqSpEXGMi1TVYeS/Drw98BxwBVVdU+PUw41fdOgY7XfcOz2/VjtNxy7fR9Lv1NV4zivJGmK/ISqJDXIcJekBh1R4b7cIwuSPC3J1d32W5PMTr7K1TdEv9+e5N4kdya5Mclh39t6tBn2MRVJfilJJWnirXLD9DvJBd3rfk+Sv5h0jeMyxM/7aUluSnJ79zN/zjTqXG1JrkhyMMndh9meJB/u/lzuTHJGrwtW1RHxxeDG678AzweOB74EbFy0z1uAj3bLFwJXT7vuCfX7F4ATuuU3t9DvYfve7fdM4BZgNzA37bon9JpvAG4HTurWnzftuifY9x3Am7vljcAD0657lfr+MuAM4O7DbD8H+AwQ4Czg1j7XO5JG7sM8smAzsLNbvhbYlCQTrHEclu13Vd1UVd/qVncz+NxAC4Z9TMXvAe8H/meSxY3RMP3+NeAjVfVNgKo6OOEax2WYvhfwrG752cC/TrC+samqW4DHnmKXzcDHa2A3cGKSU0a93pEU7ks9smDd4fapqkPAE8BzJ1Ld+AzT74W2MvjXvQXL9r371fTUqrp+koWN2TCv+QuAFyT5XJLdSc6eWHXjNUzffwd4XZJ9wKeBt06mtKlbaRY8pak9fkArl+R1wBzw89OuZRKS/ADwAeANUy5lGtYwmJp5OYPf1G5J8tNV9fhUq5qMi4Arq+oPk7wE+PMkL6qq/5t2YUeTI2nkPswjC76/T5I1DH5l+7eJVDc+Qz2qIckrgfcC51XVtydU27gt1/dnAi8Cbk7yAIN5yF0N3FQd5jXfB+yqqu9W1deBrzII+6PdMH3fClwDUFWfB57O4KFirVvVx7YcSeE+zCMLdgFbuuXXAp+t7k7EUWzZfid5MfAnDIK9lblXWKbvVfVEVa2tqtmqmmVwv+G8qtoznXJXzTA/63/DYNROkrUMpmnun2SRYzJM3x8CNgEk+UkG4T4/0SqnYxfw+u5dM2cBT1TVgZHPNu07yEvcLf4qg7vp7+3afpfBX2gYvMh/CewFvgA8f9o1T6jf/wg8CtzRfe2ads2T6vuifW+mgXfLDPmah8GU1L3AXcCF0655gn3fCHyOwTtp7gBeNe2aV6nfVwEHgO8y+M1sK/Am4E0LXvOPdH8ud/X9WffxA5LUoCNpWkaStEoMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktSg/wcZak2Cc7zZPAAAAABJRU5ErkJggg==\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": "iVBORw0KGgoAAAANSUhEUgAAAZwAAAEGCAYAAABRvCMcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3de5hU1Znv8e+Pu/EGCkEUDGBAQVQGGtSokTMo4iWSeItER0aNxBCcZHJGxdET0eiMExPNmGPwmIRB86h4H1GJ3ETjjUhLEBBQUWFsREC8xQsk6Hv+qNVYNt1NNV21q7v9fZ6nnt577bXXfmt30S9771VrKSIwMzMrtVblDsDMzL4YnHDMzCwTTjhmZpYJJxwzM8uEE46ZmWWiTbkDyFrnzp2jZ8+e5Q7DzKxZee65596KiC6NaeMLl3B69uxJZWVlucMwM2tWJK1qbBu+pWZmZplwwjEzs0w44ZiZWSa+cM9wzKzl+tvf/kZVVRUbN24sdyjNVocOHejevTtt27YtettOOGbWYlRVVbHzzjvTs2dPJJU7nGYnItiwYQNVVVX06tWr6O37lpqZtRgbN25k9913d7LZTpLYfffdS3aF6IRjZi2Kk03jlPL8OeGYmVkmnHDMzEpg2LBh/pJ5DSVLOJImS1onaUle2Z2SFqbXSkkLU3lPSR/nbbspb5/BkhZLWiHpBqXrPUm7SZol6eX0s1Op3ouZmTVeKa9wpgAj8wsi4tsRMTAiBgL3AvflbX6leltEnJ9XPgk4D+iTXtVtTgDmREQfYE5aNzOr1Ycffsjxxx/PQQcdxIABA7jzzjsBuPLKKxkyZAgDBgxg7NixVM+CPGzYMP75n/+ZiooK+vXrx/z58znppJPo06cPl112GQArV65kv/3244wzzqBfv36ccsopfPTRR1sde+bMmRx66KEMGjSIU089lQ8++GCrOsOGDePiiy9m6NCh9O3blyeeeGLLMY444ggGDRrEoEGDePrppwF47LHHOPLIIxk1ahS9e/dmwoQJ3HbbbQwdOpQDDjiAV155BYD169dz8sknM2TIEIYMGcJTTz1V/JNbqIgo2QvoCSyppVzA60CfbdTrBizPWx8N/L+0/CLQLa/ei4XENHjw4DCzlmnp0qV1brvnnnviu9/97pb1d999NyIiNmzYsKXszDPPjGnTpkVExJFHHhkXXXRRRET88pe/jG7dusUbb7wRGzdujL322iveeuuteO211wKIJ598MiIizj777Lj22mu37D9//vxYv359HHHEEfHBBx9ERMQ111wTV1xxxVbxHXnkkfHjH/84IiIefvjhGD58eEREfPjhh/Hxxx9HRMRLL70U1X/D5s6dG7vuuuuWmPbcc8/4yU9+siXeH/7whxERMXr06HjiiSciImLVqlWx3377bdd5BCqjkTmhXM9wjgDWRsTLeWW9JP1Z0uOSjkhlewFVeXWqUhlA14hYk5bfBLrWdTBJYyVVSqpcv359kd6CmTUnBxxwALNmzeLiiy/miSeeYNdddwVg7ty5HHzwwRxwwAE8+uijvPDCC1v2OfHEE7fsu//++9OtWzfat29P7969ef311wHo0aMHhx12GABnnnkmTz755OeOO2/ePJYuXcphhx3GwIEDueWWW1i1qvZxME866SQABg8ezMqVK4Hcl1nPO+88DjjgAE499VSWLl26pf6QIUO2xLTPPvswYsSILfFW7z979mzGjx/PwIEDOfHEE3n//fdrvcLKQrm++DkauCNvfQ2wd0RskDQY+G9J+xfaWESEpKhn+83AzQAVFRV11jOzlqtv374sWLCA6dOnc9lllzF8+HAuuugixo0bR2VlJT169GDixImf+w5K+/btAWjVqtWW5er1zZs3A1t3I665HhEcffTR3HHHHWxL9TFat269pf3rr7+erl278vzzz/Ppp5/SoUOHrerXjDE/vk8//ZR58+Z9br9yyfwKR1Ib4CTgzuqyiNgUERvS8nPAK0BfYDXQPW/37qkMYK2kbqnNbsC60kdvZs3VG2+8wZe+9CXOPPNMLrzwQhYsWLAluXTu3JkPPviAe+65p8Ht/s///A/PPPMMALfffjuHH37457YfcsghPPXUU6xYsQLIPUt66aWXCm7/vffeo1u3brRq1Yrf//73fPLJJw2Kb8SIEfzqV7/asr5w4cIG7V9M5bildhS55zJbbpVJ6iKpdVruTa5zwKvpltn7kg5JvdPOAh5Iu00DxqTlMXnlZmZbWbx4MUOHDmXgwIFcccUVXHbZZXTs2JHzzjuPAQMGcMwxxzBkyJAGt7vvvvty44030q9fP9555x2+//3vf257ly5dmDJlCqNHj+bAAw/k0EMPZfny5QW3P27cOG655RYOOuggli9fzo477tig+G644QYqKys58MAD6d+/PzfddNO2dyoRRZTmDpOkO4BhQGdgLXB5RPxO0hRgXkTkd30+GbgS+Bvwaar7YNpWQa7H2w7AH4AL0i203YG7gL2BVcBpEfH2tuKqqKgI9403a5mWLVtGv379MjveypUrOeGEE1iyZMm2KzcjtZ1HSc9FREVj2i3ZM5yIGF1H+T/WUnYvuW7StdWvBAbUUr4BGN64KM3MLCseacDMbDv17NmzxV3dlJITjpmZZcIJx8zMMuGEY2ZmmXDCMTOzTHiKaTNrsXpOeLio7a285viittdYw4YN4+c//zkVFYX1Vr7wwgt58MEHadeuHfvssw//9V//RceOHUsc5Wd8hWNm9gVx9NFHs2TJEhYtWkTfvn3593//90yP74RjZlYkTX0KhBEjRtCmTe7G1iGHHEJVVdVWdUrJCcfMrEgeeeQR9txzT55//nmWLFnCyJG56bvGjx/P/PnzWbJkCR9//DEPPfTQln3atWtHZWUl559/PqNGjeLGG29kyZIlTJkyhQ0bNgDw4osvMm7cOJYtW8Yuu+zCr3/9688d96233uKqq65i9uzZLFiwgIqKCq677rp6Y508eTLHHntskc9A/ZxwzMyKpDlMgQBw9dVX06ZNG84444yivv9tcacBM7MiaQ5TIEyZMoWHHnqIOXPmbNVOqfkKx8ysSJr6FAiPPPIIP/vZz5g2bRpf+tKXGhxHY/kKx8xarKy7MS9evJgLL7yQVq1a0bZtWyZNmvS5KRD22GOPRk2BcM4559C/f/96p0DYtGkTAFdddRV9+/b9XL3x48ezadMmjj76aCCXqLKcrqBk0xM0VZ6ewKzlynp6giyUYwqEUk1P4FtqZmaWCSccM7MmrCVNgeCEY2ZmmXCnATOzEllU9W6j2ziwe3ZjnZWar3DMzCwTTjhmZpaJkt1SkzQZOAFYFxEDUtlE4Dxgfar2rxExPW27BDgX+AT4p4iYkcpHAv8JtAZ+GxHXpPJewFRgd+A54B8i4q+lej9m1gxN3LXI7b1X3PYaqaHTE9x9991MnDiRZcuW8eyzzxa8X7GU8gpnCjCylvLrI2JgelUnm/7A6cD+aZ9fS2otqTVwI3As0B8YneoC/Edq66vAO+SSlZmZ1WHAgAHcd999fP3rXy/L8Ut2hRMRf5TUs8Dqo4CpEbEJeE3SCmBo2rYiIl4FkDQVGCVpGfD3wHdSnVuAicCk4kRvZra1bXUC+OijD7no+2ezds0bfPLJJ4z94YWMPPEkbvrlz/jjrEfYuPFjBlYczP+55nokce6pJ7Df/gey4Nln+Pjjj7jq+kn87sbrWbF8Kcd841uMv+gyVq5cyciRIxk8eDALFixg//3359Zbb91qaJqZM2dy+eWXs2nTpi2Tq+20006fq1PuL8WW4xnOeEmLJE2W1CmV7QW8nlenKpXVVb478G5EbK5RXitJYyVVSqpcv359XdXMzBrl6cfm0KVrN+6e+ST3zXmGw4YNB2D0mPO4/eFHuW/OM2zc+DGPz35kyz5t2rXljulzOfXMs/nRuWfwr1ddy72zn+aBu+/g3XfeBkozPUE5ZJ1wJgH7AAOBNcAvsjhoRNwcERURUdGlS5csDmlmX0Bf3a8/856Yy/X/djkL/vQ0O++Se4Y0/5knOOMbR3HyUV/j2aee4JWXlm/ZZ9jRx27Zd59996NL1z1o17493ff+Cm++sRoo/vQE5ZLp93AiYm31sqTfANWzEK0GeuRV7Z7KqKN8A9BRUpt0lZNf38ysLHr2/ipTpz/OE3Nn8n+vvZqhhx/J2ef/E1df+i/c8fCj7LFndyZddw1/TQNsArRr99n0BG3btdtS3qpVKz4pwfQE5ZTpFY6kbnmr3wKqx2uYBpwuqX3qfdYHeBaYD/SR1EtSO3IdC6ZFbsTRucApaf8xwANZvAczs7qse3MNHXbYgRNO+jZjzr+A5Yuf3zJ6c8dOu/PRhx8w6+GG/6kq1vQE5VbKbtF3AMOAzpKqgMuBYZIGAgGsBL4HEBEvSLoLWApsBn4QEZ+kdsYDM8h1i54cEdVT5V0MTJV0FfBn4Helei9m1kw1shtzQ0cKeHn5Uq6/+ie0atWKNm3acum//YJddt2Vk0efxclHfY3OX/4y+x80qMFxFGt6gvvvv58LLriA9evXc/zxxzNw4EBmzJjR4Hi2l6cnMLMWo9jTExRjaJrG2mXzu56ewMzMrCGccMzMmjBPT2Bm1kR90R4TFFspz58Tjpm1GB06dGDDhg1OOtspItiwYQMdOnQoSfueD8fMWozu3btTVVVFsUYUWfvOx0VppzGW/WWHTI/XoUMHunfvXpK2nXDMrMVo27YtvXr1Klp7x054uGhtba+V1xxf7hCKxrfUzMwsE044ZmaWCSccMzPLhBOOmZllwgnHzMwy4YRjZmaZcMIxM7NMOOGYmVkmnHDMzCwTTjhmZpYJJxwzM8uEE46ZmWXCCcfMzDLhhGNmZpkoWcKRNFnSOklL8squlbRc0iJJ90vqmMp7SvpY0sL0uilvn8GSFktaIekGSUrlu0maJenl9LNTqd6LmZk1XimvcKYAI2uUzQIGRMSBwEvAJXnbXomIgel1fl75JOA8oE96Vbc5AZgTEX2AOWndzMyaqJJNwBYRf5TUs0bZzLzVecAp9bUhqRuwS0TMS+u3At8E/gCMAoalqrcAjwEXNz5yM7PiWNnhO0Vo5b0itNE0lPMZzjnkEke1XpL+LOlxSUeksr2Aqrw6VakMoGtErEnLbwJd6zqQpLGSKiVVFmvqWTMza5iyJBxJlwKbgdtS0Rpg74j4O+DHwO2Sdim0vYgIIOrZfnNEVERERZcuXRoRuZmZba+S3VKri6R/BE4AhqdEQURsAjal5eckvQL0BVYD3fN2757KANZK6hYRa9Ktt3UZvQUzM9sOmV7hSBoJXAScGBEf5ZV3kdQ6Lfcm1zng1XTL7H1Jh6TeaWcBD6TdpgFj0vKYvHIzM2uCSnaFI+kOcg/1O0uqAi4n1yutPTAr9W6el3qkfR24UtLfgE+B8yPi7dTUOHI93nYg98yn+rnPNcBdks4FVgGnleq9mNkXU3Ee+lu1UvZSG11L8e/qqHsvcG8d2yqBAbWUbwCGNyZGMzPLjkcaMDOzTDjhmJlZJpxwzMwsE044ZmaWCSccMzPLhBOOmZllwgnHzMwy4YRjZmaZcMIxM7NMOOGYmVkmnHDMzCwTTjhmZpYJJxwzM8uEE46ZmWXCCcfMzDLhhGNmZplocMKR1EnSgaUIxszMWq6CEo6kxyTtImk3YAHwG0nXlTY0MzNrSQq9wtk1It4HTgJujYiDgaNKF5aZmbU0hSacNpK6AacBD5UwHjMza6EKTThXADOAFRExX1Jv4OVt7SRpsqR1kpbkle0maZakl9PPTqlckm6QtELSIkmD8vYZk+q/LGlMXvlgSYvTPjdIUqFv3MzMslVowlkTEQdGxDiAiHgVKOQZzhRgZI2yCcCciOgDzEnrAMcCfdJrLDAJcgkKuBw4GBgKXF6dpFKd8/L2q3ksMzNrIgpNOL8qsOxzIuKPwNs1ikcBt6TlW4Bv5pXfGjnzgI7pNt4xwKyIeDsi3gFmASPTtl0iYl5EBHBrXltmZtbEtKlvo6RDga8BXST9OG/TLkDr7Txm14hYk5bfBLqm5b2A1/PqVaWy+sqrainfiqSx5K6a2HvvvbczbDMza4xtXeG0A3Yil5h2znu9D5zS2IOnK5NobDsFHOfmiKiIiIouXbqU+nBmZlaLeq9wIuJx4HFJUyJiVZGOuVZSt4hYk26LrUvlq4EeefW6p7LVwLAa5Y+l8u611Dczsyao0Gc47SXdLGmmpEerX9t5zGlAdU+zMcADeeVnpd5qhwDvpVtvM4ARaYSDTsAIYEba9r6kQ1LvtLPy2jIzsyam3iucPHcDNwG/BT4ptHFJd5C7OuksqYpcb7NrgLsknQusIvfdHoDpwHHACuAj4GyAiHhb0k+B+anelRFR3RFhHLmecDsAf0gvMzNrggpNOJsjYlJDG4+I0XVsGl5L3QB+UEc7k4HJtZRXAgMaGpeZmWWv0FtqD0oaJ6lb+uLmbun7MWZmZgUp9Aqn+pnLhXllAfQubjhmZtZSFZRwIqJXqQMxM7OWraCEI+ms2soj4tbihmNmZi1VobfUhuQtdyD30H8BueFkzMzMtqnQW2oX5K9L6ghMLUlEZmbWIjV4iunkQ8DPdczMrGCFPsN5kM/GPGsN9APuKlVQZmbW8hT6DOfnecubgVURUVVXZTMzs5oKuqWWBvFcTm6k6E7AX0sZlJmZtTwFJRxJpwHPAqeSG/vsT5IaPT2BmZl9cRR6S+1SYEhErAOQ1AWYDdxTqsDMzKxlKbSXWqvqZJNsaMC+ZmZmBV/hPCJpBnBHWv82uekEzMzMClJvwpH0VaBrRFwo6STg8LTpGeC2UgdnZmYtx7aucH4JXAIQEfcB9wFIOiBt+0ZJozMzsxZjW89hukbE4pqFqaxnSSIyM7MWaVsJp2M923YoZiBmZtaybSvhVEo6r2ahpO8Cz5UmJDMza4m29QznR8D9ks7gswRTAbQDvlXKwMzMrGWp9wonItZGxNeAK4CV6XVFRBwaEW9uzwEl7StpYd7rfUk/kjRR0uq88uPy9rlE0gpJL0o6Jq98ZCpbIWnC9sRjZmbZKHQ+nLnA3GIcMCJeBAYCSGoNrAbuB84Gro+I/IFCkdQfOB3YH9gTmC2pb9p8I3A0UAXMlzQtIpYWI04zMyuuQr/4WSrDgVciYpWkuuqMAqZGxCbgNUkrgKFp24qIeBVA0tRU1wnHzKwJKvfwNKfz2egFAOMlLZI0WVKnVLYX8HpenapUVlf5ViSNlVQpqXL9+vXFi97MzApWtoQjqR1wInB3KpoE7EPudtsa4BfFOlZE3BwRFRFR0aVLl2I1a2ZmDVDOW2rHAgsiYi3kOihUb5D0G+ChtLoa6JG3X/dURj3lZmbWxJTzltpo8m6nSeqWt+1bwJK0PA04XVJ7Sb2APuTm5pkP9JHUK10tnZ7qmplZE1SWKxxJO5LrXfa9vOKfSRoIBLnu198DiIgXJN1FrjPAZuAHEfFJamc8MANoDUyOiBcyexNmZtYgZUk4EfEhsHuNsn+op/7VwNW1lE/H0ySYmTUL5e6lZmZmXxBOOGZmlgknHDMzy4QTjpmZZcIJx8zMMuGEY2ZmmXDCMTOzTDjhmJlZJpxwzMwsE044ZmaWCSccMzPLRLln/DQzs3r0nPBwo9tYec3xRYik8ZxwzKxFKsof6g5FCMS28C01MzPLhBOOmZllwgnHzMwy4YRjZmaZcMIxM7NMOOGYmVkmnHDMzCwTZUs4klZKWixpoaTKVLabpFmSXk4/O6VySbpB0gpJiyQNymtnTKr/sqQx5Xo/ZmZWv3Jf4fyviBgYERVpfQIwJyL6AHPSOsCxQJ/0GgtMglyCAi4HDgaGApdXJykzM2tayp1wahoF3JKWbwG+mVd+a+TMAzpK6gYcA8yKiLcj4h1gFjAy66DNzGzbyplwApgp6TlJY1NZ14hYk5bfBLqm5b2A1/P2rUpldZV/jqSxkiolVa5fv76Y78HMzApUzrHUDo+I1ZK+DMyStDx/Y0SEpCjGgSLiZuBmgIqKiqK0aWZmDVO2hBMRq9PPdZLuJ/cMZq2kbhGxJt0yW5eqrwZ65O3ePZWtBobVKH+sxKGbmWVmZYfvFKGV94rQRuOVJeFI2hFoFRF/ScsjgCuBacAY4Jr084G0yzRgvKSp5DoIvJeS0gzg3/I6CowALsnwrZhZE1WcP9RWTOW6wukK3C+pOobbI+IRSfOBuySdC6wCTkv1pwPHASuAj4CzASLibUk/BeaneldGxNvZvQ0zMytUWRJORLwKHFRL+QZgeC3lAfygjrYmA5OLHaOZmRVXU+sWbWZmLZQTjpmZZcIJx8zMMuGEY2ZmmXDCMTOzTDjhmJlZJpxwzMwsE044ZmaWCSccMzPLhBOOmZllwgnHzMwy4YRjZmaZcMIxM7NMOOGYmVkmnHDMzCwTTjhmZpYJJxwzM8uEE46ZmWXCCcfMzDLhhGNmZpnIPOFI6iFprqSlkl6Q9MNUPlHSakkL0+u4vH0ukbRC0ouSjskrH5nKVkiakPV7MTOzwrUpwzE3A/87IhZI2hl4TtKstO36iPh5fmVJ/YHTgf2BPYHZkvqmzTcCRwNVwHxJ0yJiaSbvwszMGiTzhBMRa4A1afkvkpYBe9WzyyhgakRsAl6TtAIYmratiIhXASRNTXWdcMzMmqCyPsOR1BP4O+BPqWi8pEWSJkvqlMr2Al7P260qldVVbmZmTVDZEo6knYB7gR9FxPvAJGAfYCC5K6BfFPFYYyVVSqpcv359sZo1M7MGKEvCkdSWXLK5LSLuA4iItRHxSUR8CvyGz26brQZ65O3ePZXVVb6ViLg5IioioqJLly7FfTNmZlaQcvRSE/A7YFlEXJdX3i2v2reAJWl5GnC6pPaSegF9gGeB+UAfSb0ktSPXsWBaFu/BzMwarhy91A4D/gFYLGlhKvtXYLSkgUAAK4HvAUTEC5LuItcZYDPwg4j4BEDSeGAG0BqYHBEvZPlGzMyscOXopfYkoFo2Ta9nn6uBq2spn17ffmZm1nR4pAEzM8uEE46ZmWXCCcfMzDLhhGNmZplwwjEzs0w44ZiZWSaccMzMLBNOOGZmlgknHDMzy4QTjpmZZcIJx8zMMuGEY2ZmmSjHaNFmZpahnhMeLncIgBOOmTVBxfgDubJDEQKxovItNTMzy4SvcMysyVnZ4TvlDqFFKcb5rG0Ss4byFY6ZmWXCCcfMzDLhhGNmZplwwjEzs0w44ZiZWSaafcKRNFLSi5JWSJpQ7njMzKx2zTrhSGoN3AgcC/QHRkvqX96ozMysNs39ezhDgRUR8SqApKnAKGBpWaMy+yKbuGu5I7AmqrknnL2A1/PWq4CDa1aSNBYYm1Y3SVqSQWyN1Rl4q9xBFKA5xNkcYgTHWWyOs7j2bWwDzT3hFCQibgZuBpBUGREVZQ5pmxxn8TSHGMFxFpvjLC5JlY1to1k/wwFWAz3y1runMjMza2Kae8KZD/SR1EtSO+B0YFqZYzIzs1o061tqEbFZ0nhgBtAamBwRL2xjt5tLH1lROM7iaQ4xguMsNsdZXI2OUxFRjEDMzMzq1dxvqZmZWTPhhGNmZplokQlH0qmSXpD0qaSKGtsuScPgvCjpmDr27yXpT6nenalDQqljvlPSwvRaKWlhHfVWSlqc6jW6m+J2xDlR0uq8WI+ro17ZhhySdK2k5ZIWSbpfUsc66pXlXG7r3Ehqnz4PK9LnsGdWseXF0EPSXElL07+lH9ZSZ5ik9/I+Cz/JOs4UR72/R+XckM7nIkmDyhDjvnnnaaGk9yX9qEadspxPSZMlrcv/fqKk3STNkvRy+tmpjn3HpDovSxqzzYNFRIt7Af3IfUnpMaAir7w/8DzQHugFvAK0rmX/u4DT0/JNwPczjv8XwE/q2LYS6FzGczsR+Jdt1Gmdzm1voF065/0zjHEE0CYt/wfwH03lXBZyboBxwE1p+XTgzjL8nrsBg9LyzsBLtcQ5DHgo69ga+nsEjgP+QG7SykOAP5U53tbAm8BXmsL5BL4ODAKW5JX9DJiQlifU9m8I2A14Nf3slJY71XesFnmFExHLIuLFWjaNAqZGxKaIeA1YQW54nC0kCfh74J5UdAvwzVLGW8vxTwPuyOqYJbBlyKGI+CtQPeRQJiJiZkRsTqvzyH0/q6ko5NyMIve5g9zncHj6XGQmItZExIK0/BdgGbmRPZqjUcCtkTMP6CipWxnjGQ68EhGryhjDFhHxR+DtGsX5n8G6/gYeA8yKiLcj4h1gFjCyvmO1yIRTj9qGwqn5j2h34N28P1i11SmlI4C1EfFyHdsDmCnpuTRkTzmMT7cmJtdxqV3Iec7KOeT+d1ubcpzLQs7Nljrpc/geuc9lWaRben8H/KmWzYdKel7SHyTtn2lgn9nW77EpfR4hd9Va138om8L5BOgaEWvS8ptA11rqNPi8Ntvv4UiaDexRy6ZLI+KBrOMpRIExj6b+q5vDI2K1pC8DsyQtT/9DySROYBLwU3L/yH9K7vbfOcU8fiEKOZeSLgU2A7fV0UzJz2VzJ2kn4F7gRxHxfo3NC8jdFvogPcv7b6BP1jHSjH6P6XnwicAltWxuKufzcyIiJBXl+zPNNuFExFHbsVshQ+FsIHfJ3Sb977Jow+VsK2ZJbYCTgMH1tLE6/Vwn6X5yt2iK+o+r0HMr6TfAQ7VsKvmQQwWcy38ETgCGR7rhXEsbJT+XtSjk3FTXqUqfiV3JfS4zJaktuWRzW0TcV3N7fgKKiOmSfi2pc0RkOhBlAb/HpjQE1rHAgohYW3NDUzmfyVpJ3SJiTbr9uK6WOqvJPXeq1p3cc/M6fdFuqU0DTk+9gHqR+9/Ds/kV0h+nucApqWgMkNUV01HA8oioqm2jpB0l7Vy9TO7heKYjX9e49/2tOo5f1iGHJI0ELgJOjIiP6qhTrnNZyLmZRu5zB7nP4aN1Jc1SSc+Mfgcsi4jr6qizR/WzJUlDyf09yTQxFvh7nAaclXqrHQK8l3e7KGt13sFoCuczT/5nsK6/gTOAEZI6pVvrI1JZ3bLuEZHFi9wfwipgE7AWmJG37VJyvYReBI7NK58O7JmWe5NLRCuAu4H2GcU9BTi/RtmewOvtH98AAAJ2SURBVPS8uJ5PrxfI3T7K+tz+HlgMLEofym4140zrx5Hr2fRK1nGm39vrwML0uqlmjOU8l7WdG+BKcgkSoEP63K1In8PeZfg9H07utumivPN4HHB+9WcUGJ/O3fPkOmd8rQxx1vp7rBGnyE3U+Er67FZkHWeKY0dyCWTXvLKyn09yCXAN8Lf0d/Nccs8M5wAvA7OB3VLdCuC3efuekz6nK4Czt3UsD21jZmaZ+KLdUjMzszJxwjEzs0w44ZiZWSaccMzMLBNOOGZmlgknHLMmSNJjqjHSuVlz54RjZmaZcMIxayRJ5+fNYfKapLk1to+UdHfe+jBJD6XlSZIqlZtz5oo62v8gb/kUSVPSchdJ90qan16HleQNmhWJE45ZI0XETRExEBhC7pvaNYeCmQ0cnIZeAfg2uWkJIPfN+ArgQOBISQc24ND/CVwfEUOAk4Hfbu97MMtCsx2806wJ+k9y4549mF8YEZslPQJ8Q9I9wPHkxnoDOC0Nqd+G3KRn/ckNJ1OIo4D+eVPl7CJpp4j4oJ59zMrGCcesCNLo1F8hNx5WbaambW8DlRHxlzSA7L8AQyLinXSrrEMt++aPP5W/vRVwSERsbGT4ZpnwLTWzRpI0mFziODMiPq2j2uPkpvE9j89up+0CfAi8J6kruaHra7NWUj9JrcgNTFttJnBBXhwDt/9dmJWeE45Z440nN6/73NRxYKtnKRHxCbm5g45NP4mI54E/A8uB24Gn6mh/QtrnaXKj+lb7J6Aizb66lNzIw2ZNlkeLNjOzTPgKx8zMMuGEY2ZmmXDCMTOzTDjhmJlZJpxwzMwsE044ZmaWCSccMzPLxP8HNtx4XQIeHhMAAAAASUVORK5CYII=\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/ncsmith/src/coffea/coffea/hist/plot.py:355: 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\n",
      "                                 Dload  Upload   Total   Spent    Left  Speed\n",
      "100  212k  100  212k    0     0   848k      0 --:--:-- --:--:-- --:--:--  851k\n"
     ]
    }
   ],
   "source": [
    "!curl -O http://scikit-hep.org/uproot/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\n",
    "from uproot_methods import TLorentzVectorArray\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(\"Electron_*\", namedecode='ascii').items()}\n",
    "p4 = TLorentzVectorArray.from_cartesian(\n",
    "    arrays.pop('Px'),\n",
    "    arrays.pop('Py'),\n",
    "    arrays.pop('Pz'),\n",
    "    arrays.pop('E'),\n",
    ")\n",
    "electrons = awkward.JaggedArray.zip(p4=p4, **arrays)\n",
    "\n",
    "arrays = {k.replace('Muon_', ''): v for k,v in tree.arrays(\"Muon_*\", namedecode='ascii').items()}\n",
    "p4 = TLorentzVectorArray.from_cartesian(\n",
    "    arrays.pop('Px'),\n",
    "    arrays.pop('Py'),\n",
    "    arrays.pop('Pz'),\n",
    "    arrays.pop('E'),\n",
    ")\n",
    "muons = awkward.JaggedArray.zip(p4=p4, **arrays)\n",
    "\n",
    "print(\"Avg. electrons/event:\", electrons.counts.sum()/tree.numentries)\n",
    "print(\"Avg. muons/event:\", muons.counts.sum()/tree.numentries)"
   ]
  },
  {
   "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=electrons['p4'].pt.flatten(),\n",
    "    eta=electrons['p4'].eta.flatten()\n",
    ")\n",
    "lepton_kinematics.fill(\n",
    "    flavor=\"muon\",\n",
    "    pt=muons['p4'].pt.flatten(),\n",
    "    eta=muons['p4'].eta.flatten()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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": [
    "# 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",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}