{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "%matplotlib inline\n",
    "from coffea import hist\n",
    "import coffea.processor as processor\n",
    "import awkward as ak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This program plots an event-level variable (in this case, MET, but switching it is as easy as a dict-key change). It also demonstrates an easy use of the book-keeping cutflow tool, to keep track of the number of events processed.\n",
    "\n",
    "# The processor class bundles our data analysis together while giving us some helpful tools.  It also leaves looping and chunks to the framework instead of us.\n",
    "class Processor(processor.ProcessorABC):\n",
    "    def __init__(self):\n",
    "        # Bins and categories for the histogram are defined here. For format, see https://coffeateam.github.io/coffea/stubs/coffea.hist.hist_tools.Hist.html && https://coffeateam.github.io/coffea/stubs/coffea.hist.hist_tools.Bin.html\n",
    "        dataset_axis = hist.Cat(\"dataset\", \"\")\n",
    "        MET_axis = hist.Bin(\"MET\", \"MET [GeV]\", 50, 0, 100)\n",
    "        \n",
    "        # The accumulator keeps our data chunks together for histogramming. It also gives us cutflow, which can be used to keep track of data.\n",
    "        self._accumulator = processor.dict_accumulator({\n",
    "            'MET': hist.Hist(\"Counts\", dataset_axis, MET_axis),\n",
    "            'cutflow': processor.defaultdict_accumulator(int)\n",
    "        })\n",
    "    \n",
    "    @property\n",
    "    def accumulator(self):\n",
    "        return self._accumulator\n",
    "    \n",
    "    def process(self, events):\n",
    "        output = self.accumulator.identity()\n",
    "        \n",
    "        # This is where we do our actual analysis. The dataset has columns similar to the TTree's; events.columns can tell you them, or events.[object].columns for deeper depth.\n",
    "        dataset = events.metadata[\"dataset\"]\n",
    "        MET = events.MET.pt\n",
    "        \n",
    "        # We can define a new key for cutflow (in this case 'all events'). Then we can put values into it. We need += because it's per-chunk (demonstrated below)\n",
    "        output['cutflow']['all events'] += ak.size(MET)\n",
    "        output['cutflow']['number of chunks'] += 1\n",
    "        \n",
    "        # This fills our histogram once our data is collected. The hist key ('MET=') will be defined in the bin in __init__.\n",
    "        output['MET'].fill(dataset=dataset, MET=MET)\n",
    "        return output\n",
    "\n",
    "    def postprocess(self, accumulator):\n",
    "        return accumulator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[########################################] | 100% Completed |  1min 10.1s\r"
     ]
    }
   ],
   "source": [
    "from dask.distributed import Client\n",
    "import time\n",
    "\n",
    "client = Client(\"tls://localhost:8786\")\n",
    "\n",
    "# Our file is missing some cross-references, so we have to make NanoAOD push warnings instead of erroring out.\n",
    "# This ultimately isn't a problem, it's just a constraint of the public NanoAOD we're using.\n",
    "def fix():\n",
    "    from coffea.nanoevents import NanoAODSchema\n",
    "    NanoAODSchema.warn_missing_crossrefs = True\n",
    "\n",
    "client.register_worker_callbacks(fix)\n",
    "processor.NanoAODSchema.warn_missing_crossrefs = True\n",
    "\n",
    "fileset = {'SingleMu' : [\"root://eospublic.cern.ch//eos/root-eos/benchmark/Run2012B_SingleMu.root\"]}\n",
    "\n",
    "output = processor.run_uproot_job(fileset,\n",
    "                                treename = 'Events',\n",
    "                                processor_instance = Processor(),\n",
    "                                executor = processor.dask_executor,\n",
    "                                executor_args = {'schema': processor.NanoAODSchema, 'client': client}\n",
    "                                )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='MET [GeV]', ylabel='Counts'>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAERCAYAAACKHYuuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAZsElEQVR4nO3de5BdZZnv8e9DEkg0CJpkuAVIOMIYg6LSZqIZIQPKzdTkzBwkQR3Fo4ByOXEAPc4MHkssqrBGLBgQYrgozNFEuQyBHBSZERWnEHMZiISIIIRDS47kMgEBISQ854+9k+w0vXt1unvtS+/vp6qre6/17rWfXkX6x3rfd70rMhNJkvqyW7MLkCS1PsNCklTIsJAkFTIsJEmFDAtJUiHDQpJUqC3DIiKuj4hnIuKhfrY/JSIejohVEfHdsuuTpOEm2vE+i4g4CngeuDEzDy9oeyjwfeCYzPzPiPiTzHymEXVK0nDRllcWmfkzYGPttoj4LxHxw4hYHhH3RsRbqrtOB76Rmf9Zfa9BIUm7qC3Doo4FwLmZeSRwAXBVdfthwGER8e8R8YuIOKFpFUpSmxrZ7AKGQkSMBd4L3BQR2zbvUf0+EjgUmAlMBO6NiMMzc1ODy5SktjUswoLKFdKmzHxHL/u6gV9k5ivAExHxCJXwWNrA+iSprQ2LbqjMfI5KEHwIICqOqO6+DfiL6vbxVLqlHm9GnZLUrtoyLCJiIXAf8KcR0R0RnwQ+AnwyIh4EVgGzq83vAjZExMPAPcDnMnNDM+qWpHbVllNnJUmN1ZZXFpKkxmq7Ae7x48fnpEmTml2GJLWV5cuXr8/MCQN9f9uFxaRJk1i2bFmzy5CkthIRTw7m/XZDSZIKGRaSpEKGhSSpUNuNWUgavl555RW6u7t56aWXml1K2xo9ejQTJ05k1KhRQ3pcw0JSy+ju7mbPPfdk0qRJ1Kzzpn7KTDZs2EB3dzeTJ08e0mPbDSWpZbz00kuMGzfOoBigiGDcuHGlXJkZFpJaikExOGWdv9LCIiIOjIh7ImJ19XGm83ppMzMino2IB6pf/6useiRJA1fmmMUW4PzMXBERewLLI+LuzHy4R7t7M3NWiXVIalNHf+AEnup+esiOd+DE/fnp3T8sbHfxxRfz3e9+lxEjRrDbbrvxzW9+k2uuuYbzzjuPt771rbv8uWvWrGHWrFk89NBDfbaZPHkyF154IV/5ylcAWL9+Pfvttx9nnnkmV1555S5/7lAqLSwycy2wtvrzHyJiNXAA0DMs1IdpM45i/cZNve4b/6a9+eW//6yxBUkN9FT300w966rihv206qqzCtvcd999LFmyhBUrVrDHHnuwfv16Nm/ezLXXXjtkddRzyCGHsGTJku1hcdNNNzF16tTSP7c/GjIbKiImAe8E7u9l93uqy4o/DVyQmasaUVO7WL9xU91/LCsXnMchU97e6z6DRBqYtWvXMn78ePbYo/KwzfHjxwMwc+ZMvva1r9HV1cXYsWOZN28eS5YsYcyYMSxevJh99tmH3/72t3zkIx9h69atnHjiiXz961/n+eef3+n4W7du5Qtf+AI/+clPePnllzn77LM588wzARgzZgxTpkxh2bJldHV18b3vfY9TTjmFp5+uXF2ddtppzJo1i5NPPhmAsWPHvub4ZSk9LKqPPL0F+Gz1IUW1VgAHZ+bzEXESlQcVHdrLMc4AzgA46KCDyi24SepdQWwdObrue95+xtfr7uvP/0FJeq3jjjuOiy66iMMOO4z3v//9zJkzh6OPPnqnNi+88ALTp0/n4osv5vOf/zzXXHMNF154IfPmzWPevHmceuqpzJ8/v9fjX3fddey1114sXbqUl19+mRkzZnDcccdtH5ieO3cuixYtYt9992XEiBHsv//+28OimUoNi4gYRSUovpOZt/bcXxsemXlnRFwVEeMzc32PdguABQBdXV3D8gEcfV1BDMTWkaO96pAGYOzYsSxfvpx7772Xe+65hzlz5nDJJZfs1Gb33Xdn1qzKUOuRRx7J3XffDVS6sG677TYAPvzhD3PBBRe85vg/+tGPWLlyJTfffDMAzz77LI8++iiHHXYYACeccAJf/OIX2WeffZgzZ05Zv+YuKy0sohKT1wGrM7PX/wWOiH2B32dmRsQ0KrOzfIrdEPCqQxq4ESNGMHPmTGbOnMnb3vY2brjhhp32jxo1avuVwIgRI9iyZUu/j52ZXHHFFRx//PE7bV+zZg1QCaIjjzySSy+9lFWrVnHHHXdsbzNy5EheffXV7cfZvHnzQH69ASnzPosZwN8Ax9RMjT0pIj4dEZ+utjkZeKg6ZvFPwNz00X2SmuiRRx7h0Ucf3f76gQce4OCDD+7Xe6dPn84tt9wCwKJFi3ptc/zxx3P11VfzyiuvAPCb3/yGF154Yac2559/Pl/96lcZN27cTtsnTZrE8uXLAVi8ePH2YzRCmbOhfg70eXdIZl4JNHc+mKSWdeDE/Yf0SvjAifsXtnn++ec599xz2bRpEyNHjuTNb34zCxYs2D6o3JfLLruMj370o1x66aV88IMfZK+99npNm0996lOsWbOGd73rXWQmEyZM2N51tc3UqVN7nQV1+umnM3v2bKZNm8axxx7L61//+sKahkrbPYO7q6srh+PDjw6Z8vYhHbPoy8oF5zFiy2uXA3AsQ822evVqpkyZ0uwyBuzFF19kzJgxRASLFi1i4cKFLF68uOF19HYeI2J5ZnYN9JguJNhAfd0z0desp6FWbzzDsQxpcJYvX84555xDZrL33ntz/fXXN7ukIWNYNNBQz3iS1Fre97738eCDDza7jFK4kKCkltJuXeOtpqzz55WFtvPeDDXb6NGj2bBhg8uUD9C251mMHj303dqGhbbz3gw128SJE+nu7mbdunXNLqVtbXtS3lAzLCS1jFGjRg35E940NByzkCQVMiwkSYUMC0lSIccs1C/OlJI6m2ExxFrlLu2h5kwpqbMZFkPMu7QlDUeOWUiSChkWkqRChoUkqZBhIUkq5AC3Bq3etFqn1ErDh2GhQfNhStLwZzeUJKmQYSFJKmRYSJIKGRaSpEKGhSSpkLOhVBpXqpWGD8NCpXGlWmn4MCwGqN5S5O28DLkk1WNYDJBLkUvqJA5wS5IKGRaSpEKGhSSpkGEhSSpU2gB3RBwI3AjsC7wKLMjMy3u0CeBy4CTgReC0zFxRVk1qHd6DIbWXMmdDbQHOz8wVEbEnsDwi7s7Mh2vanAgcWv36M+Dq6ncNc96DIbWX0rqhMnPttquEzPwDsBo4oEez2cCNWfELYO+I2K+smiRJA9OQMYuImAS8E7i/x64DgKdqXnfz2kCRJDVZ6WEREWOBW4DPZuZzPXf38pbs5RhnRMSyiFi2bt26MsqUJPWh1LCIiFFUguI7mXlrL026gQNrXk8Enu7ZKDMXZGZXZnZNmDChnGIlSXWVFhbVmU7XAaszs95o5u3Ax6JiOvBsZq4tqyZJ0sCUORtqBvA3wK8i4oHqtr8HDgLIzPnAnVSmzT5GZersJ0qsR5I0QKWFRWb+nN7HJGrbJHB2WTVIkoaGq86q5dS7Yc+b9aTmMSzUcurdsOfNelLzuDaUJKmQYSFJKmRYSJIKGRaSpEIOcPdh2oyjWL9xU6/7to4c3dhiJKmJDIs+rN+4ialnXdXsMiSp6eyGkiQVMiwkSYXshlLb8FGsUvMYFmobPopVah67oSRJhQwLSVIhw0KSVMiwkCQVMiwkSYUMC0lSIcNCklTIsJAkFfKmPA0L3t0tlcuw0LDg3d1SueyGkiQVMiwkSYUMC0lSIcNCklTIsJAkFTIsJEmFDAtJUiHDQpJUyLCQJBUyLCRJhUpb7iMirgdmAc9k5uG97J8JLAaeqG66NTMvKqsedS7XjZIGr8y1ob4NXAnc2EebezNzVok1FJo24yjWb9zU676tI0c3thiVwnWjpMErLSwy82cRMams4w+V9Rs3MfWsq5pdhiS1tF0es4iIN0ZE79f0u+49EfFgRPwgIqYO0TElSUOsX2ERET+JiDdExJuAB4FvRUT9a/v+WQEcnJlHAFcAt/Xx+WdExLKIWLZu3bpBfqwkaVf198pir8x8Dvhr4FuZeSTw/sF8cGY+l5nPV3++ExgVEePrtF2QmV2Z2TVhwoTBfKwkaQD6GxYjI2I/4BRgyVB8cETsGxFR/XlatZYNQ3FsSdLQ6u8A95eBu4CfZ+bSiDgEeLSvN0TEQmAmMD4iuoEvAaMAMnM+cDLwmYjYAvwRmJuZOaDfQpJUqv6GxdrM3D6onZmPF41ZZOapBfuvpDK1VpLU4vrbDXVFP7dJkoahPq8sIuI9wHuBCRFxXs2uNwAjyixMktQ6irqhdgfGVtvtWbP9OSpjDlJbq7cUiMuASDvrMywy86fATyPi25n5ZINqkhqm3lIgLgMi7ay/A9x7RMQCYFLtezLzmDKKkiS1lv6GxU3AfOBaYGt55UiSWlF/w2JLZl5daiWSpJbV36mzd0TEWRGxX0S8adtXqZVJklpGf68sPl79/rmabQkcMrTlSJJaUb/CIjMnl12IJKl19SssIuJjvW3PzL6egidJGib62w317pqfRwPHUnkehWEhSR2gv91Q59a+joi9gH8upSJJUsvZ5ceqVr0IHDqUhUiSWld/xyzuoDL7CSoLCE4Bvl9WUVKz1VszClw3Sp2pv2MWX6v5eQvwZGZ2l1CP1BLqrRkFrhulztSvbqjqgoK/prLy7BuBzWUWJUlqLf0Ki4g4Bfgl8CEqz+G+PyJcolySOkR/u6H+AXh3Zj4DEBETgH8Fbi6rMElS6+jvbKjdtgVF1YZdeK8kqc3198rihxFxF7Cw+noOcGc5JUmSWk3RM7jfDOyTmZ+LiL8G/hwI4D7gOw2oT5LUAoq6ki4D/gCQmbdm5nmZ+bdUriouK7c0SVKrKOqGmpSZK3tuzMxlETGpnJLKMW3GUazfuOk127eOHN34YiSpzRSFRV9/SccMZSFlW79xE1PPuqrZZUhSWyoKi6URcXpmXlO7MSI+CSwvryypdbkUiDpRUVh8FviXiPgIO8KhC9gd+KsS65JalkuBqBP1GRaZ+XvgvRHxF8Dh1c3/JzN/XHplkqSW0d/nWdwD3FNyLZKkFuVd2JKkQoaFJKmQYSFJKmRYSJIKlRYWEXF9RDwTEQ/V2R8R8U8R8VhErIyId5VViyRpcMq8svg2cEIf+08EDq1+nQFcXWItkqRBKC0sMvNnwMY+mswGbsyKXwB7R8R+ZdUjSRq4/j7PogwHAE/VvO6ublvbs2FEnEHl6oODDjqoIcVJA1FvKRCXAVG7a2ZYRC/bsreGmbkAWADQ1dXVaxupFdRbCsRlQNTumjkbqhs4sOb1RODpJtUiSepDM8PiduBj1VlR04FnM/M1XVCSpOYrrRsqIhYCM4HxEdENfAkYBZCZ86k8be8k4DHgReATZdUiSRqc0sIiM08t2J/A2WV9viRp6HgHtySpkGEhSSpkWEiSChkWkqRChoUkqVAz7+CWOka9ZUDApUDUHgwLqQHqLQMCLgWi9mA3lCSpkGEhSSpkWEiSChkWkqRChoUkqZBhIUkqZFhIkgp5n4XUZN6wp3ZgWEhN5g17agfDKiymzTiK9Rs39bpv68jRjS1GkoaRYRUW6zduYupZVzW7DEkadhzgliQVMiwkSYUMC0lSIcNCklTIsJAkFRpWs6Gk4abeDXverKdGMyykFlbvhj1v1lOj2Q0lSSpkWEiSChkWkqRChoUkqZBhIUkqZFhIkgo5dVZqQz4wSY1WalhExAnA5cAI4NrMvKTH/pnAYuCJ6qZbM/OiMmuShgMfmKRGKy0sImIE8A3gA0A3sDQibs/Mh3s0vTczZ5VVhyRp8Mocs5gGPJaZj2fmZmARMLvEz5MklaTMsDgAeKrmdXd1W0/viYgHI+IHETG1twNFxBkRsSwilq1bt66MWiVJfSgzLKKXbdnj9Qrg4Mw8ArgCuK23A2XmgszsysyuCRMmDG2VkqRCZYZFN3BgzeuJwNO1DTLzucx8vvrzncCoiBhfYk2SpAEoczbUUuDQiJgM/A6YC3y4tkFE7Av8PjMzIqZRCa8NJdYkDXtOq1UZSguLzNwSEecAd1GZOnt9Zq6KiE9X988HTgY+ExFbgD8CczOzZ1eVpF3gtFqVodT7LKpdS3f22Da/5ucrgSvLrEGSNHgu9yFJKmRYSJIKGRaSpEIuJCh1kHozpZwlpSKGhdRB6s2UcpaUitgNJUkqZFhIkgoZFpKkQo5ZSHKJEBUyLCS5RIgKtV1YrP71I3X/D2jryNENrkaSOkPbhcWWrVuZetZVzS5DkjqKA9ySpEJtd2UhqbEc/BYYFpIKOPgtsBtKktQPhoUkqZDdUJIGzPGMzmFYSBowxzM6h91QkqRCXllIKoUPWhpeDAtJpfBBS8OLYSGpoRwUb0+GhaSGclC8PRkWklqGVx2ty7CQ1DK86mhdhoWktuDsquYyLCS1BWdXNZdhIamtOc7RGIaFpLbW1zjHygXnGSRDxLCQNGwNJEgMkd4ZFpI6Ur0g6etqpC/DPWRKDYuIOAG4HBgBXJuZl/TYH9X9JwEvAqdl5ooya5KkvvR1NdKXgYRMOwVMaWERESOAbwAfALqBpRFxe2Y+XNPsRODQ6tefAVdXv0tSWxlIyAz0KmZAIqYM5u1lXllMAx7LzMcBImIRMBuoDYvZwI2ZmcAvImLviNgvM9eWWJcktYSBXsUMxBPzjh7U3/syw+IA4Kma19289qqhtzYHADuFRUScAZxRfZlL5h39ytCW2qYydyPi1WaX0RI8Fzt4LnbwXOyQr7ZsWEQv23IAbcjMBcACgIhYlq9u7Rp8ee2vci5e9VzguajludjBc7FDRCwbzPvLfFJeN3BgzeuJwNMDaCNJarIyw2IpcGhETI6I3YG5wO092twOfCwqpgPPOl4hSa2ntG6ozNwSEecAd1GZOnt9Zq6KiE9X988H7qQybfYxKlNnP9GPQy8oqeR25LnYwXOxg+diB8/FDoM6F1GZiCRJUn1ldkNJkoYJw0KSVKitwiIiToiIRyLisYj4QrPraaSIODAi7omI1RGxKiLmVbe/KSLujohHq9/f2OxaGyEiRkTEf0TEkurrTj0Pe0fEzRHx6+p/G+/p4HPxt9V/Gw9FxMKIGN1J5yIiro+IZyLioZptdX//iPi76t/SRyLi+KLjt01Y1CwfciLwVuDUiHhrc6tqqC3A+Zk5BZgOnF39/b8A/FtmHgr8W/V1J5gHrK553ann4XLgh5n5FuAIKuek485FRBwA/A+gKzMPpzKpZi6ddS6+DZzQY1uvv3/1b8dcYGr1PVdV/8bW1TZhQc3yIZm5Gdi2fEhHyMy12xZZzMw/UPmjcACVc3BDtdkNwH9tSoENFBETgQ8C19Zs7sTz8AbgKOA6gMzcnJmb6MBzUTUSGBMRI4HXUblnq2PORWb+DNjYY3O93382sCgzX87MJ6jMSJ3W1/HbKSzqLQ3ScSJiEvBO4H5gn233plS//0kTS2uUy4DPA7XLOHTieTgEWAd8q9old21EvJ4OPBeZ+Tvga8D/pbJc0LOZ+SM68Fz0UO/33+W/p+0UFv1aGmS4i4ixwC3AZzPzuWbX02gRMQt4JjOXN7uWFjASeBdwdWa+E3iB4d3NUle1L342MBnYH3h9RHy0uVW1tF3+e9pOYdHxS4NExCgqQfGdzLy1uvn3EbFfdf9+wDPNqq9BZgB/GRFrqHRFHhMR/5vOOw9Q+TfRnZn3V1/fTCU8OvFcvB94IjPXZeYrwK3Ae+nMc1Gr3u+/y39P2yks+rN8yLBVfVDUdcDqzKxd1/h24OPVnz8OLG50bY2UmX+XmRMzcxKV/wZ+nJkfpcPOA0Bm/j/gqYj40+qmY6k8AqDjzgWV7qfpEfG66r+VY6mM63XiuahV7/e/HZgbEXtExGQqzxT6ZV8Haqs7uCPiJCr91duWD7m4uRU1TkT8OXAv8Ct29NX/PZVxi+8DB1H5B/OhzOw5yDUsRcRM4ILMnBUR4+jA8xAR76Ay0L878DiVJXN2ozPPxZeBOVRmDv4H8ClgLB1yLiJiITATGA/8HvgScBt1fv+I+Afgv1M5X5/NzB/0efx2CgtJUnO0UzeUJKlJDAtJUiHDQpJUyLCQJBUyLCRJhQwLSVIhw0IdISIyIv655vXIiFhXs8T5adXXD9R8HVHz88aIeKL687/2OPakiPhjRDxQs22fiPhuRDweEcsj4r6I+KuCGp+oucFu27bLIuLzEfG+iHi4dvlpqZFKewa31GJeAA6PiDGZ+UfgA8DverT5Xmae02PbOwAi4tvAksy8uc7xf5uZ29oGlZuhbsjMD1e3HQz8ZUGNi6jclf7l6nt2A04GZmTmk9WbUpcUHEMqhVcW6iQ/oLK0OcCpwMKSPucYYHNmzt+2ITOfzMwrYPuDm/4xIpZGxMqIOLPabCGVsNjmKGBNZj5ZUp1SvxkW6iSLqKyHMxp4O5WlUmrN6dENNWaAnzMVWNHH/k9SWUL73cC7gdMjYnJmrgRejYgjqu3mUl6gSbvEsFDHqP4xnkTlquLOXpp8LzPfUfP1x6H43Ij4RkQ8GBFLq5uOAz5WHeO4HxhHZSE3qF5dVB/gMxu4aShqkAbLMQt1mtupPCRnJpU/0mVYBfy3bS8y8+yIGA8sq24K4NzMvKuX9y4EfgT8FFiZmZ22pLZalFcW6jTXAxdl5q9K/IwfA6Mj4jM1215X8/NdwGeqzychIg6rPuGOzPwtsAG4BLug1EIMC3WUzOzOzMvr7O45ZvHeAX5GUnnW8dHV6bC/pPL84/9ZbXItledOrKhOhf0mO1/lLwTeAvzLQD5fKoNLlEuDVH0m+pLMPHw4fI7UG68spMHbCuxVe1PeUIuI9wF3AOvL+gypL15ZSJIKeWUhSSpkWEiSChkWkqRChoUkqdD/B3WjINQcrDELAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Generates a 1D histogram from the data output to the 'MET' key. fill_opts are optional, to fill the graph (default is a line).\n",
    "hist.plot1d(output['MET'], overlay='dataset', fill_opts={'edgecolor': (0,0,0,0.3), 'alpha': 0.8})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all events 53446198\n",
      "number of chunks 534\n"
     ]
    }
   ],
   "source": [
    "# Easy way to print all cutflow dict values. Can just do print(output['cutflow'][\"KEY_NAME\"]) for one.\n",
    "for key, value in output['cutflow'].items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}