{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Coffea-Casa Benchmark Example 8" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "%matplotlib inline\n", "import hist\n", "import coffea.processor as processor\n", "import awkward as ak\n", "from coffea.nanoevents import schemas" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# This program plots the transverse mass of MET and a third lepton, where the third lepton is associated with a lepton pair\n", "# that has the same flavor, opposite charge, and closest mass to 91.2.\n", "\n", "import math\n", "\n", "class Processor(processor.ProcessorABC):\n", " def __init__(self):\n", " dataset_axis = hist.axis.StrCategory(name=\"dataset\", label=\"\", categories=[], growth=True)\n", " muon_axis = hist.axis.Regular(name=\"massT\", label=\"Transverse Mass [GeV]\", bins=50, start=15, stop=250)\n", " \n", " self.output = processor.dict_accumulator({\n", " 'massT': hist.Hist(dataset_axis, muon_axis),\n", " 'cutflow': processor.defaultdict_accumulator(int)\n", " })\n", " \n", " def process(self, events):\n", " dataset = events.metadata[\"dataset\"]\n", " \n", " # Keep track of muons and electrons by tagging them 0/1.\n", " muons = ak.with_field(events.Muon, 0, 'flavor')\n", " electrons = ak.with_field(events.Electron, 1, 'flavor')\n", " MET = events.MET\n", " \n", " self.output['cutflow']['all events'] += ak.size(events.MET, axis=0)\n", " \n", " # A few reasonable muon and electron selection cuts\n", " muons = muons[(muons.pt > 10) & (np.abs(muons.eta) < 2.4)]\n", " electrons = electrons[(electrons.pt > 10) & (np.abs(electrons.eta) < 2.5)]\n", " \n", " self.output['cutflow']['all muons'] += ak.sum(ak.count(muons, axis=1))\n", " self.output['cutflow']['all electrons'] += ak.sum(ak.count(electrons, axis=1))\n", "\n", " # Stack muons and electrons into a single array.\n", " leptons = ak.with_name(ak.concatenate([muons, electrons], axis=1), 'PtEtaPhiMCandidate')\n", " \n", " # Filter out events with less than 3 leptons.\n", " trileptons = leptons[ak.num(leptons, axis=1) >= 3]\n", " self.output['cutflow']['trileptons'] += ak.sum(ak.num(trileptons, axis=1))\n", " \n", " # Generate the indices of every pair; indices because we'll be removing these elements later.\n", " lepton_pairs = ak.argcombinations(trileptons, 2, fields=['i0', 'i1'])\n", " \n", " # Select pairs that are SFOS.\n", " SFOS_pairs = lepton_pairs[(trileptons[lepton_pairs['i0']].flavor == trileptons[lepton_pairs['i1']].flavor) & (trileptons[lepton_pairs['i0']].charge != trileptons[lepton_pairs['i1']].charge)]\n", " \n", " # Find the pair with mass closest to Z.\n", " closest_pairs = SFOS_pairs[ak.local_index(SFOS_pairs) == ak.argmin(np.abs((trileptons[SFOS_pairs['i0']] + trileptons[SFOS_pairs['i1']]).mass - 91.2), axis=1)]\n", " \n", " # Make trileptons and closest_pairs have same shape. First, fill nones with empty arrays. Then filter out events that don't meet the pair requirement.\n", " closest_pairs = ak.fill_none(closest_pairs, [], axis=0)\n", " closest_pairs = closest_pairs[ak.num(closest_pairs) > 0]\n", " trileptons = trileptons[ak.num(closest_pairs) > 0]\n", " MET = MET[ak.num(closest_pairs) > 0]\n", " \n", " # Remove elements of the closest pairs from leptons, because we want the pt of the third lepton.\n", " trileptons_no_pair = trileptons[(ak.local_index(trileptons) != ak.flatten(closest_pairs.i0)) & (ak.local_index(trileptons) != ak.flatten(closest_pairs.i1))]\n", " \n", " # Find the highest-pt lepton out of the ones that remain.\n", " leading_lepton = trileptons_no_pair[ak.argmax(trileptons_no_pair.pt, axis=1)]\n", " self.output['cutflow']['number of final leading leptons'] += ak.sum(ak.num(trileptons_no_pair, axis=1))\n", " \n", " # Cross MET with the leading lepton.\n", " met_plus_lep = ak.cartesian({'i0': MET, 'i1': leading_lepton})\n", " \n", " # Do some math to get what we want.\n", " dphi_met_lep = (met_plus_lep.i0.phi - met_plus_lep.i1.phi + math.pi) % (2*math.pi) - math.pi\n", " mt_lep = np.sqrt(2.0*met_plus_lep.i0.pt*met_plus_lep.i1.pt*(1.0-np.cos(dphi_met_lep)))\n", " \n", " self.output['massT'].fill(dataset=dataset, massT=ak.flatten(mt_lep))\n", " \n", " return self.output\n", "\n", " def postprocess(self, accumulator):\n", " pass" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from dask.distributed import Client\n", "\n", "client = Client(\"tls://localhost:8786\")" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[########################################] | 100% Completed | 3min 35.1s\r" ] }, { "data": { "text/plain": [ "{'bytesread': 9982563224,\n", " 'columns': ['Muon_pt',\n", " 'Electron_charge',\n", " 'MET_CovXY',\n", " 'Muon_phi',\n", " 'Muon_pfRelIso04_all',\n", " 'nMuon',\n", " 'Muon_charge',\n", " 'Muon_mass',\n", " 'nJet',\n", " 'Muon_softId',\n", " 'Muon_dzErr',\n", " 'Electron_dz',\n", " 'Muon_pfRelIso03_all',\n", " 'Electron_pfRelIso03_all',\n", " 'Muon_dz',\n", " 'Electron_dzErr',\n", " 'MET_pt',\n", " 'Electron_dxy',\n", " 'MET_CovXX',\n", " 'MET_phi',\n", " 'Muon_tightId',\n", " 'Electron_mass',\n", " 'Electron_phi',\n", " 'Electron_jetIdx',\n", " 'Electron_dxyErr',\n", " 'nElectron',\n", " 'Muon_dxy',\n", " 'Electron_eta',\n", " 'Electron_genPartIdx',\n", " 'MET_sumet',\n", " 'Electron_cutBasedId',\n", " 'Muon_eta',\n", " 'Muon_dxyErr',\n", " 'MET_significance',\n", " 'MET_CovYY',\n", " 'Electron_pt',\n", " 'Electron_pfId',\n", " 'Muon_jetIdx',\n", " 'Muon_genPartIdx'],\n", " 'entries': 53446198,\n", " 'processtime': 8462.17432808876,\n", " 'chunks': 534}" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fileset = {'SingleMu' : [\"root://eospublic.cern.ch//eos/root-eos/benchmark/Run2012B_SingleMu.root\"]}\n", "\n", "executor = processor.DaskExecutor(client=client)\n", "\n", "run = processor.Runner(executor=executor,\n", " schema=schemas.NanoAODSchema,\n", " savemetrics=True\n", " )\n", "\n", "output, metrics = run(fileset, \"Events\", processor_instance=Processor())\n", "\n", "metrics" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[StairsArtists(stairs=, errorbar=None, legend_artist=None)]" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEGCAYAAAB7DNKzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAYm0lEQVR4nO3dfdCddX3n8feniSLWBuVx88A0WKLbQC1KRFxnrV2ssLoadhYk7lrjbmZQhlpb29lCuxVrhwrqSsVdWVmhBKpARDtQW0QGpO7abDAqCgkiUSjERIiCBNmKTfzuH+d3ryd37nMluZ8f3q+Ze851vtfD+V3XnJxPftd1zu9KVSFJ0iA/N9UNkCRNbwaFJKmTQSFJ6mRQSJI6GRSSpE7zp7oB4+3www+vpUuXTnUzJGlG+cpXvvL9qjpipHmzLiiWLl3Kxo0bp7oZkjSjJPmHQfM89SRJ6mRQSJI6GRSSpE4GhSSp0z6DIsmVSR5Nck9f7dAktya5vz0+r2/e+Um2JLkvyal99ROT3N3mXZokrX5QkutbfUOSpX3rrG6vcX+S1eO215Kk/bY/PYqrgNOG1c4DbquqZcBt7TlJlgOrgOPaOh9NMq+tcxlwNrCs/Q1tcw3weFUdC1wCXNy2dShwAfAy4CTggv5AkiRNjn0GRVV9EXhsWHklsLZNrwVO76tfV1VPV9UDwBbgpCQLgQVVtb56w9VePWydoW3dAJzSehunArdW1WNV9ThwK3sHliRpgo32GsVRVbUdoD0e2eqLgYf7ltvaaovb9PD6HutU1S7gCeCwjm3tJcnZSTYm2bhjx45R7pIkaSTj/YO7jFCrjvpo19mzWHU5cDnAihUrJu0GG3/y15vYvG3niPOWL1rABa8/brKaIkkTZrQ9ikfa6STa46OtvhU4um+5JcC2Vl8yQn2PdZLMBw6hd6pr0Lamjc3bdrJ5+95BsXn7zoEBIkkzzWh7FDcBq4GL2uONffVPJvkQsIjeRes7q2p3kieTnAxsAN4CfGTYttYDZwC3V1UluQX4s74L2K8Bzh9le8dkUM9h8/adLF+4gOvf9vI96md9bP1kNU2SJtw+gyLJtcCrgMOTbKX3TaSLgHVJ1gAPAWcCVNWmJOuAzcAu4Nyq2t02dQ69b1AdDNzc/gCuAK5JsoVeT2JV29ZjSf4U+HJb7r1VNfyi+qQY6jksX7hgj/ryhQtYvmjBgLUkaXbYZ1BU1ZsGzDplwPIXAheOUN8IHD9C/ce0oBlh3pXAlftq42QYqecgSXOBv8yWJHUyKCRJnQwKSVKnWXfjouli8/adI377yd9XSJppDIo++/oa7P4a9E2okX5zIUnTnUHRZ7y+Bjuox+DvKyTNRAbFMH4NVpL25MVsSVIng0KS1MmgkCR1MigkSZ0MCklSJ4NCktTJoJAkdTIoJEmdDApJUieDQpLUySE8JpmjykqaaQyKSeSospJmIoNiEjmqrKSZyGsUkqROBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQSFJ6mRQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROYwqKJL+bZFOSe5Jcm+RZSQ5NcmuS+9vj8/qWPz/JliT3JTm1r35ikrvbvEuTpNUPSnJ9q29IsnQs7ZUkHbhRB0WSxcBvAyuq6nhgHrAKOA+4raqWAbe15yRZ3uYfB5wGfDTJvLa5y4CzgWXt77RWXwM8XlXHApcAF4+2vZKk0Rnrqaf5wMFJ5gPPBrYBK4G1bf5a4PQ2vRK4rqqerqoHgC3ASUkWAguqan1VFXD1sHWGtnUDcMpQb0OSNDlGHRRV9V3gg8BDwHbgiar6PHBUVW1vy2wHjmyrLAYe7tvE1lZb3KaH1/dYp6p2AU8Ahw1vS5Kzk2xMsnHHjh2j3SVJ0ghGfYe7du1hJXAM8EPgU0ne3LXKCLXqqHets2eh6nLgcoAVK1bsNX8m8F7akqarsdwK9dXAA1W1AyDJZ4B/ATySZGFVbW+nlR5ty28Fju5bfwm9U1Vb2/Twev86W9vprUOAx8bQ5mnJe2lLms7GEhQPAScneTbwj8ApwEbgKWA1cFF7vLEtfxPwySQfAhbRu2h9Z1XtTvJkkpOBDcBbgI/0rbMaWA+cAdzermPMKt5LW9J0NuqgqKoNSW4AvgrsAr5G7/TPc4B1SdbQC5Mz2/KbkqwDNrflz62q3W1z5wBXAQcDN7c/gCuAa5JsodeTWDXa9kqSRmcsPQqq6gLggmHlp+n1LkZa/kLgwhHqG4HjR6j/mBY0kqSp4S+zJUmdDApJUieDQpLUyaCQJHUyKCRJnQwKSVIng0KS1MmgkCR1MigkSZ0MCklSJ4NCktTJoJAkdTIoJEmdDApJUieDQpLUyaCQJHUyKCRJnQwKSVIng0KS1MmgkCR1MigkSZ0MCklSp/lT3QB127x9J2d9bP1e9eWLFnDB64+bghZJmmsMimls+aIFI9Y3b985yS2RNJcZFNPYoB7DSD0MSZooXqOQJHUyKCRJnQwKSVIng0KS1MmgkCR1MigkSZ0MCklSpzEFRZLnJrkhyTeT3Jvk5UkOTXJrkvvb4/P6lj8/yZYk9yU5ta9+YpK727xLk6TVD0pyfatvSLJ0LO2VJB24sfYoPgx8rqr+OfCrwL3AecBtVbUMuK09J8lyYBVwHHAa8NEk89p2LgPOBpa1v9NafQ3weFUdC1wCXDzG9kqSDtCogyLJAuCVwBUAVfWTqvohsBJY2xZbC5zeplcC11XV01X1ALAFOCnJQmBBVa2vqgKuHrbO0LZuAE4Z6m1IkibHWHoUzwd2AH+R5GtJPp7k54Gjqmo7QHs8si2/GHi4b/2trba4TQ+v77FOVe0CngAOG0ObJUkHaCxBMR94CXBZVb0YeIp2mmmAkXoC1VHvWmfPDSdnJ9mYZOOOHTu6Wy1JOiBjCYqtwNaq2tCe30AvOB5pp5Noj4/2LX903/pLgG2tvmSE+h7rJJkPHAI8NrwhVXV5Va2oqhVHHHHEGHZJkjTcqIOiqr4HPJzkha10CrAZuAlY3WqrgRvb9E3AqvZNpmPoXbS+s52eejLJye36w1uGrTO0rTOA29t1DEnSJBnrMOPvAD6R5JnAd4D/SC981iVZAzwEnAlQVZuSrKMXJruAc6tqd9vOOcBVwMHAze0PehfKr0myhV5PYtUY2ytJOkBjCoqqugtYMcKsUwYsfyFw4Qj1jcDxI9R/TAsaSdLU8JfZkqROBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQSFJ6jTWH9xpimzevpOzPrZ+r/ryRQu44PXHTUGLJM1WBsUMtHzRghHrm7fvnOSWSJoLDIoZaFCPYaQehiSNldcoJEmdDApJUieDQpLUyaCQJHUyKCRJnQwKSVIng0KS1MmgkCR1MigkSZ0MCklSJ4NCktTJoJAkdTIoJEmdDApJUieDQpLUyaCQJHUyKCRJnQwKSVIng0KS1MmgkCR1mj/VDdD42rx9J2d9bP1e9eWLFnDB64+bghZJmukMillk+aIFI9Y3b985yS2RNJsYFLPIoB7DSD0MSdpfY75GkWRekq8l+Wx7fmiSW5Pc3x6f17fs+Um2JLkvyal99ROT3N3mXZokrX5QkutbfUOSpWNtryTpwIzHxex3Avf2PT8PuK2qlgG3teckWQ6sAo4DTgM+mmReW+cy4GxgWfs7rdXXAI9X1bHAJcDF49BeSdIBGFNQJFkCvA74eF95JbC2Ta8FTu+rX1dVT1fVA8AW4KQkC4EFVbW+qgq4etg6Q9u6AThlqLchSZocY+1R/Dnwn4Gf9tWOqqrtAO3xyFZfDDzct9zWVlvcpofX91inqnYBTwCHDW9EkrOTbEyycceOHWPcJUlSv1EHRZJ/AzxaVV/Z31VGqFVHvWudPQtVl1fViqpaccQRR+xncyRJ+2Ms33p6BfCGJK8FngUsSPKXwCNJFlbV9nZa6dG2/Fbg6L71lwDbWn3JCPX+dbYmmQ8cAjw2hjZLkg7QqHsUVXV+VS2pqqX0LlLfXlVvBm4CVrfFVgM3tumbgFXtm0zH0LtofWc7PfVkkpPb9Ye3DFtnaFtntNfYq0chSZo4E/E7iouAdUnWAA8BZwJU1aYk64DNwC7g3Kra3dY5B7gKOBi4uf0BXAFck2QLvZ7EqglorySpw7gERVXdAdzRpn8AnDJguQuBC0eobwSOH6H+Y1rQSJKmhoMCSpI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqZM3LpojBt0iFbxNqqRuBsUcMOgWqeBtUiXtm0ExB3T1FrxNqqR98RqFJKmTQSFJ6mRQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqZNBIUnqZFBIkjoZFJKkTg4KqIFDkDv8uCQwKOa8QUOQO/y4pCEGxRw3qMfg8OOShniNQpLUyaCQJHUyKCRJnQwKSVIng0KS1MmgkCR1MigkSZ0MCklSp1H/4C7J0cDVwD8DfgpcXlUfTnIocD2wFHgQeGNVPd7WOR9YA+wGfruqbmn1E4GrgIOBvwXeWVWV5KD2GicCPwDOqqoHR9tmHRiH9pAEY+tR7AJ+r6p+GTgZODfJcuA84LaqWgbc1p7T5q0CjgNOAz6aZF7b1mXA2cCy9ndaq68BHq+qY4FLgIvH0F4dgOWLFrB84d7De2zevpPN2xzeQ5pLRt2jqKrtwPY2/WSSe4HFwErgVW2xtcAdwB+0+nVV9TTwQJItwElJHgQWVNV6gCRXA6cDN7d13tO2dQPw35Kkqmq07db+cWgPSUPG5RpFkqXAi4ENwFEtRIbC5Mi22GLg4b7Vtrba4jY9vL7HOlW1C3gCOGyE1z87ycYkG3fs2DEeuyRJasYcFEmeA3wa+J2q6jonkRFq1VHvWmfPQtXlVbWiqlYcccQR+2qyJOkAjCkokjyDXkh8oqo+08qPJFnY5i8EHm31rcDRfasvAba1+pIR6nusk2Q+cAjw2FjaLEk6MKMOiiQBrgDuraoP9c26CVjdplcDN/bVVyU5KMkx9C5a39lOTz2Z5OS2zbcMW2doW2cAt3t9QpIm11juR/EK4DeBu5Pc1Wp/CFwErEuyBngIOBOgqjYlWQdspveNqXOrandb7xx+9vXYm9sf9ILomnbh+zF635qSJE2isXzr6X8z8jUEgFMGrHMhcOEI9Y3A8SPUf0wLGk0f/r5Cmlu8w50OiLdOleYeg0IHxN9XSHOPYz1JkjoZFJKkTgaFJKmTQSFJ6mRQSJI6+a0njRt/XyHNTgaFxoW/r5BmL4NC48LfV0izl9coJEmdDApJUidPPWnCeZFbmtkMCk0oL3JLM59BoQnlRW5p5vMahSSpk0EhSerkqSdNGS9ySzODQaEp4UVuaeYwKDQlvMgtzRxeo5AkdbJHoWnHaxfS9GJQaFrx2oU0/RgUmla8diFNPwaFZgxPSUlTw6DQjOApKWnqGBSaEbpOSdnTkCaWQaEZzZ6GNPEMCs1o9jSkiWdQaFYa1NPY8MBjbHjgMTZvG7nHYYhIezMoNCsN+rD/k7/eNDAkukLEANFcZlBoTun6sB8UIgaI5jqDQmoOtBeyr9NYIzFYNBPNiKBIchrwYWAe8PGqumiKm6Q5ZDSnsUYymmAZxMDRZJr2QZFkHvDfgd8AtgJfTnJTVW2e2pZprjvQD+oDDZZBxjNwppJhN3NM+6AATgK2VNV3AJJcB6wEDArNKOP1oThegTOVZkvYTTfXv+3lE7LdmRAUi4GH+55vBV7Wv0CSs4Gz29MfJblvLC+47u1jWXtKHA58f6obMcU8BjPwGPzD+G5uxu3/eFv39jEdg18cNGMmBEVGqNUeT6ouBy6fnOZMP0k2VtWKqW7HVPIYeAzm+v7DxB2DmXCHu63A0X3PlwDbpqgtkjTnzISg+DKwLMkxSZ4JrAJumuI2SdKcMe1PPVXVriS/BdxC7+uxV1bVpilu1nQzZ0+79fEYeAzm+v7DBB2DVNW+l5IkzVkz4dSTJGkKGRSSpE4GxQyT5MEkdye5K8nGVjs0ya1J7m+Pz5vqdo6nJFcmeTTJPX21gfuc5PwkW5Lcl+TUqWn1+BpwDN6T5LvtvXBXktf2zZtVxyDJ0Um+kOTeJJuSvLPV58z7oOMYTPz7oKr8m0F/wIPA4cNq7wfOa9PnARdPdTvHeZ9fCbwEuGdf+wwsB74OHAQcA3wbmDfV+zBBx+A9wO+PsOysOwbAQuAlbfoXgG+1/Zwz74OOYzDh7wN7FLPDSmBtm14LnD51TRl/VfVF4LFh5UH7vBK4rqqerqoHgC30hoGZ0QYcg0Fm3TGoqu1V9dU2/SRwL71RG+bM+6DjGAwybsfAoJh5Cvh8kq+0oUsAjqqq7dB7MwFHTlnrJs+gfR5pyJeuf0wz3W8l+UY7NTV02mVWH4MkS4EXAxuYo++DYccAJvh9YFDMPK+oqpcA/xo4N8krp7pB08w+h3yZRS4Dfgk4AdgO/NdWn7XHIMlzgE8Dv1NVXSMKzqVjMOHvA4Nihqmqbe3xUeCv6HUlH0myEKA9Pjp1LZw0g/Z5zgz5UlWPVNXuqvop8D/52WmFWXkMkjyD3gfkJ6rqM608p94HIx2DyXgfGBQzSJKfT/ILQ9PAa4B76A1psrotthq4cWpaOKkG7fNNwKokByU5BlgG3DkF7ZtwQx+Qzb+l916AWXgMkgS4Ari3qj7UN2vOvA8GHYPJeB9M+yE8tIejgL/qvV+YD3yyqj6X5MvAuiRrgIeAM6ewjeMuybXAq4DDk2wFLgAuYoR9rqpNSdbRu1/JLuDcqto9JQ0fRwOOwauSnEDvdMKDwNtg1h6DVwC/Cdyd5K5W+0Pm1vtg0DF400S/DxzCQ5LUyVNPkqROBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQaFpI8lhfUMlf2/Y0MnPnOr2jZckleSavufzk+xI8tkJer072jDTb+irvSvJN9Mbsv7rST7UfvU7aBvvSfK+YbUTktzbpr+Q5EdJVkzEPmhqGRSaNqrqB1V1QlWdAPwP4JKh51X1kyTT4gei49COp4Djkxzcnv8G8N0xbnNf/kNV3QSQ5O30ftV/clX9CvBSekNfHNyx/rXAWcNqq4BPAlTVrwMbx7vRmh4MCk1rSa5q/9v9AnBxkpOS/H2Sr7XHF7bl3prkM0k+125i8/5Wn9e2cU/73/PvJvnlJHf2vcbSJN9o0ycm+bs2Ou8tfeMI3ZHkz5L8HfDOJGe2bX49yRf7XusDSb7cRvJ8W8eu3Qy8rk2/id4H8VB7Bu3jcUnubD2sbyRZ1oZ1+ZvWjnuSDP8wH8kfAedU1Q8BquonVXXR0CB7SV6TZH2Sryb5VJLnVNV9wA+TvKxvO28ErtuP19MMNy3+hybtwwuAV1fV7iQLgFdW1a4krwb+DPh3bbkT6A29/DRwX5KP0Bt2enFVHQ+Q5LlV9cMkz0zy/Kr6Dr3/Ka9rp14+Aqysqh3tQ/dC4D+17T+3qn6tbedu4NSq+m6S57b5a4AnquqlSQ4CvpTk8+1eAMNdB7y7nW56EXAl8C/bvG8O2Me3Ax+uqk+0U3HzgNcC26rqda1dh3QdyPTGCnvOgDaR5HDgv7Tj/VSSPwDeBbyXXpitAjYkORn4QVXd3/V6mh0MCs0En+obo+YQYG2SZfTGtuk/r35bVT0BkGQz8IvAJuD5LTT+Bvh8W3Ydvf8RX0QvKM4CXggcD9ya3nha8+gN2zzk+r7pLwFXtbF0hkYyfQ3woiRn9LV1GbDXh3JVfSO9ewq8CfjbYbMH7eN64I+SLAE+U1X3t8D6YJKLgc9W1f8a/lrDhL6hptO7PebFwHOBfw8cSu/OaF9qx+CZ7XWhF25/n+T36AXG/+8FaXbz1JNmgqf6pv8U+ELrIbweeFbfvKf7pncD86vqceBXgTuAc4GPt/nXA29M8gKg2v+MA2zquy7yK1X1mpHaUVVvp/c/76OBu5Ic1tZ/R9/6x1TV5xnsJuCD7P2BO+I+VtUngTcA/wjckuRfVdW3gBOBu4H3JXl3x+vRTi89ld5oolTVLe2a0D30QiHArX37sLyq1rRlH6Y36Nyv0evhrOt6Lc0eBoVmmkP42YXft+5r4XYq5eeq6tPAH9O77zRV9W16YfLH/KyncB9wRJKXt3WfkeS4Adv9paraUFXvBr5PLzBuAc4Z+vZQkhekNxz8IFcC762qu/dnH5M8H/hOVV1KL2RelGQR8H+r6i/phc5L9nVMgPcBlw2dMkuv6zAUuP8HeEWSY9u8Z7cwHXItcAnw7arauh+vpVnAU0+aad5P77TMu4Db92P5xcBfJBn6T9H5ffOuBz5A78bztG9WnQFc2s71zwf+nN7pq+E+0E4NBbiN3k3svwEsBb7aPnx30HH/8vZB++ED2MezgDcn+Sfge/SuG7y0teWnwD8B5wx6vT6XAc+md63haeBH9E6lfa2qnkjyVuDadp0Fej2nb7XpT7U2v2M/XkezhMOMS7NckjuA36+qCf366mS9jiafp56k2e8xehfe37DPJUcpva8vP59er0azjD0KSVInexSSpE4GhSSpk0EhSepkUEiSOv0/jNWBuxayLlAAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "output['massT'].plot1d()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "all events 53446198\n", "all muons 991421725\n", "all electrons 87391040\n", "trileptons 5043516\n", "number of final leading leptons 1227755\n" ] } ], "source": [ "for key, value in output['cutflow'].items():\n", " print(key, value)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.13" } }, "nbformat": 4, "nbformat_minor": 4 }