z-mumu-cr.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start up Spark (only needs to be done once)\n",
    "import pyspark.sql\n",
    "session = pyspark.sql.SparkSession.builder \\\n",
    "    .master(\"mesos://zk://mesos-zk1:2181,mesos-zk2:2181,mesos-zk3:2181/mesos\") \\\n",
    "    .appName(\"z-mumu\") \\\n",
    "    .config('spark.driver.memory', '4g') \\\n",
    "    .config('spark.eventLog.enabled', 'true') \\\n",
    "    .config('spark.eventLog.dir', 'hdfs://hdfs-nn2/spark-history') \\\n",
    "    .config('spark.shuffle.service.enabled', 'true') \\\n",
    "    .config('spark.dynamicAllocation.enabled', 'false') \\\n",
    "    .config('spark.sql.catalogImplementation', 'in-memory') \\\n",
    "    .config('spark.mesos.executor.docker.image', 'perilousapricot/cms-jupyter:latest') \\\n",
    "    .config('spark.mesos.executor.home', '/usr/local/spark') \\\n",
    "    .config('spark.mesos.executor.docker.volumes', '/mnt/nfs/jupyter/:/home/:rw,/cvmfs:/cvmfs:ro,/lfs_roots/instances:/lio:rw,/cms:/cms:ro,/mnt/nfs/jupyter/passwd:/etc/passed:ro,/mnt/nfs/jupyter/group:/etc/group:ro,/tmp:/tmp') \\\n",
    "    .config('spark.executor.memory', '100g') \\\n",
    "    .config('spark.mesos.task.labels', 'testkey:testvalue') \\\n",
    "    .config('spark.dynamicAllocation.initialExecutors', '4') \\\n",
    "    .config('spark.dynamicAllocation.cachedExecutorIdleTimeout', '2h') \\\n",
    "    .config('spark.dynamicAllocation.executorIdleTimeout', '30m') \\\n",
    "    .config('spark.executor.cores', '14') \\\n",
    "    .config('spark.speculation', 'true') \\\n",
    "    .config('spark.mesos.executor.docker.parameters', 'workdir=/tmp') \\\n",
    "    .config('spark.executor.heartbeatInterval', '60s') \\\n",
    "    .config(\"spark.python.profile\", \"true\") \\\n",
    "    .config('spark.jars.packages', 'org.diana-hep:spark-root_2.11:0.1.15,org.diana-hep:histogrammar-sparksql_2.11:1.0.4') \\\n",
    "    .getOrCreate()\n",
    "sc = session.sparkContext\n",
    "sqlContext = session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Loading DataFrames .......................done\n",
      "DYJets(dy) - 48435266\n",
      "DiBoson(ww) - 6947038\n",
      "DiBoson(wz) - 2979124\n",
      "DiBoson(zz) - 992744\n",
      "SingleTop(ss) - 2876045\n",
      "SingleTop(stb) - 3809631\n",
      "SingleTop(stt) - 5964287\n",
      "SingleTop(sttwb) - 991780\n",
      "SingleTop(sttwt) - 985470\n",
      "TTJets(tt) - 10066547\n",
      "WJets(wj) - 29212279\n",
      "WJets(wj) - 56246105\n",
      "MC Partitions:  8355\n",
      "Data Partitions: 10683\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "import sys\n",
    "from pyspark.sql.functions import lit\n",
    "from pyspark.sql.types import *\n",
    "\n",
    "dataDFList = []\n",
    "mcDFList = []\n",
    "\n",
    "sys.stdout.write(\"\\nLoading DataFrames \")\n",
    "fileInputs = json.loads(open(\"input-files.json\", \"r\").read())\n",
    "\n",
    "for category, subcategory, path, xsec, efficiency, count in fileInputs: \n",
    "    if category in (\"Category\", \"DISABLED\"):\n",
    "        continue\n",
    "    \n",
    "    dsPath = \"hdfs://hdfs-nn2/tmp/store/group/ra2tau/\" + path + \"/\"\n",
    "    tempDF = sqlContext.read.load(dsPath) \\\n",
    "                    .withColumn(\"Category\", lit(category)) \\\n",
    "                    .withColumn(\"SubCategory\", lit(subcategory))\n",
    "\n",
    "    if xsec == \"DATA\":\n",
    "        tempDF2 = tempDF.withColumn(\"xsec\", lit(float(1.0))) \\\n",
    "                        .withColumn(\"eff\", lit(float(1.0))) \\\n",
    "                        .withColumn(\"count\", lit(float(1.0)))\n",
    "        dataDFList.append([tempDF2, category, subcategory, xsec, efficiency, count])\n",
    "    else:\n",
    "        tempDF2 = tempDF.withColumn(\"xsec\", lit(float(xsec))) \\\n",
    "                        .withColumn(\"eff\", lit(float(efficiency))) \\\n",
    "                        .withColumn(\"count\", lit(float(count)))\n",
    "        mcDFList.append([tempDF2, category, subcategory, xsec, efficiency, count])\n",
    "\n",
    "    sys.stdout.write('.')\n",
    "print \"done\"\n",
    "# Monte-Carlo\n",
    "if mcDFList:\n",
    "    mcDF = mcDFList[0][0]\n",
    "    print \"%s(%s) - %s\" % (mcDFList[0][1], mcDFList[0][2], mcDFList[0][0].count())\n",
    "    for x in mcDFList[1:]:\n",
    "        print \"%s(%s) - %s\" % (x[1], x[2], x[0].count())\n",
    "        mcDF = mcDF.union(x[0])\n",
    "    print \"MC Partitions:  %d\" % mcDF.rdd.getNumPartitions()\n",
    "\n",
    "# Data\n",
    "if dataDFList:\n",
    "    dataDF = dataDFList[0][0]\n",
    "    for x in dataDFList[1:]:\n",
    "        dataDF = dataDF.union(x[0])\n",
    "    print \"Data Partitions: %d\" % dataDF.rdd.getNumPartitions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add a \"weights\" column\n",
    "processedLumiPB = 35900\n",
    "mcWeight = (mcDF['xsec'] * mcDF['eff'] * processedLumiPB) / mcDF['count']\n",
    "mcDFWeighed = mcDF.withColumn(\"weight\", mcWeight)\n",
    "dataDFWeighed = dataDF.withColumn(\"weight\", lit(1.0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We want to combine the data/MC into a single Spark dataset to simplify the\n",
    "# later steps. To do this, though, they all need to have the same columns\n",
    "reqCol = ['Muon_pt', 'Muon_eta', 'Muon_phi', 'Muon_energy',\n",
    "          'Muon_charge', 'Muon_loose',\n",
    "          'Jet_pt', 'Jet_eta', 'Jet_phi', 'Jet_energy',\n",
    "          'Met_type1PF_pt','Met_type1PF_px','Met_type1PF_py',\n",
    "          'Met_type1PF_pz','Met_type1PF_phi',\n",
    "          'eff', 'xsec', 'weight',\n",
    "          'Category', 'SubCategory']\n",
    "trimMCDF = mcDFWeighed.select(*reqCol)\n",
    "trimDataDF = dataDFWeighed.select(*reqCol)\n",
    "trimDF = trimMCDF.union(trimDataDF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a custom spark type. This type will be added to a custom\n",
    "# column which is an output from a python function\n",
    "from pyspark.sql.types import *\n",
    "\n",
    "muSchema = StructType([\n",
    "    # Simple flags\n",
    "    StructField(\"pass\", BooleanType(), False),\n",
    "    StructField(\"ss\", BooleanType(), False),\n",
    "    StructField(\"invmass\", FloatType(), False),\n",
    "\n",
    "    # Properties of muons that pass our cuts\n",
    "    StructField(\"pt1\", FloatType(), False),\n",
    "    StructField(\"eta1\", FloatType(), False),\n",
    "    StructField(\"phi1\", FloatType(), False),\n",
    "    StructField(\"energy1\", FloatType(), False),\n",
    "    StructField(\"charge1\", FloatType(), False),\n",
    "    \n",
    "    StructField(\"pt2\", FloatType(), False),\n",
    "    StructField(\"eta2\", FloatType(), False),\n",
    "    StructField(\"phi2\", FloatType(), False),\n",
    "    StructField(\"energy2\", FloatType(), False),\n",
    "    StructField(\"charge2\", FloatType(), False),\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a custom python function which will produce some derived values. This\n",
    "# can be absolutely anything, as long as its deterministic and idempotent\n",
    "\n",
    "# ... The will be of the type we defined just before.\n",
    "muonTestFalse = (False, False, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)\n",
    "def muonTest(pt,eta,phi,energy,charge,loose):\n",
    "    \"\"\"\n",
    "    Perform muon selection:\n",
    "      pT > 30\n",
    "      abs(eta) < 2.1\n",
    "      80GeV < DiMuonInvMass < 100GeV\n",
    "      N(mu) == 2\n",
    "    \"\"\"\n",
    "    passes = True\n",
    "    if len(pt) < 2:\n",
    "        return muonTestFalse\n",
    "    \n",
    "    leadingIdx = None\n",
    "    trailingIdx = None\n",
    "    for idx in range(len(pt)):\n",
    "        if leadingIdx == None:\n",
    "            if pt[idx] > 30 and abs(eta[idx]) < 2.1 and loose[idx]:\n",
    "                leadingIdx = idx\n",
    "        elif trailingIdx == None:\n",
    "            if pt[idx] > 30 and abs(eta[idx]) < 2.1 and loose[idx]:\n",
    "                trailingIdx = idx\n",
    "        else:\n",
    "            if pt[idx] > 30 and abs(eta[idx]) < 2.1 and loose[idx]:\n",
    "                return muonTestFalse\n",
    "    \n",
    "    if leadingIdx != None and trailingIdx != None:\n",
    "        dimuInvMass = invMass(pt[leadingIdx], pt[trailingIdx],\n",
    "                                eta[leadingIdx], eta[trailingIdx],\n",
    "                                phi[leadingIdx], phi[trailingIdx],\n",
    "                                energy[leadingIdx], energy[trailingIdx])\n",
    "        return (True,\n",
    "                (charge[leadingIdx] * charge[trailingIdx]) > 0,\n",
    "                dimuInvMass,\n",
    "                pt[leadingIdx], pt[trailingIdx],\n",
    "                eta[leadingIdx], eta[trailingIdx],\n",
    "                phi[leadingIdx], phi[trailingIdx],\n",
    "                energy[leadingIdx], energy[trailingIdx],\n",
    "                charge[leadingIdx], charge[trailingIdx])\n",
    "    else:\n",
    "        # if N(mu) != 2\n",
    "        return muonTestFalse\n",
    "\n",
    "import math\n",
    "def invMass(pt0,pt1, eta0, eta1, phi0, phi1, energy0, energy1):\n",
    "    vec1 = (pt0 * math.cos(phi0), pt0 * math.sin(phi0), pt0 * math.sinh(eta0), energy0)\n",
    "    vec2 = (pt1 * math.cos(phi1), pt1 * math.sin(phi1), pt1 * math.sinh(eta1), energy1)\n",
    "\n",
    "    sumvec = (vec1[0] + vec2[0],\n",
    "              vec1[1] + vec2[1],\n",
    "              vec1[2] + vec2[2],\n",
    "              vec1[3] + vec2[3])\n",
    "    magSquared = sumvec[0]*sumvec[0] \\\n",
    "                     + sumvec[1]*sumvec[1] \\\n",
    "                     + sumvec[2]*sumvec[2] \\\n",
    "                     - sumvec[3]*sumvec[3]\n",
    "    if magSquared > 0.0:\n",
    "        return math.sqrt(magSquared)\n",
    "    else:\n",
    "        return math.sqrt(-magSquared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert the python function to a Spark UDF (there's also a\n",
    "# decorator that does this). This tells Spark to run muonTest\n",
    "# and return muSchema\n",
    "from pyspark.sql.functions import udf\n",
    "muonUDF = udf(muonTest, muSchema)\n",
    "\n",
    "# Now tell Spark we want to \n",
    "flatDF = trimDF.withColumn(\"muSel\", muonUDF(\"Muon_pt\", \n",
    "                                           \"Muon_eta\",\n",
    "                                           \"Muon_phi\",\n",
    "                                           \"Muon_energy\",\n",
    "                                           \"Muon_charge\",\n",
    "                                           \"Muon_loose\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "passMuDF = flatDF.where(\"muSel.pass == True\")\n",
    "passMuDF = passMuDF.cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------------------------------------------------------------------------------------------------------------+\n",
      "|muSel                                                                                                               |\n",
      "+--------------------------------------------------------------------------------------------------------------------+\n",
      "|[true,true,42.130745,70.31298,37.222256,0.12262728,-0.6786659,-0.02368905,-0.05557488,70.842384,46.128536,-1.0,-1.0]|\n",
      "|[true,true,83.21503,51.00024,31.819628,0.9399291,1.5536748,-1.5349883,1.9570378,75.237045,78.59909,-1.0,-1.0]       |\n",
      "|[true,true,150.14207,129.67409,33.094105,0.38001454,-0.6884529,-0.6914861,2.489376,139.15054,41.251705,-1.0,-1.0]   |\n",
      "|[true,true,146.35324,102.219955,45.875477,-0.16423549,0.6313914,-0.48854694,2.969861,103.601715,55.327675,1.0,1.0]  |\n",
      "|[true,true,0.9542496,56.914436,31.983658,1.1955177,1.1925913,-0.86010593,-0.88167036,102.66845,57.555393,-1.0,-1.0] |\n",
      "|[true,true,90.15616,62.719593,32.472797,0.9502102,1.1528411,2.2848601,-1.081595,93.23,56.550125,-1.0,-1.0]          |\n",
      "|[true,true,68.01124,50.113293,33.043507,-0.26598132,-1.2180612,2.209356,0.73055315,51.896534,60.741165,-1.0,-1.0]   |\n",
      "|[true,true,74.46316,48.242054,30.557604,-0.26124507,0.66290396,0.36425763,-1.6425613,49.897785,37.521397,-1.0,-1.0] |\n",
      "|[true,true,98.89647,49.821365,47.959824,1.6885593,1.3775464,-0.39879495,2.808227,139.41177,101.13191,1.0,1.0]       |\n",
      "|[true,true,122.8197,68.470535,42.497295,-0.15596907,0.9102048,0.1839533,-2.7029586,69.30512,61.350742,1.0,1.0]      |\n",
      "|[true,true,5.5168486,39.573753,34.123726,-1.4227015,-1.2731037,-0.12597942,-0.116860144,86.852066,65.72038,1.0,1.0] |\n",
      "|[true,true,137.01408,49.978317,34.279503,-1.3952897,0.7846459,-1.0831544,2.093741,107.05123,45.384678,-1.0,-1.0]    |\n",
      "|[true,true,66.53284,51.068207,34.29398,1.8270401,0.5604734,-0.8816228,-0.020329278,162.81444,39.822998,-1.0,-1.0]   |\n",
      "|[true,true,105.90134,67.5152,34.240284,0.57498556,1.468059,0.80796164,-2.3596137,78.9867,78.25921,1.0,1.0]          |\n",
      "|[true,true,79.44105,37.327827,30.531641,-1.8836437,-0.35592577,-2.5776627,-0.6425213,125.59816,32.486237,-1.0,-1.0] |\n",
      "|[true,true,75.932724,39.549862,39.217014,-0.37177008,1.0503515,-0.3252472,-1.5545732,42.31477,62.913406,1.0,1.0]    |\n",
      "|[true,true,98.023026,53.086357,47.24465,0.97942394,1.0693126,2.830496,-0.7350109,80.65017,76.92902,-1.0,-1.0]       |\n",
      "|[true,true,127.23344,40.655586,34.383507,1.3539598,-0.97288495,-3.0961432,-0.85824233,83.97308,51.98035,-1.0,-1.0]  |\n",
      "|[true,true,18.454597,40.033997,39.26958,1.5850439,2.0462117,0.41690633,0.4054543,101.77537,154.48172,1.0,1.0]       |\n",
      "|[true,true,53.99529,45.68514,37.020145,-1.8595343,-0.73310685,-2.3961172,-1.8272241,150.22398,47.42203,-1.0,-1.0]   |\n",
      "+--------------------------------------------------------------------------------------------------------------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "passMuDF.where(\"muSel.ss == True\").select('muSel').show(truncate = False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load libraries, amp up passMuDF with histogrammar\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import histogrammar as hg\n",
    "import histogrammar.sparksql\n",
    "hg.sparksql.addMethods(passMuDF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Monkey-patch histogrammar to fix a bug\n",
    "def x(self, jvm, converter):\n",
    "    return converter.Select(self.quantity.asSparkSQL(), self.cut._sparksql(jvm, converter))\n",
    "hg.Select._sparksql = x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "plots = hg.UntypedLabel(\n",
    "    # Count events (both raw and weighted)\n",
    "    nRawEvents = hg.Sum(lit(1.0)),\n",
    "    nEvents = hg.Sum(passMuDF['weight']),\n",
    "    # Make some regular \"histograms\" of muon pT\n",
    "    LeadPt = hg.Bin(50, 0, 150, passMuDF['muSel.pt1'], hg.Count(passMuDF['weight'])),\n",
    "    SecondPt = hg.Bin(50, 0, 150, passMuDF['muSel.pt2'], hg.Count(passMuDF['weight'])),\n",
    "    # Let's make an additional cut for only same-sign events\n",
    "    ssCut = hg.Select(\n",
    "        passMuDF['muSel.ss'] == True,\n",
    "        # .. and count them\n",
    "        hg.Sum(passMuDF['weight']),\n",
    "    ),\n",
    ")     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a set of histograms per-sample\n",
    "bulkHisto = hg.Categorize(quantity = passMuDF[\"Category\"], value = plots)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fill from spark -- this is needed if you do a hg.Categorize (static) instead of a passMuDF.Categorize (the class method)\n",
    "bulkHisto.fillsparksql(df=passMuDF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample  Raw  Weighted\n",
      "    DiBoson     71586.0      22699.2\n",
      "     TTJets     88222.0     261691.0\n",
      "      WJets      3238.0      83691.0\n",
      "     DYJets   3974396.0   15693668.7\n",
      "  SingleTop     28587.0      27169.3\n",
      "====================================\n",
      "    Sum(MC)   4166029.0   16088919.3\n",
      "       Data  18207696.0   18207696.0\n"
     ]
    }
   ],
   "source": [
    "# Output some event counts as a result of cuts\n",
    "# ... something is off with my WJets input files\n",
    "sumEvents = 0.0\n",
    "sumRawEvents = 0.0\n",
    "print \"Sample  Raw  Weighted\"\n",
    "for sample in bulkHisto.bins:\n",
    "    if sample == \"SingleMuon\":\n",
    "        continue\n",
    "    events = bulkHisto(sample)('nEvents').sum\n",
    "    rawEvents = bulkHisto(sample)('nRawEvents').sum\n",
    "    print \"%11s   %9.1f  % 11.1f\" % (sample, rawEvents, events)\n",
    "    sumEvents += float(events)\n",
    "    sumRawEvents += float(rawEvents)\n",
    "\n",
    "print \"=\" * 36\n",
    "print \"    Sum(MC)  % 9.1f  % 11.1f\" % (sumRawEvents, sumEvents)\n",
    "print \"       Data % 9.1f  % 11.1f\" % (bulkHisto('SingleMuon')('nRawEvents').sum, bulkHisto('SingleMuon')('nEvents').sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x52e1e90>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEICAYAAACj2qi6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAGdZJREFUeJzt3X+wX3V95/Hnq1AUsZoAaUoTZsOuGTvIrAp3IB07na5sIWDX8Ie1OJ2SslmzO+LWVmfa0M4uU60zONsplR2lw0hK6LgipVqyCqZZtNvZ2QlyUQsCslwRJBl+3BJ+tGWqQt/7x/cT/Xr53ptPYpLzBZ6Pme98z3mfzzmfzz3JzSvnx/d7UlVIktTjx4YegCTpxcPQkCR1MzQkSd0MDUlSN0NDktTN0JAkdTM0pCMgyZ8k+S9Dj0P6UcXPaUiHRpIHgZXA88D3gP8L/KeqenjIcUmHkkca0qH176rq1cBJwGPAfx94PNIhZWhIh0FV/RNwI3AqQJJrk/xBm/6FJLuTfCDJ40keSXLxkOOVehka0mGQ5FXArwC7FmnyU8BrgVXAJuBjSZYfoeFJB+3ooQcgvcT8ZZLngOOAeeDcRdp9D/hgVT0H3JzkH4DXs3jISFPBIw3p0LqgqpYBrwTeC/zvJD81od0TLTD2eRZ49ZEYoPSjMDSkw6Cqnq+qzzC6k+rnhh6PdKgYGtJhkJENwHLg3qHHIx0qXtOQDq3/meR5oICHgI1VdXeSgYclHRp+uE+S1M3TU5KkboaGJKmboSFJ6mZoSJK6veTunjrxxBNrzZo1Qw9Dkl5U7rjjjr+rqhX7a/eSC401a9YwOzs79DAk6UUlyUM97Tw9JUnqZmhIkroZGpKkboaGJKmboSFJ6mZoSJK6GRqSpG6GhiSpm6EhSerW9YnwJL8F/AdGD5a5C7gYOAm4HjgBuAP4tar6bpJXANcBZwBPAL9SVQ+27VwKbGL0CMzfqKodrb4e+ChwFPCJqrq81U+Z1MeP/mNraGu2fH5i/cHL33aERyLpQOz3SCPJKuA3gJmqOo3RP+wXAh8Brqiq1wFPMgoD2vuTrX5Fa0eSU9t6bwDWAx9PclSSo4CPAecBpwLvam1Zog9J0gB6T08dDRyb5GjgVcAjwFuBG9vybcAFbXpDm6ctPzujZ11uAK6vqu9U1beAOeDM9pqrqgfaUcT1wIa2zmJ9SJIGsN/QqKo9wB8C32YUFk8zOlX0VFU915rtBla16VXAw23d51r7E8brC9ZZrH7CEn1IkgbQc3pqOaOjhFOAnwaOY3R6aWok2ZxkNsns/Pz80MORpJesntNT/xb4VlXNV9X3gM8AbwGWtdNVAKuBPW16D3AyQFv+WkYXxL9fX7DOYvUnlujjh1TV1VU1U1UzK1bs9+vgJUkHqSc0vg2sS/Kqdp3hbOAe4EvAO1qbjcBNbXp7m6ct/2JVVatfmOQV7a6otcCXgduBtUlOSXIMo4vl29s6i/UhSRpAzzWN2xhdjP4Ko9ttfwy4Gvgd4P1J5hhdf7imrXINcEKrvx/Y0rZzN3ADo8D5AnBJVT3frlm8F9gB3Avc0NqyRB+SpAFk9B/6l46ZmZnyyX3Tz89pSNMlyR1VNbO/dn4iXJLUzdCQJHUzNCRJ3QwNSVI3Q0OS1M3QkCR1MzQkSd0MDUlSN0NDktTN0JAkdTM0JEndDA1JUjdDQ5LUzdCQJHUzNCRJ3QwNSVI3Q0OS1G2/oZHk9Um+NvZ6JslvJjk+yc4k97f35a19klyZZC7JnUlOH9vWxtb+/iQbx+pnJLmrrXNlexY5i/UhSRpGzzPC76uqN1XVm4AzgGeBzzJ69vetVbUWuLXNA5wHrG2vzcBVMAoA4DLgLOBM4LKxELgKePfYeutbfbE+JEkDONDTU2cD36yqh4ANwLZW3wZc0KY3ANfVyC5gWZKTgHOBnVW1t6qeBHYC69uy11TVrho9sPy6Bdua1IckaQAHGhoXAp9q0yur6pE2/Siwsk2vAh4eW2d3qy1V3z2hvlQfPyTJ5iSzSWbn5+cP8EeSJPXqDo0kxwBvB/584bJ2hFCHcFwvsFQfVXV1Vc1U1cyKFSsO5zAk6WXtQI40zgO+UlWPtfnH2qkl2vvjrb4HOHlsvdWttlR99YT6Un1IkgZwIKHxLn5wagpgO7DvDqiNwE1j9YvaXVTrgKfbKaYdwDlJlrcL4OcAO9qyZ5Ksa3dNXbRgW5P6kCQN4OieRkmOA34R+I9j5cuBG5JsAh4C3tnqNwPnA3OM7rS6GKCq9ib5EHB7a/fBqtrbpt8DXAscC9zSXkv1IUkaQFdoVNU/AicsqD3B6G6qhW0LuGSR7WwFtk6ozwKnTahP7EOSNAw/ES5J6mZoSJK6GRqSpG6GhiSpm6EhSepmaEiSuhkakqRuhoYkqZuhIUnqZmhIkroZGpKkboaGJKlb1xcWSgdrzZbPDz0ESYeQRxqSpG6GhiSpm6EhSerWFRpJliW5Mck3ktyb5GeTHJ9kZ5L72/vy1jZJrkwyl+TOJKePbWdja39/ko1j9TOS3NXWubI99pXF+pAkDaP3SOOjwBeq6meANwL3AluAW6tqLXBrmwc4D1jbXpuBq2AUAMBlwFnAmcBlYyFwFfDusfXWt/pifUiSBrDf0EjyWuDngWsAquq7VfUUsAHY1pptAy5o0xuA62pkF7AsyUnAucDOqtpbVU8CO4H1bdlrqmpXe1TsdQu2NakPSdIAeo40TgHmgT9N8tUkn0hyHLCyqh5pbR4FVrbpVcDDY+vvbrWl6rsn1Fmijx+SZHOS2SSz8/PzHT+SJOlg9ITG0cDpwFVV9WbgH1lwmqgdIdShH15fH1V1dVXNVNXMihUrDucwJOllrSc0dgO7q+q2Nn8joxB5rJ1aor0/3pbvAU4eW391qy1VXz2hzhJ9SJIGsN/QqKpHgYeTvL6VzgbuAbYD++6A2gjc1Ka3Axe1u6jWAU+3U0w7gHOSLG8XwM8BdrRlzyRZ1+6aumjBtib1IUkaQO/XiPxn4JNJjgEeAC5mFDg3JNkEPAS8s7W9GTgfmAOebW2pqr1JPgTc3tp9sKr2tun3ANcCxwK3tBfA5Yv0IUkaQFdoVNXXgJkJi86e0LaASxbZzlZg64T6LHDahPoTk/qQJA3DT4RLkroZGpKkboaGJKmboSFJ6mZoSJK6GRqSpG6GhiSpm6EhSepmaEiSuvV+jYh0RKzZ8vlFlz14+duO4EgkTeKRhiSpm6EhSepmaEiSuhkakqRuhoYkqZuhIUnqZmhIkrp1hUaSB5PcleRrSWZb7fgkO5Pc396Xt3qSXJlkLsmdSU4f287G1v7+JBvH6me07c+1dbNUH5KkYRzIkca/qao3VdW+x75uAW6tqrXArW0e4DxgbXttBq6CUQAAlwFnAWcCl42FwFXAu8fWW7+fPiRJA/hRTk9tALa16W3ABWP162pkF7AsyUnAucDOqtpbVU8CO4H1bdlrqmpXe774dQu2NakPSdIAekOjgL9KckeSza22sqoeadOPAivb9Crg4bF1d7faUvXdE+pL9fFDkmxOMptkdn5+vvNHkiQdqN7vnvq5qtqT5CeBnUm+Mb6wqipJHfrh9fVRVVcDVwPMzMwc1nFI0stZ15FGVe1p748Dn2V0TeKxdmqJ9v54a74HOHls9dWttlR99YQ6S/QhSRrAfkMjyXFJfmLfNHAO8HVgO7DvDqiNwE1tejtwUbuLah3wdDvFtAM4J8nydgH8HGBHW/ZMknXtrqmLFmxrUh+SpAH0nJ5aCXy23QV7NPA/quoLSW4HbkiyCXgIeGdrfzNwPjAHPAtcDFBVe5N8CLi9tftgVe1t0+8BrgWOBW5pL4DLF+lDkjSA/YZGVT0AvHFC/Qng7An1Ai5ZZFtbga0T6rPAab19SJKG4SfCJUndDA1JUjdDQ5LUzdCQJHUzNCRJ3QwNSVI3Q0OS1M3QkCR1MzQkSd0MDUlSN0NDktTN0JAkdTM0JEndDA1JUjdDQ5LUrfcZ4dKS1mz5/NBDkHQEdB9pJDkqyVeTfK7Nn5LktiRzST6d5JhWf0Wbn2vL14xt49JWvy/JuWP19a02l2TLWH1iH5KkYRzI6an3AfeOzX8EuKKqXgc8CWxq9U3Ak61+RWtHklOBC4E3AOuBj7cgOgr4GHAecCrwrtZ2qT4kSQPoCo0kq4G3AZ9o8wHeCtzYmmwDLmjTG9o8bfnZrf0G4Pqq+k5VfYvRM8TPbK+5qnqgqr4LXA9s2E8fkqQB9B5p/DHw28A/t/kTgKeq6rk2vxtY1aZXAQ8DtOVPt/bfry9YZ7H6Un38kCSbk8wmmZ2fn+/8kSRJB2q/oZHkl4DHq+qOIzCeg1JVV1fVTFXNrFixYujhSNJLVs/dU28B3p7kfOCVwGuAjwLLkhzdjgRWA3ta+z3AycDuJEcDrwWeGKvvM77OpPoTS/QhSRrAfo80qurSqlpdVWsYXcj+YlX9KvAl4B2t2Ubgpja9vc3Tln+xqqrVL2x3V50CrAW+DNwOrG13Sh3T+tje1lmsD0nSAH6UD/f9DvD+JHOMrj9c0+rXACe0+vuBLQBVdTdwA3AP8AXgkqp6vh1FvBfYwejurBta26X6kCQN4IA+3FdVfw38dZt+gNGdTwvb/BPwy4us/2HgwxPqNwM3T6hP7EOSNAy/RkSS1M3QkCR1MzQkSd0MDUlSN0NDktTN0JAkdTM0JEndDA1JUjdDQ5LUzdCQJHUzNCRJ3QwNSVI3Q0OS1O2AvuVWGtKaLZ+fWH/w8rcd4ZFIL18eaUiSuhkakqRu+w2NJK9M8uUkf5vk7iS/3+qnJLktyVyST7dHtdIe5/rpVr8tyZqxbV3a6vclOXesvr7V5pJsGatP7EOSNIyeI43vAG+tqjcCbwLWJ1kHfAS4oqpeBzwJbGrtNwFPtvoVrR1JTmX0/O83AOuBjyc5KslRwMeA84BTgXe1tizRhyRpAPsNjRr5hzb74+1VwFuBG1t9G3BBm97Q5mnLz06SVr++qr5TVd8C5hg9yvVMYK6qHqiq7wLXAxvaOov1IUkaQNc1jXZE8DXgcWAn8E3gqap6rjXZDaxq06uAhwHa8qeBE8brC9ZZrH7CEn1IkgbQFRpV9XxVvQlYzejI4GcO66gOUJLNSWaTzM7Pzw89HEl6yTqgu6eq6ingS8DPAsuS7Pucx2pgT5veA5wM0Ja/FnhivL5gncXqTyzRx8JxXV1VM1U1s2LFigP5kSRJB6Dn7qkVSZa16WOBXwTuZRQe72jNNgI3tentbZ62/ItVVa1+Ybu76hRgLfBl4HZgbbtT6hhGF8u3t3UW60OSNICeT4SfBGxrdzn9GHBDVX0uyT3A9Un+APgqcE1rfw3wZ0nmgL2MQoCqujvJDcA9wHPAJVX1PECS9wI7gKOArVV1d9vW7yzShyRpAPsNjaq6E3jzhPoDjK5vLKz/E/DLi2zrw8CHJ9RvBm7u7UOSNAy/e0oHZLHvf5L08uDXiEiSuhkakqRuhoYkqZuhIUnqZmhIkroZGpKkboaGJKmboSFJ6mZoSJK6GRqSpG6GhiSpm6EhSepmaEiSuhkakqRuhoYkqZuhIUnq1vOM8JOTfCnJPUnuTvK+Vj8+yc4k97f35a2eJFcmmUtyZ5LTx7a1sbW/P8nGsfoZSe5q61yZJEv1IUkaRs+T+54DPlBVX0nyE8AdSXYCvw7cWlWXJ9kCbGH0TO/zgLXtdRZwFXBWkuOBy4AZoNp2tlfVk63Nu4HbGD32dT1wS9vmpD6k71vsaYIPXv62IzwS6aVvv0caVfVIVX2lTf89cC+wCtgAbGvNtgEXtOkNwHU1sgtYluQk4FxgZ1XtbUGxE1jflr2mqnZVVQHXLdjWpD4kSQM4oGsaSdYAb2Z0RLCyqh5pix4FVrbpVcDDY6vtbrWl6rsn1Fmij4Xj2pxkNsns/Pz8gfxIkqQD0B0aSV4N/AXwm1X1zPiydoRQh3hsP2SpPqrq6qqaqaqZFStWHM5hSNLLWldoJPlxRoHxyar6TCs/1k4t0d4fb/U9wMljq69utaXqqyfUl+pDkjSAnrunAlwD3FtVfzS2aDuw7w6ojcBNY/WL2l1U64Cn2ymmHcA5SZa3u6DOAXa0Zc8kWdf6umjBtib1IUkaQM/dU28Bfg24K8nXWu13gcuBG5JsAh4C3tmW3QycD8wBzwIXA1TV3iQfAm5v7T5YVXvb9HuAa4FjGd01dUurL9aHJGkA+w2Nqvo/QBZZfPaE9gVcssi2tgJbJ9RngdMm1J+Y1IckaRh+IlyS1M3QkCR1MzQkSd16LoTrZWixr+aQ9PLmkYYkqZuhIUnqZmhIkroZGpKkboaGJKmboSFJ6uYtt3rJ8ol+0qHnkYYkqZuhIUnqZmhIkroZGpKkboaGJKlbz+NetyZ5PMnXx2rHJ9mZ5P72vrzVk+TKJHNJ7kxy+tg6G1v7+5NsHKufkeSuts6V7ZGvi/YhSRpOz5HGtcD6BbUtwK1VtRa4tc0DnAesba/NwFUwCgDgMuAs4EzgsrEQuAp499h66/fThyRpIPsNjar6G2DvgvIGYFub3gZcMFa/rkZ2AcuSnAScC+ysqr1V9SSwE1jflr2mqna1x8Ret2Bbk/qQJA3kYK9prKyqR9r0o8DKNr0KeHis3e5WW6q+e0J9qT5eIMnmJLNJZufn5w/ix5Ek9fiRPxFeVZWkDsVgDraPqroauBpgZmbmsI5FL35+Ulw6eAd7pPFYO7VEe3+81fcAJ4+1W91qS9VXT6gv1YckaSAHGxrbgX13QG0EbhqrX9TuoloHPN1OMe0AzkmyvF0APwfY0ZY9k2Rdu2vqogXbmtSHJGkg+z09leRTwC8AJybZzeguqMuBG5JsAh4C3tma3wycD8wBzwIXA1TV3iQfAm5v7T5YVfsurr+H0R1axwK3tBdL9CFJGsh+Q6Oq3rXIorMntC3gkkW2sxXYOqE+C5w2of7EpD4kScPxE+GSpG6GhiSpm6EhSermk/ukxs9vSPvnkYYkqZuhIUnq5umpl7nFTslI0iQeaUiSunmkIe2HF8ilH/BIQ5LUzdCQJHXz9JR0kDxtpZcjjzQkSd0MDUlSN09PSYeYp630UmZoSEeIYaKXAkNDGphhoheTqQ+NJOuBjwJHAZ+oqssHHpJ0RBzMV7wYNDrcpjo0khwFfAz4RWA3cHuS7VV1z7Ajk6bT4f4uMUNJUx0awJnAXFU9AJDkemADYGhIA/ALLg/eSyVwpz00VgEPj83vBs5a2CjJZmBzm/2HJPcdgr5PBP7uEGzncJr2MU77+GD6xzjt4wPH2CUfWXLx4OMD/kVPo2kPjS5VdTVw9aHcZpLZqpo5lNs81KZ9jNM+Ppj+MU77+MAxHgrTPr5x0/7hvj3AyWPzq1tNkjSAaQ+N24G1SU5JcgxwIbB94DFJ0svWVJ+eqqrnkrwX2MHoltutVXX3Eer+kJ7uOkymfYzTPj6Y/jFO+/jAMR4K0z6+70tVDT0GSdKLxLSfnpIkTRFDQ5LUzdCYIMn6JPclmUuyZQrGc3KSLyW5J8ndSd7X6scn2Znk/va+fOBxHpXkq0k+1+ZPSXJb24+fbjczDDm+ZUluTPKNJPcm+dkp3Ie/1f6Mv57kU0leOfR+TLI1yeNJvj5Wm7jfMnJlG+udSU4faHz/rf0535nks0mWjS27tI3vviTnHu7xLTbGsWUfSFJJTmzzR3wfHghDY4Gxry45DzgVeFeSU4cdFc8BH6iqU4F1wCVtTFuAW6tqLXBrmx/S+4B7x+Y/AlxRVa8DngQ2DTKqH/go8IWq+hngjYzGOjX7MMkq4DeAmao6jdHNHxcy/H68Fli/oLbYfjsPWNtem4GrBhrfTuC0qvrXwP8DLgVovzcXAm9o63y8/c4PMUaSnAycA3x7rDzEPuxmaLzQ97+6pKq+C+z76pLBVNUjVfWVNv33jP6xW9XGta012wZcMMwIIclq4G3AJ9p8gLcCN7YmQ4/vtcDPA9cAVNV3q+oppmgfNkcDxyY5GngV8AgD78eq+htg74LyYvttA3BdjewCliU56UiPr6r+qqqea7O7GH3Ga9/4rq+q71TVt4A5Rr/zh9Ui+xDgCuC3gfE7ko74PjwQhsYLTfrqklUDjeUFkqwB3gzcBqysqkfaokeBlQMNC+CPGf3l/+c2fwLw1Ngv7tD78RRgHvjTdgrtE0mOY4r2YVXtAf6Q0f86HwGeBu5guvbjPovtt2n8/fn3wC1temrGl2QDsKeq/nbBoqkZ4ySGxotIklcDfwH8ZlU9M76sRvdOD3L/dJJfAh6vqjuG6L/T0cDpwFVV9WbgH1lwKmrIfQjQrgtsYBRwPw0cx4RTGtNm6P22lCS/x+j07ieHHsu4JK8Cfhf4r0OP5UAZGi80lV9dkuTHGQXGJ6vqM6382L7D1vb++EDDewvw9iQPMjqd91ZG1w+WtdMsMPx+3A3srqrb2vyNjEJkWvYhwL8FvlVV81X1PeAzjPbtNO3HfRbbb1Pz+5Pk14FfAn61fvCBtGkZ379i9J+Dv22/N6uBryT5KaZnjBMZGi80dV9d0q4PXAPcW1V/NLZoO7CxTW8EbjrSYwOoqkuranVVrWG0v75YVb8KfAl4x9DjA6iqR4GHk7y+lc5m9BX7U7EPm28D65K8qv2Z7xvj1OzHMYvtt+3ARe0OoHXA02OnsY6YjB7e9tvA26vq2bFF24ELk7wiySmMLjZ/+UiPr6ruqqqfrKo17fdmN3B6+3s6FftwUVXla8ELOJ/RHRffBH5vCsbzc4wO/+8EvtZe5zO6bnArcD/wv4Djp2CsvwB8rk3/S0a/kHPAnwOvGHhsbwJm2378S2D5tO1D4PeBbwBfB/4MeMXQ+xH4FKNrLN9j9I/bpsX2GxBGdx9+E7iL0Z1gQ4xvjtF1gX2/L38y1v732vjuA84bah8uWP4gcOJQ+/BAXn6NiCSpm6enJEndDA1JUjdDQ5LUzdCQJHUzNCRJ3QwNSVI3Q0OS1O3/A49c4CjEhWIUAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x52e1d50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bulkHisto('DYJets')('LeadPt').plot.matplotlib()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x52e1d90>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x4b90d10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bulkHisto('DYJets')('SecondPt').plot.matplotlib()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you would like access to Vanderbilt's Spark cluster (with access to these datasets), contact Andrew Melo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZMAAAEICAYAAACavRnhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAGbRJREFUeJzt3XuQpXV95/H3R25RUblNEGFwUCfZRXcD2IFJRVNGDAxgHNy1XKisjC7rmAi7WmtKR60IXpJANsqGWiSBZcJgUMDbMgkYJMjGcjdcGuSOSItDMeMAI8PFBAsFv/vH+TUe2u7pyzNzzvTM+1V1qp/zfX7P8/v106fPp5/LeTpVhSRJXTxv2AOQJM1/hokkqTPDRJLUmWEiSerMMJEkdWaYSJI6M0ykaSRZlKSS7Nyefy3J8mGPS9qWGCaa15KsTfKmQfZZVcdU1epB9rktS3J6kr8Z9jg0XIaJJKkzw0TbrSRvTnJLkseS/L8k/7Zv3sok30vyoyR3JXlr37ydkvx5kh8muQ84bsJ6/0+S/9ym35nkW639o0m+n+SYvrYHJflm6+cfkpwz1V/xSd6QZF2SDyZ5OMmGJMcnOTbJd5NsSvKRvvYXJvnUxOX7nv/rNtbHktyZ5C0Tlj0nyRVtbNcneeUU4xo/zLciyQ/auP6wzVsKfAT4D0n+OcmtM/jRaDtkmGi7lORQYBXwHmBv4K+ANUl2a02+B7weeAnwceBvkuzX5r0beDNwKDACvG2a7o4A7gH2Af4MuCBJ2rzPAze0MZwOvGOadb0U+CVgf+BjwPnAfwRe28b7R0kOmmYdJNkF+Fvg68AvA/8FuDjJr/Y1O4He974nMAb88TSr/W1gMXAU8KEkb6qqvwf+BLi0qnavql+bbmzaPhkm2l6tAP6qqq6vqmfaOY6ngCUAVfXFqvpBVf2sqi4F7gUOb8u+HfgfVfVAVW0C/nSavu6vqvOr6hlgNbAfsG+SA4FfBz5WVT+pqm8Ba6ZZ10+BP66qnwKX0Auov6iqH1XVncBdwEzesJcAuwNntL6/AfwdcGJfm69W1Q1V9TRwMXDINOv8eFX9S1XdDvz1hHVpB2eYaHv1cuAD7RDPY0keAxYCLwNIclLfIbDHgNfQe+OmtXmgb133T9PXg+MTVfVkm9y9rWdTX40J653MIy2UAH7cvj7UN//Hbd3TeRnwQFX9rK92P709nl8YN/DkDNY7cZu8bAbj0A7CMNH26gF6f+Hv0fd4QVV9IcnL6R0+OhXYu6r2AO4Axg9NbaAXPOMOnOMYNgB7JXlBX23hVI3n4F+A/nW/tG/6B8DCJP2/4wcC6zv0N3Gb/KBNe+txGSbaLuyS5Jf6HjvTC4vfT3JEel6Y5LgkLwJeSO8NcCNAknfR2zMZdxnwX5MckGRPYOVcBlVV9wOjwOlJdk3yG8Dvzv3b/AW3AMcm2SvJS4H39827nt7exgeT7JLkDa3vSzr090dJXpDk1cC7gEtb/SFg0YTg0g7GH762B1fSO/wz/ji9qkbpnUj/n8Cj9E4wvxOgqu4CPg38E703wn8D/N++9Z0PXAXcCtwMfKXD2H4P+A3gEeBT9N6An+qwvn6fozfGtfROtI+/uVNVP6EXHscAPwQ+C5xUVd/p0N8/0tuO1wB/XlVfb/Uvtq+PJLm5w/o1j8V/jiUNTpJLge9U1WnDHstMJVkEfB/YpZ2sl36BeybSVpTk15O8Msnz2mcylgH/e9jjkra0nYc9AGk791J6h8n2BtYBf1BV3x7ukKQtb9o9k3ZC84Ykt7ZP0X681Q9qn5odS3Jpkl1bfbf2fKzNX9S3rg+3+j1Jju6rL221sSQr++qz7kPallTV31bVwnYl2a9U1V8Pe0yzVVVrqyoe4tLmzOQw11PAG9snWw8BliZZApwJnFVVr6J3gvPk1v5k4NFWP6u1I8nB9D5x+2pgKfDZ9G5bsRNwDr0ThQcDJ7a2zLYPSdJwzOoEfLte/lvAHwBXAC+tqqfbJY+nV9XRSa5q0//ULtF8EFhAu7yyqv60resqereXYHzZVv9wq51B79LNGfdRm/lm9tlnn1q0aNGMv1dJEtx0000/rKoF07Wb0TmTtvdwE/AqensR3wMe69vtXcfPP1m7P+2Tsi0EHqd3vHh/4Lq+1fYv88CE+hFtmdn28cMJ415B77YaHHjggYyOjs7k25UkNUmmuwMEMMOrudq9jQ4BDqB3/6J/1WFsA1NV51XVSFWNLFgwbbBKkuZoVpcGV9VjwLX0PoS1RzvEBL2QGb9Nw3rabRfa/JfQ+8DWs/UJy0xVf2QOfUiShmAmV3MtSLJHm34+8DvA3fRCZfzW3MuBy9v0mvacNv8b7VzGGuCEdiXWQfRuZX0DcCOwuF25tSu9k/Rr2jKz7UOSNAQzOWeyH7C6nTd5HnBZVf1dkruAS9L75zzfBi5o7S8APpdkDNhELxyoqjuTXEbvFtpPA6eM3x01yan0bl+xE7Cq3Wob4EOz6UOSNBw7zO1URkZGyhPwkjQ7SW6qqpHp2nk7FUlSZ4aJJKkzw0SS1JlhIknqzLsGa84Wrbzi2em1Zxw3xJFIGjb3TCRJnRkmkqTOPMylWek/tCVJ49wzkSR1ZphIkjozTCRJnRkmkqTODBNJUmeGiSSpM8NEktSZYSJJ6swwkSR1ZphIkjozTCRJnRkmkqTODBNJUmeGiSSpM8NEktSZYSJJ6swwkSR1ZphIkjozTCRJnU0bJkkWJrk2yV1J7kzyvlY/Pcn6JLe0x7F9y3w4yViSe5Ic3Vdf2mpjSVb21Q9Kcn2rX5pk11bfrT0fa/MXTdeHJGnwZrJn8jTwgao6GFgCnJLk4DbvrKo6pD2uBGjzTgBeDSwFPptkpyQ7AecAxwAHAyf2refMtq5XAY8CJ7f6ycCjrX5WazdlH3PeCpKkTqYNk6raUFU3t+kfAXcD+29mkWXAJVX1VFV9HxgDDm+Psaq6r6p+AlwCLEsS4I3Al9ryq4Hj+9a1uk1/CTiytZ+qD0nSEMzqnEk7zHQocH0rnZrktiSrkuzZavsDD/Qttq7VpqrvDTxWVU9PqD9nXW3+4639VOuaON4VSUaTjG7cuHE236okaRZmHCZJdge+DLy/qp4AzgVeCRwCbAA+vVVG2EFVnVdVI1U1smDBgmEPR5K2WzMKkyS70AuSi6vqKwBV9VBVPVNVPwPO5+eHmdYDC/sWP6DVpqo/AuyRZOcJ9eesq81/SWs/1bokSUMwk6u5AlwA3F1Vn+mr79fX7K3AHW16DXBCuxLrIGAxcANwI7C4Xbm1K70T6GuqqoBrgbe15ZcDl/eta3mbfhvwjdZ+qj4kSUOw8/RN+E3gHcDtSW5ptY/QuxrrEKCAtcB7AKrqziSXAXfRuxLslKp6BiDJqcBVwE7Aqqq6s63vQ8AlST4FfJteeNG+fi7JGLCJXgBttg9J0uCl94f+9m9kZKRGR0eHPYx5b9HKKyatrz3juAGPRNIgJLmpqkama+cn4CVJnRkmkqTODBNJUmeGiSSpM8NEktSZYSJJ6swwkSR1ZphIkjozTCRJnRkmkqTODBNJUmeGiSSpM8NEktSZYSJJ6swwkSR1ZphIkjozTCRJnRkmkqTODBNJUmeGiSSpM8NEktSZYSJJ6mznYQ9A275FK68Y9hAkbeMME20REwNn7RnHDWkkkobBw1ySpM4ME0lSZ4aJJKmzacMkycIk1ya5K8mdSd7X6nsluTrJve3rnq2eJGcnGUtyW5LD+ta1vLW/N8nyvvprk9zeljk7SebahyRp8GayZ/I08IGqOhhYApyS5GBgJXBNVS0GrmnPAY4BFrfHCuBc6AUDcBpwBHA4cNp4OLQ27+5bbmmrz6oPSdJwTBsmVbWhqm5u0z8C7gb2B5YBq1uz1cDxbXoZcFH1XAfskWQ/4Gjg6qraVFWPAlcDS9u8F1fVdVVVwEUT1jWbPiRJQzCrcyZJFgGHAtcD+1bVhjbrQWDfNr0/8EDfYutabXP1dZPUmUMfE8e7IsloktGNGzfO7JuUJM3ajMMkye7Al4H3V9UT/fPaHkVt4bE9x1z6qKrzqmqkqkYWLFiwlUYmSZpRmCTZhV6QXFxVX2nlh8YPLbWvD7f6emBh3+IHtNrm6gdMUp9LH5KkIZjJ1VwBLgDurqrP9M1aA4xfkbUcuLyvflK74moJ8Hg7VHUVcFSSPduJ96OAq9q8J5IsaX2dNGFds+lDkjQEM7mdym8C7wBuT3JLq30EOAO4LMnJwP3A29u8K4FjgTHgSeBdAFW1KckngRtbu09U1aY2/V7gQuD5wNfag9n2IUkajmnDpKq+BWSK2UdO0r6AU6ZY1ypg1ST1UeA1k9QfmW0fkqTB8xPwkqTODBNJUmeGiSSpM8NEktSZYSJJ6swwkSR1ZphIkjozTCRJnRkmkqTODBNJUmeGiSSpM8NEktSZYSJJ6swwkSR1ZphIkjozTCRJnRkmkqTODBNJUmeGiSSpM8NEktSZYSJJ6swwkSR1tvOwB6Bt06KVVwx7CJLmEfdMJEmdGSaSpM4ME0lSZ4aJJKmzacMkyaokDye5o692epL1SW5pj2P75n04yViSe5Ic3Vdf2mpjSVb21Q9Kcn2rX5pk11bfrT0fa/MXTdeHJGk4ZrJnciGwdJL6WVV1SHtcCZDkYOAE4NVtmc8m2SnJTsA5wDHAwcCJrS3AmW1drwIeBU5u9ZOBR1v9rNZuyj5m921LkrakacOkqr4JbJrh+pYBl1TVU1X1fWAMOLw9xqrqvqr6CXAJsCxJgDcCX2rLrwaO71vX6jb9JeDI1n6qPiRJQ9LlcyanJjkJGAU+UFWPAvsD1/W1WddqAA9MqB8B7A08VlVPT9J+//FlqurpJI+39pvr4zmSrABWABx44IFz+BY1V/2fU1l7xnFDHImkQZjrCfhzgVcChwAbgE9vsRFtQVV1XlWNVNXIggULhj0cSdpuzSlMquqhqnqmqn4GnM/PDzOtBxb2NT2g1aaqPwLskWTnCfXnrKvNf0lrP9W6JElDMqcwSbJf39O3AuNXeq0BTmhXYh0ELAZuAG4EFrcrt3aldwJ9TVUVcC3wtrb8cuDyvnUtb9NvA77R2k/VhyRpSKY9Z5LkC8AbgH2SrANOA96Q5BCggLXAewCq6s4klwF3AU8Dp1TVM209pwJXATsBq6rqztbFh4BLknwK+DZwQatfAHwuyRi9CwBOmK4PSdJwpPfH/vZvZGSkRkdHhz2MeWNL3ujRE/DS/JXkpqoama6dn4CXJHVmmEiSOjNMJEmdGSaSpM4ME0lSZ4aJJKkzw0SS1JlhIknqzDCRJHVmmEiSOjNMJEmdGSaSpM66/KdFbWe25M0dJe1Y3DORJHVmmEiSOjNMJEmdGSaSpM4ME0lSZ4aJJKkzw0SS1JlhIknqzDCRJHVmmEiSOvN2Ktrq+m/TsvaM44Y4Eklbi3smkqTODBNJUmeGiSSps2nDJMmqJA8nuaOvtleSq5Pc277u2epJcnaSsSS3JTmsb5nlrf29SZb31V+b5Pa2zNlJMtc+JEnDMZM9kwuBpRNqK4FrqmoxcE17DnAMsLg9VgDnQi8YgNOAI4DDgdPGw6G1eXffckvn0ockaXimDZOq+iawaUJ5GbC6Ta8Gju+rX1Q91wF7JNkPOBq4uqo2VdWjwNXA0jbvxVV1XVUVcNGEdc2mD0nSkMz1nMm+VbWhTT8I7Num9wce6Gu3rtU2V183SX0ufUiShqTzCfi2R1FbYCxbvI8kK5KMJhnduHHjVhiZJAnmHiYPjR9aal8fbvX1wMK+dge02ubqB0xSn0sfv6CqzquqkaoaWbBgway+QUnSzM01TNYA41dkLQcu76uf1K64WgI83g5VXQUclWTPduL9KOCqNu+JJEvaVVwnTVjXbPqQJA3JtLdTSfIF4A3APknW0bsq6wzgsiQnA/cDb2/NrwSOBcaAJ4F3AVTVpiSfBG5s7T5RVeMn9d9L74qx5wNfaw9m24fmpv9WJ5I0V9OGSVWdOMWsIydpW8ApU6xnFbBqkvoo8JpJ6o/Mtg9J0nD4CXhJUmeGiSSpM8NEktSZYSJJ6swwkSR1ZphIkjozTCRJnfk/4DVQ/j94afvknokkqTPDRJLUmWEiSerMMJEkdWaYSJI6M0wkSZ0ZJpKkzgwTSVJnhokkqTPDRJLUmbdT2QH5f98lbWnumUiSOnPPREPjTR+l7Yd7JpKkzgwTSVJnhokkqTPDRJLUmWEiSerMMJEkdWaYSJI66xQmSdYmuT3JLUlGW22vJFcnubd93bPVk+TsJGNJbktyWN96lrf29yZZ3ld/bVv/WFs2m+tDkjQcW2LP5Ler6pCqGmnPVwLXVNVi4Jr2HOAYYHF7rADOhV4wAKcBRwCHA6f1hcO5wLv7lls6TR+SpCHYGoe5lgGr2/Rq4Pi++kXVcx2wR5L9gKOBq6tqU1U9ClwNLG3zXlxV11VVARdNWNdkfWieWrTyimcfkuafrmFSwNeT3JRkRavtW1Ub2vSDwL5ten/ggb5l17Xa5urrJqlvro/nSLIiyWiS0Y0bN876m5MkzUzXe3O9rqrWJ/ll4Ook3+mfWVWVpDr2sVmb66OqzgPOAxgZGdmq45CkHVmnPZOqWt++Pgx8ld45j4faISra14db8/XAwr7FD2i1zdUPmKTOZvqQJA3BnMMkyQuTvGh8GjgKuANYA4xfkbUcuLxNrwFOald1LQEeb4eqrgKOSrJnO/F+FHBVm/dEkiXtKq6TJqxrsj4kSUPQ5TDXvsBX29W6OwOfr6q/T3IjcFmSk4H7gbe39lcCxwJjwJPAuwCqalOSTwI3tnafqKpNbfq9wIXA84GvtQfAGVP0IUkagjmHSVXdB/zaJPVHgCMnqRdwyhTrWgWsmqQ+Crxmpn1IkobDf46lbY7/NEuafwyTHYSf35C0NXlvLklSZ4aJJKkzw0SS1JlhIknqzBPw2qZ5ZZc0P7hnIknqzDCRJHVmmEiSOjNMJEmdeQJe84Yn46Vtl3smkqTODBNJUmce5tK85CEvadvinokkqTPDRJLUmYe5NO95yEsaPvdMJEmduWei7Yp7KdJwGCbbMf9Vr6RBMUy03XIvRRocw0Q7BINF2roME+1wDBZpyzNMtEMzWKQtwzCRmqkuWDBkpOkZJtI0DBlpevM6TJIsBf4C2An4X1V1xpCHpB3IXC69NoC0vZq3YZJkJ+Ac4HeAdcCNSdZU1V3DHZk0ta392R/DSsMyb8MEOBwYq6r7AJJcAiwDDBPtsPyg6uwYvlvOfA6T/YEH+p6vA47ob5BkBbCiPf3nJPd07HMf4Icd17E1OK7ZcVyzs92OK2duoZE81/a2vV4+k0bzOUymVVXnAedtqfUlGa2qkS21vi3Fcc2O45odxzU7O+q45vNdg9cDC/ueH9BqkqQBm89hciOwOMlBSXYFTgDWDHlMkrRDmreHuarq6SSnAlfRuzR4VVXduZW73WKHzLYwxzU7jmt2HNfs7JDjSlVtzfVLknYA8/kwlyRpG2GYSJI6M0xmIMnSJPckGUuycojjWJjk2iR3Jbkzyfta/fQk65Pc0h7HDml8a5Pc3sYw2mp7Jbk6yb3t654DHtOv9m2XW5I8keT9w9hmSVYleTjJHX21SbdPes5ur7nbkhw24HH99yTfaX1/Nckerb4oyY/7tttfDnhcU/7ckny4ba97khw94HFd2jemtUluafVBbq+p3h8G8xqrKh+bedA7uf894BXArsCtwMFDGst+wGFt+kXAd4GDgdOBP9wGttVaYJ8JtT8DVrbplcCZQ/5ZPkjvQ1gD32bAbwGHAXdMt32AY4GvAQGWANcPeFxHATu36TP7xrWov90QttekP7f2e3ArsBtwUPud3WlQ45ow/9PAx4awvaZ6fxjIa8w9k+k9e9uWqvoJMH7bloGrqg1VdXOb/hFwN707AWzLlgGr2/Rq4PghjuVI4HtVdf8wOq+qbwKbJpSn2j7LgIuq5zpgjyT7DWpcVfX1qnq6Pb2O3ue4BmqK7TWVZcAlVfVUVX0fGKP3uzvQcSUJ8HbgC1uj783ZzPvDQF5jhsn0Jrtty9DfwJMsAg4Frm+lU9uu6qpBH0rqU8DXk9yU3q1sAPatqg1t+kFg3+EMDeh9Fqn/l3xb2GZTbZ9t6XX3n+j9BTvuoCTfTvKPSV4/hPFM9nPbVrbX64GHqurevtrAt9eE94eBvMYMk3koye7Al4H3V9UTwLnAK4FDgA30drOH4XVVdRhwDHBKkt/qn1m9feuhXIue3gdb3wJ8sZW2lW32rGFun6kk+SjwNHBxK20ADqyqQ4H/Bnw+yYsHOKRt7uc2wYk89w+WgW+vSd4fnrU1X2OGyfS2qdu2JNmF3gvl4qr6CkBVPVRVz1TVz4Dz2Uq799OpqvXt68PAV9s4HhrfdW5fHx7G2OgF3M1V9VAb4zaxzZh6+wz9dZfkncCbgd9rb0K0w0iPtOmb6J2b+JVBjWkzP7dtYXvtDPw74NLx2qC312TvDwzoNWaYTG+buW1LOx57AXB3VX2mr95/nPOtwB0Tlx3A2F6Y5EXj0/RO4N5Bb1stb82WA5cPemzNc/5i3Ba2WTPV9lkDnNSuuFkCPN53qGKrS+8fz30QeEtVPdlXX5De/xIiySuAxcB9AxzXVD+3NcAJSXZLclAb1w2DGlfzJuA7VbVuvDDI7TXV+wODeo0N4iqD+f6gd9XDd+n9VfHRIY7jdfR2UW8DbmmPY4HPAbe3+hpgvyGM7RX0rqa5FbhzfDsBewPXAPcC/wDsNYSxvRB4BHhJX23g24xemG0Afkrv+PTJU20felfYnNNec7cDIwMe1xi94+njr7O/bG3/ffv53gLcDPzugMc15c8N+GjbXvcAxwxyXK1+IfD7E9oOcntN9f4wkNeYt1ORJHXmYS5JUmeGiSSpM8NEktSZYSJJ6swwkSR1ZphIkjozTCRJnf1/QlfKc6AMKmsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f74cc1fd850>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "h1 = passMuDF.Bin(100, 0, 200, passMuDF['muSel.pt1'])\n",
    "ax = h1.plot.matplotlib(name=\"Leading muon pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'plot': <histogrammar.util.PlotMethod object at 0x596fed0>, 'nanflow': <Count 0.0>, '_checkedForCrossReferences': False, 'underflow': <Count 0.0>, 'high': 200.0, 'values': [<Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 134293.0>, <Count 404043.0>, <Count 674315.0>, <Count 949888.0>, <Count 1252243.0>, <Count 1613596.0>, <Count 2108791.0>, <Count 2826722.0>, <Count 2866933.0>, <Count 2103426.0>, <Count 1502237.0>, <Count 1101942.0>, <Count 833469.0>, <Count 645576.0>, <Count 510146.0>, <Count 406379.0>, <Count 328717.0>, <Count 266987.0>, <Count 215985.0>, <Count 175730.0>, <Count 144474.0>, <Count 121096.0>, <Count 102361.0>, <Count 89062.0>, <Count 78551.0>, <Count 69318.0>, <Count 61972.0>, <Count 55745.0>, <Count 50076.0>, <Count 45256.0>, <Count 41292.0>, <Count 38015.0>, <Count 34505.0>, <Count 31820.0>, <Count 29450.0>, <Count 27159.0>, <Count 24673.0>, <Count 23343.0>, <Count 21614.0>, <Count 20224.0>, <Count 18589.0>, <Count 17522.0>, <Count 16188.0>, <Count 15104.0>, <Count 14399.0>, <Count 13374.0>, <Count 12265.0>, <Count 11482.0>, <Count 10932.0>, <Count 10402.0>, <Count 9751.0>, <Count 9101.0>, <Count 8658.0>, <Count 8037.0>, <Count 7746.0>, <Count 7170.0>, <Count 6915.0>, <Count 6380.0>, <Count 6059.0>, <Count 5718.0>, <Count 5504.0>, <Count 5200.0>, <Count 5054.0>, <Count 4680.0>, <Count 4428.0>, <Count 4175.0>, <Count 4029.0>, <Count 3820.0>, <Count 3630.0>, <Count 3443.0>, <Count 3377.0>, <Count 3213.0>, <Count 2988.0>, <Count 2823.0>, <Count 2684.0>, <Count 2668.0>, <Count 2423.0>, <Count 2320.0>, <Count 2256.0>, <Count 2164.0>, <Count 2105.0>, <Count 1968.0>, <Count 1863.0>, <Count 1836.0>, <Count 1694.0>], 'low': 0.0, 'entries': 22373725.0, 'overflow': <Count 46164.0>, 'fill': <histogrammar.util.FillMethod object at 0x596fe90>, 'quantity': UserFcn(None, muSel.pt1 AS `pt1`)}\n",
      "{'plot': <histogrammar.util.PlotMethod object at 0x504efd0>, 'nanflow': <Count 0.0>, '_checkedForCrossReferences': False, 'underflow': <Count 0.0>, 'high': 150.0, 'values': [<Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 0.0>, <Count 53441.0>, <Count 162822.0>, <Count 277685.0>, <Count 415750.0>, <Count 628894.0>, <Count 815244.0>, <Count 544265.0>, <Count 327052.0>, <Count 208340.0>, <Count 138632.0>, <Count 96220.0>, <Count 67919.0>, <Count 47511.0>, <Count 33208.0>, <Count 24277.0>, <Count 18415.0>, <Count 14626.0>, <Count 11951.0>, <Count 9876.0>, <Count 8314.0>, <Count 7150.0>, <Count 6019.0>, <Count 5199.0>, <Count 4839.0>, <Count 4108.0>, <Count 3640.0>, <Count 3267.0>, <Count 2927.0>, <Count 2558.0>, <Count 2333.0>, <Count 2039.0>, <Count 1852.0>, <Count 1704.0>, <Count 1576.0>, <Count 1476.0>, <Count 1292.0>, <Count 1172.0>, <Count 1114.0>, <Count 992.0>, <Count 895.0>], 'low': 0.0, 'entries': 3974396.0, 'overflow': <Count 13802.0>, 'fill': <histogrammar.util.FillMethod object at 0x5109290>, 'quantity': UserFcn(None, muSel.pt1 AS `pt1`)}\n"
     ]
    }
   ],
   "source": [
    "print h1.__dict__\n",
    "print bulkHisto('DYJets')('LeadPt').__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}