{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Coffea-Casa Benchmark Example 2"
   ]
  },
  {
   "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 a per-event array (in this case, Jet pT). In Coffea, this is not very dissimilar from the event-level process.\n",
    "\n",
    "class Processor(processor.ProcessorABC):\n",
    "    def __init__(self):\n",
    "        dataset_axis = hist.Cat(\"dataset\", \"\")\n",
    "        Jet_axis = hist.Bin(\"Jet_pt\", \"Jet_pt [GeV]\", 100, 15, 60)\n",
    "        \n",
    "        self._accumulator = processor.dict_accumulator({\n",
    "            'Jet_pt': hist.Hist(\"Counts\", dataset_axis, Jet_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",
    "        dataset = events.metadata['dataset']\n",
    "        Jet_pt = events.Jet.pt\n",
    "        # As before, we can get the number of events by checking the size of the array. To get the number of jets, which varies per event, though, we need to count up the number in each event, and then sum those counts (count subarray sizes, sum them).\n",
    "        output['cutflow']['all events'] += ak.size(Jet_pt, axis=0)\n",
    "        output['cutflow']['all jets'] += ak.sum(ak.count(Jet_pt, axis=1))\n",
    "        \n",
    "        # .flatten() removes jaggedness; plotting jagged data is meaningless, we just want to plot flat jets.\n",
    "        output['Jet_pt'].fill(dataset=dataset, Jet_pt=ak.flatten(Jet_pt))\n",
    "        \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 |  2min 12.9s\r"
     ]
    }
   ],
   "source": [
    "from dask.distributed import Client\n",
    "import time\n",
    "\n",
    "client = Client(\"tls://localhost:8786\")\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='Jet_pt [GeV]', ylabel='Counts'>"
      ]
     },
     "execution_count": 4,
     "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": [
    "hist.plot1d(output['Jet_pt'], 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",
      "all jets 170952895\n"
     ]
    }
   ],
   "source": [
    "for key, value in output['cutflow'].items():\n",
    "    print(key, value)"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}