{ "cells": [ { "cell_type": "markdown", "id": "0ef5ce86-6598-46ad-8fd4-c074b13c06d2", "metadata": {}, "source": [ "# Packed Selection\n", "\n", "This is a rendered copy of [packedselection.ipynb](https://github.com/scikit-hep/coffea/blob/master/binder/packedselection.ipynb). You can optionally run it interactively on [binder at this link](https://mybinder.org/v2/gh/coffeateam/coffea/master?filepath=binder%2Fpackedselection.ipynb)\n", "\n", "In `coffea`, `PackedSelection` is a class that can store several boolean arrays in a memory-efficient manner and evaluate arbitrary combinations of boolean requirements in an CPU-efficient way. Supported inputs include 1D numpy or awkward arrays and it has built-in functionalities to form analysis in signal and control regions, and to implement cutflow or \"N-1\" plots.\n", "\n", "`coffea` 2025 supports multiple modes, including `eager` (which loads all data from the file, typically best for testing only small input files), `virtual` (which functions the most like `coffea 0.7` and only loads data as-needed), and `dask` (the original variation introduced in CalVer `coffea` to utilize fully DAG-building via `dask` / `dask-awkward`). Let's first read a sample file of 40 Drell-Yan events to demonstrate the utilities using our `NanoAODSchema` as our schema; feel free to swap between `eager` and `virtual` modes for the `events` array." ] }, { "cell_type": "code", "execution_count": 1, "id": "d144affc-9918-4642-940e-148335eed6b7", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
[{Electron: [], PuppiMET: {phi: 1.64, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [{deltaEtaSC: -0.0145, ...}], PuppiMET: {...}, FsrPhoton: [], ...},\n",
       " {Electron: [Electron, ...], PuppiMET: {...}, ...},\n",
       " {Electron: [Electron, ...], PuppiMET: {...}, ...},\n",
       " {Electron: [], PuppiMET: {phi: 0.538, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [{deltaEtaSC: -0.0232, ...}], PuppiMET: {...}, FsrPhoton: [], ...},\n",
       " {Electron: [{deltaEtaSC: 0.00415, ...}], PuppiMET: {...}, FsrPhoton: [], ...},\n",
       " {Electron: [], PuppiMET: {phi: 0.105, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [], PuppiMET: {phi: -0.513, ...}, FsrPhoton: [], ChsMET: ..., ...},\n",
       " {Electron: [{deltaEtaSC: 0.00813, ...}], PuppiMET: {...}, FsrPhoton: [], ...},\n",
       " ...,\n",
       " {Electron: [{deltaEtaSC: -0.00836, ...}], PuppiMET: {...}, ...},\n",
       " {Electron: [], PuppiMET: {phi: 0.612, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [{deltaEtaSC: -0.00405, ...}], PuppiMET: {...}, ...},\n",
       " {Electron: [], PuppiMET: {phi: 2.83, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [{deltaEtaSC: 0.053, ...}], PuppiMET: {...}, FsrPhoton: [], ...},\n",
       " {Electron: [], PuppiMET: {phi: 1.44, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [{deltaEtaSC: -0.00986, ...}], PuppiMET: {...}, ...},\n",
       " {Electron: [], PuppiMET: {phi: -2.92, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [], PuppiMET: {phi: -0.415, ...}, FsrPhoton: [], ChsMET: ..., ...}]\n",
       "--------------------------------------------------------------------------------\n",
       "backend: cpu\n",
       "nbytes: 243.3 kB\n",
       "type: 40 * event
" ], "text/plain": [ ", ...] type='40 * event'>" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import awkward as ak\n", "import numpy as np\n", "from coffea.nanoevents import NanoEventsFactory, NanoAODSchema\n", "from matplotlib import pyplot as plt\n", "\n", "NanoAODSchema.warn_missing_crossrefs = False\n", "\n", "fname = \"coffea/tests/samples/nano_dy.root\"\n", "events = NanoEventsFactory.from_root(\n", " {fname: \"Events\"},\n", " metadata={\"dataset\": \"nano_dy\"},\n", " schemaclass=NanoAODSchema,\n", " mode=\"eager\",\n", ").events()\n", "\n", "events" ] }, { "cell_type": "markdown", "id": "919582c0-9dc0-40d0-8e25-076dc4a848cd", "metadata": {}, "source": [ "Now let's import `PackedSelection`, and create an instance of it." ] }, { "cell_type": "code", "execution_count": 2, "id": "e4c80e4f-f4bd-4a92-b5fe-4c9faaf22bf7", "metadata": {}, "outputs": [], "source": [ "from coffea.analysis_tools import PackedSelection\n", "\n", "selection = PackedSelection()" ] }, { "cell_type": "markdown", "id": "18124df0-d370-4c3e-9e25-a9500eb1daf1", "metadata": {}, "source": [ "We can create a boolean mask and add this to our selection by using the `add` method. This adds the following \"cut\" to our selection and names it \"twoElectron\"." ] }, { "cell_type": "code", "execution_count": 3, "id": "b3d0e60b-48b6-4c8b-bb1a-7d8e295cd23b", "metadata": {}, "outputs": [], "source": [ "selection.add(\"twoElectron\", ak.num(events.Electron) == 2)" ] }, { "cell_type": "markdown", "id": "324c3acb-eb43-440a-a23e-3e31dded970a", "metadata": {}, "source": [ "We've added one \"cut\" to our selection. Now let's add a couple more." ] }, { "cell_type": "code", "execution_count": 4, "id": "0e45733b-36dc-43b5-94d2-6cc9f974e830", "metadata": {}, "outputs": [], "source": [ "selection.add(\"eleOppSign\", ak.sum(events.Electron.charge, axis=1) == 0)\n", "selection.add(\"noElectron\", ak.num(events.Electron) == 0)" ] }, { "cell_type": "markdown", "id": "71edfec0-537d-42a7-86df-f96423f69371", "metadata": {}, "source": [ "To avoid repeating calling `add` multiple times, we can just use the `add_multiple` method which does just that." ] }, { "cell_type": "code", "execution_count": 5, "id": "f16c75b5-71bf-4957-835e-efabda6978cf", "metadata": {}, "outputs": [], "source": [ "selection.add_multiple(\n", " {\n", " \"twoMuon\": ak.num(events.Muon) == 2,\n", " \"muOppSign\": ak.sum(events.Muon.charge, axis=1) == 0,\n", " \"noMuon\": ak.num(events.Muon) == 0,\n", " \"leadPt20\": ak.any(events.Electron.pt >= 20.0, axis=1) | ak.any(events.Muon.pt >= 20.0, axis=1),\n", " }\n", ")" ] }, { "cell_type": "markdown", "id": "d0e968df-afdd-413b-a7ab-29f05f1e25c4", "metadata": {}, "source": [ "By viewing the `PackedSelection` instance, one can see the names of the added selections, whether it is operating in delayed mode or not, the number of added selections and the maximum supported number of selections." ] }, { "cell_type": "code", "execution_count": 6, "id": "927d8de4-53b7-4250-b24c-17fa16c16526", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PackedSelection(selections=('twoElectron', 'eleOppSign', 'noElectron', 'twoMuon', 'muOppSign', 'noMuon', 'leadPt20'), delayed_mode=False, items=7, maxitems=32)\n" ] } ], "source": [ "print(selection)" ] }, { "cell_type": "markdown", "id": "434fa647-9e54-4678-adf5-c75e25cc032e", "metadata": {}, "source": [ "To evaluate a boolean mask (e.g. to filter events) we can use the `selection.all(*names)` function, which will compute the logical AND of all listed boolean selections." ] }, { "cell_type": "code", "execution_count": 7, "id": "0055353a-735b-4ac7-a2f1-698d2d42008b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([False, False, True, False, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, False, False])" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "selection.all(\"twoElectron\", \"noMuon\", \"leadPt20\")" ] }, { "cell_type": "markdown", "id": "b81d7b70-29cd-46b1-8d23-8f538b109c54", "metadata": {}, "source": [ "We can also be more specific and require that a specific set of selections have a given value (with the unspecified ones allowed to be either true or false) using `selection.require`." ] }, { "cell_type": "code", "execution_count": 8, "id": "5e6a478e-e69b-4181-8f8a-398bd6810375", "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "array([False, False, False, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, False, False])" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "selection.require(twoElectron=True, noMuon=True, eleOppSign=False)" ] }, { "cell_type": "markdown", "id": "52a11d5f-3d39-4146-b38d-f783039ccac9", "metadata": {}, "source": [ "There exist also the `allfalse` and `any` methods where the first one is the opposite of `all` and the second one is a logical OR between all listed boolean selections." ] }, { "cell_type": "markdown", "id": "9e36a33b-2fcc-4380-8a0c-9c3402315e61", "metadata": {}, "source": [ "Using `PackedSelection`, we are now able to perform an N-1 style selection using the `nminusone(*names)` method. This will perform an N-1 style selection by using as \"N\" the provided names and will exclude each named cut one at a time in order. In the end it will also peform a selection using all N cuts." ] }, { "cell_type": "code", "execution_count": 9, "id": "77bc1bdc-3449-425a-8853-e2622fc4ed94", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "NminusOne(selections=('twoElectron', 'noMuon', 'leadPt20'), commonmasked=False, weighted=False, weightsmodifier=None)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nminusone = selection.nminusone(\"twoElectron\", \"noMuon\", \"leadPt20\")\n", "nminusone" ] }, { "cell_type": "markdown", "id": "164c7fb8-f582-4892-8e78-a54e47820721", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "This returns an `NminusOne` object which has the following methods: `result()`, `print()`, `yieldhist()`, `to_npz()` and `plot_vars()`" ] }, { "cell_type": "markdown", "id": "7945c67d-5488-426c-b81c-56e2d09cee96", "metadata": {}, "source": [ "Let's look at the results of the N-1 selection." ] }, { "cell_type": "code", "execution_count": 10, "id": "eef67293-1f22-4ea0-ad7a-ac95a424a14c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ('labels', 'nev', 'masks')\n" ] } ], "source": [ "res = nminusone.result()\n", "print(type(res), res._fields)" ] }, { "cell_type": "markdown", "id": "7cdcfac7-ec59-447d-a285-609332042306", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "This is just a `namedtuple` with the attributes `labels`, `nev` and `masks`. So we can say:" ] }, { "cell_type": "code", "execution_count": 11, "id": "5ee9d9e6-b496-4cc3-9d36-578ce096ff57", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(['initial', 'N - twoElectron', 'N - noMuon', 'N - leadPt20', 'N'],\n", " [40, np.int64(10), np.int64(3), np.int64(5), np.int64(3)],\n", " [array([False, True, True, False, False, False, False, False, False,\n", " True, False, False, False, False, False, True, True, False,\n", " False, False, True, True, False, False, False, False, False,\n", " True, False, True, False, False, False, True, False, False,\n", " False, False, False, False]),\n", " array([False, False, True, False, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, False, False]),\n", " array([False, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " True, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, False, False]),\n", " array([False, False, True, False, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, False, False])])" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "labels, nev, masks = res\n", "labels, nev, masks" ] }, { "cell_type": "markdown", "id": "e321f2b4-3e35-423c-a0a2-7b878ae7a260", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "`labels` is a list of labels of each mask that is applied, `nev` is a list of the number of events that survive each mask, and `masks` is a list of boolean masks (arrays) of which events survive each selection.\n", "You can also choose to print the statistics of your N-1 selection in a similar fashion to `RDataFrame`." ] }, { "cell_type": "code", "execution_count": 12, "id": "abe984e8-a4f1-4769-8d7c-60ce565b2d56", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n",
       "N-1 selection stats:\n",
       "
\n" ], "text/plain": [ "\n", "\u001b[38;2;230;159;0mN-\u001b[0m\u001b[1;38;2;230;159;0m1\u001b[0m\u001b[38;2;230;159;0m selection stats:\u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Ignoring twoElectron         pass = 10                  all = 40                  -- eff = 25.0 %\n",
       "
\n" ], "text/plain": [ "Ignoring \u001b[38;2;213;94;0mtwoElectron \u001b[0mpass = \u001b[1;36m10\u001b[0m all = \u001b[1;36m40\u001b[0m -- eff = \u001b[1;36m25.0\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Ignoring noMuon              pass = 3                   all = 40                  -- eff = 7.5 %\n",
       "
\n" ], "text/plain": [ "Ignoring \u001b[38;2;213;94;0mnoMuon \u001b[0mpass = \u001b[1;36m3\u001b[0m all = \u001b[1;36m40\u001b[0m -- eff = \u001b[1;36m7.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Ignoring leadPt20            pass = 5                   all = 40                  -- eff = 12.5 %\n",
       "
\n" ], "text/plain": [ "Ignoring \u001b[38;2;213;94;0mleadPt20 \u001b[0mpass = \u001b[1;36m5\u001b[0m all = \u001b[1;36m40\u001b[0m -- eff = \u001b[1;36m12.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
All cuts                     pass = 3                   all = 40                  -- eff = 7.5 %\n",
       "
\n" ], "text/plain": [ "\u001b[38;2;230;159;0mAll cuts\u001b[0m pass = \u001b[1;36m3\u001b[0m all = \u001b[1;36m40\u001b[0m -- eff = \u001b[1;36m7.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "nminusone.print()" ] }, { "cell_type": "markdown", "id": "282ebb23-70f8-43e1-bb60-99770fcf3543", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Or get a histogram of your total event yields. This just returns a `hist.Hist` object and we can plot it with its backends to `mplhep`." ] }, { "cell_type": "code", "execution_count": 13, "id": "ef6b795a-3205-4850-a366-791bf625f094", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "h, labels = nminusone.yieldhist()\n", "h.plot1d()\n", "plt.xticks(plt.gca().get_xticks(), labels, rotation=45)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "0080510c-aa7c-4492-b1a1-28601d4e7a27", "metadata": {}, "source": [ "You can also save the results of the N-1 selection to a `.npz` file for later use." ] }, { "cell_type": "code", "execution_count": 14, "id": "d6bb3514-403c-441a-bf85-d88304e556c4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "labels: ['initial' 'N - twoElectron' 'N - noMuon' 'N - leadPt20' 'N']\n", "nev: [40 10 3 5 3]\n", "masks: [[False True True False False False False False False True False False\n", " False False False True True False False False True True False False\n", " False False False True False True False False False True False False\n", " False False False False]\n", " [False False True False False False False False False False False False\n", " False False False False False False False False True True False False\n", " False False False False False False False False False False False False\n", " False False False False]\n", " [False False True True False False False False False False False False\n", " False False False False False False True False True True False False\n", " False False False False False False False False False False False False\n", " False False False False]\n", " [False False True False False False False False False False False False\n", " False False False False False False False False True True False False\n", " False False False False False False False False False False False False\n", " False False False False]]\n" ] } ], "source": [ "nminusone.to_npz(\"nminusone_results.npz\").compute()\n", "with np.load(\"nminusone_results.npz\") as f:\n", " for i in f.files:\n", " print(f\"{i}: {f[i]}\")" ] }, { "cell_type": "markdown", "id": "abfab631-e4bd-40b7-a3e8-faff7c87ed76", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Finally, we can ask from this object to create histograms of different variables, masking them with our N-1 selection.\n", "What it will output is a list of histograms, one for each requested variable, where the x-axis is the distribution of the variable, and the y-axis is the mask that was applied.\n", "It is essentially slices of how the variable distribution evolves as each N-1 or N selection is applied. It does also return a list of labels of the masks to keep track.\n", "\n", "Note that the variables are parsed using a dictonary of `name: array` pairs and that the arrays will of course be flattened to be histogrammed." ] }, { "cell_type": "code", "execution_count": 15, "id": "b21100ec-06e8-4e94-9966-925a512212b7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "([Hist(\n", " Regular(20, 5.81891, 60.0685, name='Ept'),\n", " Integer(0, 5, name='nminusone'),\n", " storage=Double()) # Sum: 55.0 (60.0 with flow),\n", " Hist(\n", " Regular(20, -2.93115, 3.11865, name='Ephi'),\n", " Integer(0, 5, name='nminusone'),\n", " storage=Double()) # Sum: 60.0],\n", " ['initial', 'N - twoElectron', 'N - noMuon', 'N - leadPt20', 'N'])" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hs, labels = nminusone.plot_vars({\"Ept\": events.Electron.pt, \"Ephi\": events.Electron.phi})\n", "hs, labels" ] }, { "cell_type": "markdown", "id": "ef70ef89-f1d8-4692-a2fd-044d20ffd706", "metadata": {}, "source": [ "And we can actually plot those histograms using again the `mplhep` backend." ] }, { "cell_type": "code", "execution_count": 16, "id": "d7ba7d28-b862-4f59-97df-27a1df3361f5", "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "for h in hs:\n", " h.plot2d()\n", " plt.yticks(plt.gca().get_yticks(), labels, rotation=0)\n", " plt.show()" ] }, { "cell_type": "markdown", "id": "f78249e8-8ebe-43b3-8dd5-b996db6cfa2d", "metadata": {}, "source": [ "You can slice these histograms to view and plot the 1D histogram at each step of the selection. For example, if we want the $P_T$ of the electrons at the final step (index 4) of the selection, we can do the following." ] }, { "cell_type": "code", "execution_count": 17, "id": "2cda4d43-4933-4fe1-a19b-1db74a5b62d0", "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAGwCAYAAAC5ACFFAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAJ3NJREFUeJzt3QuQ1dVhP/ADrAiIEHkLyqshCKigvIYYgjwqpQ4IWkNGUxGnWA02ChKqmQqtMWhiYYhKwQiItRqJGcCECPKsjBSLoKShKAZDqwV5TRMQSOV1/3PO/JdheRxheSwsn8/Mj72/3/3d3z179i73u+d1KxQKhUIAAOCoKh79MAAAwhIAwBfQsgQAkCEsAQBkCEsAABnCEgBAhrAEAJBRlLuT43PgwIGwcePGcPHFF4cKFSqoNgA4B8SlJj/77LPQsGHDULHisduPhKVTIAalyy+//FRcCgA4wz755JNw2WWXHfN+YekUiC1KxZVdo0aNU3FJAOA027FjR2rsKH4fPxZh6RQo7nqLQUlYAoBzyxcNoTHAGwAgQ1gCAMgQlgAAMoQlAIAMYQkAIENYAgDIEJYAADKEJQCADGEJACBDWDrM7NmzQ8uWLUOLFi3C5MmTc3UHAJwHfNzJIfbt2xeGDx8eFi9eHGrWrBnat28fBgwYEGrXrl12PyEAoExpWTrE8uXLQ5s2bUKjRo1C9erVQ58+fcK8efPK7qcDAJwfYenxxx8PHTt2TJ/qW69evdC/f/+wdu3aU/ocS5YsCX379g0NGzZMH4g3a9aso543YcKE0LRp01ClSpXQuXPnFJCKbdy4MQWlYvH2hg0bTmk5gVOrUCiE3Xv2nfYtPg9wfjoj3XBvvvlmGDp0aApMsavre9/7XrjhhhvCmjVrwkUXXXTE+UuXLg2dOnUKF1xwQYnj8fzYJVa/fv0jHrNr167Qtm3bcNddd4Wbb775qOWYPn166mabNGlSCkrjx48PvXv3TsEthjjg3PPHvftD61FvnPbnWfNo71CtspELcD46Iy1Lc+fODXfeeWfq4oqBZtq0aeHjjz8OK1euPOLcAwcOpGB12223hf379x88HgNNjx49wgsvvHDU54hdZo899lgaY3Qs48aNC0OGDAmDBw8OrVu3TqGpWrVqYerUqen+2Cp1aEtSvB2PHUtspYrXiSEQACifyuTPpO3bt6evtWrVOuK+ihUrhtdffz18/etfD3fccUd48cUXw/r161NQit13I0eOLNVz7tmzJ4Wzhx9+uMRz9erVKyxbtiztx9as1atXp5AUB3jPmTMnPPLII8e8Zgx1cduxY0c6HyhbK/6uV6hWudIpu97uPftDh8cWnLLrAeemMx6WYsvRAw88EK677rpw5ZVXHvWc2JqzaNGi0LVr19TCFMNMDDUTJ04s9fNu27YttVQd3oUX9z/44IN0u6ioKIwdOzZ07949lTMGMzPh4NwRg5KuMuCcD0uxJSa23rz11lvZ8xo3bpxalbp16xaaN28epkyZkgZun279+vVLGwDAGV864L777kuLPsZ1jC677LLsuZs3bw533313muG2e/fuMGzYsJN67jp16oRKlSql6x7+PA0aNDipawMA5dcZCUtxym0MSjNnzkzda82aNfvCLrOePXuGVq1ahRkzZoSFCxemmWwjRowodRkqV66cFpmM1yoWu9rifpcuXUp9XQCgfCs6U11vL7/8cnjttdfSWkubNm1Kx+Og6KpVq5Y4NwaYOLOtSZMmKSDFcURxxtn8+fPTIO+49tHRWpl27twZ1q1bd3A/DgpftWpVGkQeu/SiuGzAoEGDQocOHdJg7rh0QFxyIM6OAwAos7BUPDD7+uuvL3H8+eefT0sKHCrOUBszZkwa3B1bg4rFJQcWLFgQ6tate9TnWLFiRRqYXSwGoyiGo7hUQTRw4MCwdevWMGrUqBTY2rVrl5Y1ONq6TQAAZywsnejKt3/6p3961OPXXHPNMR8Tg9jxPE/sDowbAMDx8NlwAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEsAABnCEgBAhrAEAJAhLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEsAABnCEgBAhrAEAJAhLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEsAABnCEgBAhrAEAJAhLAEAZAhLAAAZwtJhZs+eHVq2bBlatGgRJk+enKs7AOA8UFTWBTib7Nu3LwwfPjwsXrw41KxZM7Rv3z4MGDAg1K5du6yLBgCUES1Lh1i+fHlo06ZNaNSoUahevXro06dPmDdvXln9bACAczEsLVmyJPTt2zc0bNgwVKhQIcyaNSt7/v79+8MjjzwSmjVrFqpWrRr+5E/+JHz/+98PhULhZMpd6nJNmDAhNG3aNFSpUiV07tw5BaRiGzduTEGpWLy9YcOGU1pOAKCch6Vdu3aFtm3bptBxPH74wx+GiRMnhmeeeSa8//77af9HP/pRePrpp4/5mKVLl4a9e/cecXzNmjVh8+bNpS7X9OnTUzfb6NGjw7vvvpvO7927d9iyZctxfS8AwPnnhMNS7Jp67LHH0lie4/Fv//Zv4aabbgo33nhjatH5i7/4i3DDDTeUaNE51IEDB8LQoUPDbbfdllqliq1duzb06NEjvPDCC6Uu17hx48KQIUPC4MGDQ+vWrcOkSZNCtWrVwtSpU9P9sVXq0JakeDseO5YYzOJ1OnbseFx1AQCce077mKWvfvWrYeHCheHDDz9M+7/+9a/DW2+9lcLNUQtUsWJ4/fXXw3vvvRfuuOOOFJ4++uijFJT69+8fRo4cWapy7NmzJ6xcuTL06tWrxHPF/WXLlqX9Tp06hdWrV6eQtHPnzjBnzpzU8nQsMdTF1q533nmnVGUCAM5+p3023EMPPRR27NgRrrjiilCpUqXUWvSDH/wg3H777cd8TGzNWbRoUejatWtqYYphJoaa2J1XWtu2bUvPXb9+/RLH4/4HH3yQbhcVFYWxY8eG7t27p5AWg5mZcABwfjvtYelnP/tZeOmll8LLL7+cZpqtWrUqPPDAAykQDRo06JiPa9y4cXjxxRdDt27dQvPmzcOUKVPSwO3TrV+/fmkDADgj3XDf/e53U+vSN7/5zXDVVVeFv/zLvwzDhg0Ljz/+ePZxcSD33XffnWa47d69Oz3mZNSpUye1bB0+QDzuN2jQ4KSuDQCUX6c9LMWgE8cGHSqGltjNlesy69mzZ2jVqlWYMWNGGvMUZ7KNGDGi1OWoXLlyWmQyXqtYLEPc79KlS6mvCwCUbyfcDRcHPq9bt+7g/vr161PXWq1atVLXWVwiYObMmQdDSWwZimOU4n2xGy4O3I6z0u66666jXj8GmDj4u0mTJikgxXFEccbZ/Pnz0yDvuPbR0VqZvqhcUVw2IHb9dejQIQ3mHj9+fFpyIM6OAwA4JWFpxYoVaQB0sRhAohhCpk2bllqF4uy1YnE9pbgo5be//e20nlEcq/TXf/3XYdSoUUe9fmyFGjNmTBrcHVuDisU1kRYsWBDq1q1bqnJFAwcODFu3bk3PvWnTptCuXbswd+7cIwZ9AwAUq1A41Utpn4fibL/4WXLbt28PNWrUKOviwHll9559ofWoN9LtNY/2DtUqF50T1wbOnfdvnw0HAJAhLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEsAABnCEgBAhrAEAJAhLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEsAABnCEgBAhrAEAJAhLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEsAABnCEgBAhrAEAJAhLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcLSYWbPnh1atmwZWrRoESZPnpyrOwDgPFBU1gU4m+zbty8MHz48LF68ONSsWTO0b98+DBgwINSuXbusiwYAlBEtS4dYvnx5aNOmTWjUqFGoXr166NOnT5g3b15Z/WwAgHMxLC1ZsiT07ds3NGzYMFSoUCHMmjXruB63YcOG8K1vfSu10lStWjVcddVVYcWKFaUp80mVbcKECaFp06ahSpUqoXPnzikgFdu4cWMKSsXi7VhuAOD8dcJhadeuXaFt27YpdByv3//+9+G6664LF1xwQZgzZ05Ys2ZNGDt2bLjkkkuOev7SpUvD3r17jzgeH7d58+ZSl2369Ompm2306NHh3XffTef27t07bNmy5bi/FwDg/HLCY5Zi11TcTsQPf/jDcPnll4fnn3/+4LFmzZod9dwDBw6EoUOHpgHWr7zySqhUqVI6vnbt2tCjR48UdkaOHFmqso0bNy4MGTIkDB48OO1PmjQp/OpXvwpTp04NDz30UGqROrQlKd7u1KnTMa8XQ1nc9u/ffxy1AACci87ImKVf/OIXoUOHDuHWW28N9erVC9dcc0147rnnjl6gihXD66+/Ht57771wxx13pPD00UcfpaDUv3//YwalL7Jnz56wcuXK0KtXrxLPFfeXLVuW9mMwWr16dQpJO3fuTK1gseXpWGKoi61d77zzTqnKBACc/c5IWPrd734XJk6cmFqL3njjjXDvvfeG73znO+GFF1446vmxhWfRokXhrbfeCrfddlsKSjHUxGuU1rZt21ILUP369Uscj/ubNm1Kt4uKilL3YPfu3UO7du3Cgw8+aCYcAJznzsjSAbF1KLYsjRkzJu3HlqXYghO7wQYNGnTUxzRu3Di8+OKLoVu3bqF58+ZhypQpadD26davX7+0AQCcsZalSy+9NLRu3brEsVatWoWPP/74mI+JA7nvvvvuNLtt9+7dYdiwYSdVhjp16qTxT4cPEI/7DRo0OKlrAwDl1xkJS3EmXBygfagPP/wwNGnS5JhdZj179kyBasaMGWHhwoVpJtuIESNKXYbKlSunRSbjtQ5t8Yr7Xbp0KfV1AYDy7YS74eLA53Xr1h3cX79+fVi1alWoVatW6jp75plnwsyZM0uEktgq9NWvfjV1w33jG99Iaxv95Cc/SdvhYoCJM9pikIoBKY4jiq1S8+fPT2OX4tpHx2pl+qKyxZl0sdsvdgnGwdzjx49Pyw0Uz44DADjpsBQXkowDoIvFABLFEDJt2rTUKhRnrx2qY8eOKUA9/PDD4dFHH03LBsSgcvvttx9x/ThDLYaqrl27ptagYnFNpAULFoS6deuWumwDBw4MW7duDaNGjUqDuuMg7rlz5x4x6BsAoFiFQqFQOLhHqezYsSN9ltz27dtDjRo11CKcQbv37AutR72Rbq95tHeoVrnonLg2cO68f/tsOACADGEJACBDWAIAyBCWAAAyhCUAgAxhCQAgQ1gCAMgQlgAAMoQlAIAMYQkAIENYAgDIEJYAADKEJQCADGEJACBDWAIAyBCWAAAyhCUAgAxhCQAgQ1gCAMgQlgAAMoQlAIAMYQkAIENYAgDIEJYAADKEJQCADGEJACBDWAIAyBCWAAAyhCUAgAxhCQAgQ1gCAMgQlgAAMoQlAIAMYQkAIENYAgDIEJYAADKEJQCADGEJACBDWAIAyBCWAAAyhCUAgAxhCQAgQ1gCAMgQlgAAMoQlAIAMYQkAIENYAgDIEJYAADKEJQCADGEJACBDWDrM7NmzQ8uWLUOLFi3C5MmTc3UHAJwHisq6AGeTffv2heHDh4fFixeHmjVrhvbt24cBAwaE2rVrl3XRAIAyomXpEMuXLw9t2rQJjRo1CtWrVw99+vQJ8+bNK6ufDQBwLoalJUuWhL59+4aGDRuGChUqhFmzZp3Q45944on0uAceeOBEn/qUlG3ChAmhadOmoUqVKqFz584pIBXbuHFjCkrF4u0NGzac8nICAOU4LO3atSu0bds2hY4T9c4774Rnn302XH311dnzli5dGvbu3XvE8TVr1oTNmzeXumzTp09P3WyjR48O7777bjq3d+/eYcuWLSf8vQAA54cTDkuxa+qxxx5LY3lOxM6dO8Ptt98ennvuuXDJJZcc87wDBw6EoUOHhttuuy3s37//4PG1a9eGHj16hBdeeKHUZRs3blwYMmRIGDx4cGjdunWYNGlSqFatWpg6dWq6P7ZIHdqSFG/HYwDA+euMjVmKAejGG28MvXr1yheoYsXw+uuvh/feey/ccccdKTx99NFHKSj1798/jBw5slTPv2fPnrBy5coSzx+fK+4vW7Ys7Xfq1CmsXr06haQY7ubMmZNano4ltmDF0NWxY8dSlQkAOPudkdlwr7zySur2it1wxyO25ixatCh07do1tTDFMBNDzcSJE0tdhm3btqWWqvr165c4Hvc/+OCDdLuoqCiMHTs2dO/ePYW0GMxyM+FiAIzbjh070uw5AKD8Oe1h6ZNPPgn3339/mD9/fhpUfbwaN24cXnzxxdCtW7fQvHnzMGXKlDRo+3Tr169f2gAAzkg3XOz6igOor7322tRyE7c333wzPPXUU+n2oeOSDhUHct99991pdtvu3bvDsGHDTqocderUCZUqVTpigHjcb9CgwUldGwAov057WOrZs2f4zW9+E1atWnVw69ChQxrsHW/HAHO0LrP4uFatWoUZM2aEhQsXpplsI0aMKHU5KleunBaZjNcqFrva4n6XLl1KfV0AoHw74W64OPB53bp1B/fXr1+fQk+tWrVS19kzzzwTZs6ceTCUXHzxxeHKK68scY2LLroojQU6/HhxgImz2po0aZICUmx9ioOoYzdeHOQd1z46VivTF5UtLhswaNCgFNbiYO7x48en5Qbi7DgAgFMSllasWJEGQBeLASSKIWTatGmpVSjOXiutOENtzJgxaXB3bA0qFtdEWrBgQahbt26pyzZw4MCwdevWMGrUqLBp06bQrl27MHfu3CMGfQMAFKtQKBQKB/coleLZcNu3bw81atRQi3AG7d6zL7Qe9Ua6vebR3qFa5aJz4trAufP+7bPhAAAyhCUAgAxhCQAgQ1gCAMgQlgAAMoQlAIAMYQkAIENYAgDIEJYAADKEJQCADGEJACBDWAIAyBCWAAAyhCUAgAxhCQAgQ1gCAMgQlgAAMoQlAIAMYQkAIENYAgDIEJYAADKEJQCADGEJACBDWAIAyBCWAAAyhCUAgAxhCQAgQ1gCAMgQlgAAMoQlAIAMYQkAIENYAgDIEJYAADKEJQCADGEJACBDWAIAyBCWAAAyhCUAgAxhCQAgQ1gCAMgQlgAAMoQlAIAMYQkAIENYAgAQlgAASkfLEgBAhrAEAJAhLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEsAABnCEgCAsAQAUDpalgAAMoQlAIAMYekoZs+eHVq2bBlatGgRJk+enKs/AKCcKyrrApxt9u3bF4YPHx4WL14catasGdq3bx8GDBgQateuXdZFAwDKgJalwyxfvjy0adMmNGrUKFSvXj306dMnzJs3ryx+NgDAuRqWlixZEvr27RsaNmwYKlSoEGbNmpU9//HHHw8dO3YMF198cahXr17o379/WLt2bWnLfNLlmjBhQmjatGmoUqVK6Ny5cwpIxTZu3JiCUrF4e8OGDae8rABAOQ5Lu3btCm3btk2h43i8+eabYejQoeHtt98O8+fPD3v37g033HBDus6xLF26NJ13uDVr1oTNmzeXulzTp09P3WyjR48O7777bjq/d+/eYcuWLcf1vQAA55dSjVmKXVNxO15z584tsT9t2rTUwrRy5crw9a9//YjzDxw4kMJVHGD9yiuvhEqVKqXjsTWqR48eKeyMHDmyVOUaN25cGDJkSBg8eHDanzRpUvjVr34Vpk6dGh566KHUKnVoS1K83alTp+P+XgGA8qVMxixt3749fa1Vq9ZR769YsWJ4/fXXw3vvvRfuuOOOFJ4++uijFJRiF97RgtLx2LNnTwpovXr1KvFccX/ZsmVpPwaj1atXp5C0c+fOMGfOnNTydDSxBat169apixEAKJ/OeFiKweeBBx4I1113XbjyyiuPeV5s4Vm0aFF46623wm233ZaCUgw1EydOLPVzb9u2Lezfvz/Ur1+/xPG4v2nTpnS7qKgojB07NnTv3j20a9cuPPjgg8ecCRdbv2K34DvvvFPqMgEAZ7czvnRADBix5SaGoC/SuHHj8OKLL4Zu3bqF5s2bhylTpqSB26dbv3790gYAcEZblu6777604GNcw+iyyy77wvPjQO677747zXDbvXt3GDZs2Ek9f506ddL4p8MHiMf9Bg0anNS1AYDy6YyEpUKhkILSzJkzU9das2bNjqvLrGfPnqFVq1ZhxowZYeHChWkm24gRI0pdjsqVK6dFJuO1Du0WjPtdunQp9XUBgPKrVN1wceDzunXrDu6vX78+rFq1Kg3Yjl1nzzzzTApGxaEkdr29/PLL4bXXXktrLRWPD4orZFetWvWI68cAE2e1NWnSJAWkOI4oDqSOyw7EsUtx7aOjtTJ9UbmiOJNu0KBBoUOHDmkw9/jx49OSA8Wz4wAATjosrVixIg2ALhYDSBRDSFwWILYKxdlrxYoHZV9//fUlrvP888+HO++884jrxxlqY8aMCV27dk2tQcXimkgLFiwIdevWLVW5ooEDB4atW7eGUaNGpdAWB3HHpQ0OH/QNABBVKMQ+Mk7Kjh07UitZXBKhRo0aahPOoN179oXWo95It9c82jtUq1x0TlwbOHfev302HABAhrAEAJAhLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEsAABnCEgBAhrAEAJAhLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEsAABnCEgBAhrAEAJAhLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEsAABnCEgBAhrAEAJAhLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEsAABnCEgBAhrAEAJAhLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEsAABnCEgBAhrAEAJAhLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEsAABnCEgBAhrAEAJAhLAEAZAhL/9/s2bNDy5YtQ4sWLcLkyZNzdQYAnEeKyroAZ4N9+/aF4cOHh8WLF4eaNWuG9u3bhwEDBoTatWuXddEAgDKmZSmEsHz58tCmTZvQqFGjUL169dCnT58wb968sv7ZAABngXLRsrRkyZLw5JNPhpUrV4ZPP/00zJw5M/Tv37/EORMmTEjnbNq0KbRt2zY8/fTToVOnTum+jRs3pqBULN7esGHDGf8+oKwVCoXwx737T/vzVL2gUqhQoUI4l+zec3rq5VysC/yunG/KRVjatWtXCkB33XVXuPnmm4+4f/r06ambbdKkSaFz585h/PjxoXfv3mHt2rWhXr16J/x8n3/+edqK7dix46S/BzgbxKDUetQbp/151jzaO1SrfG7999PhsQWn5brnYl3gd+V8Uy664WK32WOPPZbGGR3NuHHjwpAhQ8LgwYND69atU2iqVq1amDp1arq/YcOGJVqS4u147Fgef/zxNLapeLv88stPw3cFAJwNyv2fM3v27Endcw8//PDBYxUrVgy9evUKy5YtS/uxO2716tUpJMXwM2fOnPDII48c85rxWrGl6tCWJYGJ8mbF3/UK1SpXOqXdWKerdeZ0iV1kseXnVDsX64Jj87tS/pX7sLRt27awf//+UL9+/RLH4/4HH3yQbhcVFYWxY8eG7t27hwMHDoSRI0dmZ8JdeOGFaYPyLAal8717KI4lOt/rgC/md6X887/A/9evX7+0AQCUuzFLOXXq1AmVKlUKmzdvLnE87jdo0KDMygUAnBvKfViqXLlyWmRy4cKFB4/Frra436VLlzItGwBw9isX3XA7d+4M69atO7i/fv36sGrVqlCrVq3QuHHjNBh70KBBoUOHDmkwd1w6IC43EGfHAQCU+7C0YsWKNDi7WPFMtRiQpk2bFgYOHBi2bt0aRo0alRalbNeuXZg7d+4Rg74BAMplWLr++uvTysM59913X9oAAE5EuR+zBABwMoQlAIAMYQkAIENYAgDOWoVCIcyYMSP87//+b5mVQVgCAM5aq1evDrfcckto2rRp+tzWsghNwhIAcNbau3dv+nrDDTeEcePGlUloEpYAgLPe9773vbTo9D333HPGQ1O5WGeprBWv8bRjx46yLgqclN179oUDn+8++HreV7norL/26Szz6XIulplz/3flXP6UjmL16tULP/rRj8KIESPCP/7jP6bQ9OMf/zgFqL/5m78JNWvWDCei+H37i9ZqrFD4ojP4Qv/zP/8TLr/8cjUFAKfJypUrw7XXXnvEeKYePXqkT+k4GZ988km47LLLjnn/+R1XT5GGDRumir744otDhQoVQnkU03cMhPH7rFGjRlkX55ymLtXl2cprU12ejZYuXRr+/M//vMSxLVu2hCeffDL80z/9U6hUqVL47ne/W6qWpdhe9Nlnn6X38Rxh6RSoWLFiNpGWJzEoCUvq8mzjdak+z1ZemyfvoosuOmZIip8FO2zYsFCrVq1SX/94ApawBACc9caMGRPmzJlzykLSiRCWAICz1gUXXJC+zps374yHpGLCEsflwgsvDKNHj05fOTnq8tRRl6eW+lSXZ6NrrrkmfOMb3wjjx48Pl156aZmUwWw4AIAMi1ICAGQISwAAGcISAECGsAQAkCEsUcKSJUtC375902qmcTXyWbNmHbHa6ahRo9KMhKpVq4ZevXqF3/72t2rxKB5//PHQsWPHtLJ7/Dyj/v37h7Vr15Y45//+7//C0KFDQ+3atUP16tXDLbfcEjZv3qw+DzNx4sRw9dVXH1zgr0uXLmm9FfV4cp544on0e/7AAw+oy1L4+7//+1R/h25XXHGFuiylDRs2hG9961vp/8P4/nLVVVeFFStWnBXvP8ISJezatSu0bds2TJgw4ag1Ez/A8KmnngqTJk0K//7v/55WVu3du3d606ekN998MwWht99+O8yfPz/s3bs33HDDDamOi8X1Qn75y1+GV199NZ2/cePGcPPNN6vKw8QV8uMbe/xsqPifZ/wsqJtuuin853/+p3ospXfeeSc8++yzKYQeymvyxLRp0yZ8+umnB7e33npLXZbC73//+3DdddelNZXiH0Jr1qwJY8eODZdccsnZ8f4TP0gXjia+PGbOnHlw/8CBA4UGDRoUnnzyyYPH/vCHPxQuvPDCwk9/+lOV+AW2bNmS6vTNN988WHcXXHBB4dVXXz14zvvvv5/OWbZsmfr8Apdccklh8uTJ6rEUPvvss0KLFi0K8+fPL3Tr1q1w//33e02WwujRowtt27Y96n1+v0/M3/7t3xa+9rWvHfP+sn7/0bLEcVu/fn3YtGlTavo89DN1OnfuHJYtW6Ymv8D27dvT1+KVZ2MrSWxtOrQ+YxN+48aN1WfG/v37wyuvvJJa6GJ3nHo8cbHF88Ybbyzx2vOaLJ3YDRSHLTRv3jzcfvvt4eOPP1aXpfCLX/widOjQIdx6661p2EJciPK55547a95/hCWOW3yhRvXr1y9xPO4X38fRHThwII0Lic3MV1555cH6rFy5cvjSl76kPo/Db37zmzSuK64yfc8994SZM2eG1q1bq8cTFIPmu+++m8bUHc5r8sTEN+pp06aFuXPnpnF18Q29a9eu6VPs1eWJ+d3vfpfqsEWLFuGNN94I9957b/jOd74TXnjhhbPi/cfHncAZ+kt+9erVJcYzcGJatmwZVq1alVrofv7zn4dBgwalcV4cv08++STcf//9aQxdlSpVVN1J6tOnz8HbcexXDE9NmjQJP/vZz9IAZE7sD8rYshQ/LDeKLUvx/8w4Pin+rpc1LUsctwYNGqSvh8/WivvF93Gk++67L8yePTssXrw4DVQ+tD737NkT/vCHP6jP4xBb4b785S+H9u3bp1aROBHhxz/+sXo8AbHLcsuWLeHaa68NRUVFaYuBMw6ajbfjX+lek6UXW4m/8pWvhHXr1nldnqA4wy22FB+qVatWB7s1y/r9R1jiuDVr1iy9KBcuXHjw2I4dO9KshDh2hJLiGPkYlGJ30aJFi1L9HSq+6ceZH4fWZ1xaIP7noD6P7y/Rzz//XD2egJ49e6buzNhCV7zFv+bjWJvi216Tpbdz587w0UcfpTd+v98nJg5ROHxplQ8//DC11J0V7z+nfQg559wsmffeey9t8eUxbty4dPu///u/0/1PPPFE4Utf+lLhtddeK/zHf/xH4aabbio0a9as8Mc//rGsi37Wuffeews1a9Ys/Ou//mvh008/Pbjt3r374Dn33HNPoXHjxoVFixYVVqxYUejSpUvaKOmhhx5KswjXr1+fXndxv0KFCoV58+apx5N06Gw4r8kT8+CDD6bf7/i6XLp0aaFXr16FOnXqpJmv6vLELF++vFBUVFT4wQ9+UPjtb39beOmllwrVqlUr/Mu//MvBc8ry/UdYooTFixenkHT4NmjQoIPTNx955JFC/fr105TNnj17FtauXasWj/bLdZR6jNvzzz9/8Jz4S/7tb387TYOP/zEMGDAgBSpKuuuuuwpNmjQpVK5cuVC3bt30uisOSurx1IYlr8njN3DgwMKll16aXpeNGjVK++vWrVOXpfTLX/6ycOWVV6b3liuuuKLwk5/8pMT9Zfn+UyH+c/rbrwAAzk3GLAEAZAhLAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQBkCEvAeevOO+8MFSpUOGL7sz/7s+N6/H/913+l8+OH0ALlV1FZFwCgLMVg9Pzzz5c4duGFF5ZZeYCzj5Yl4LwWg1GDBg1KbJdcckm6L7YaTZw4MfTp0ydUrVo1NG/ePPz85z8/+NhmzZqlr9dcc0069/rrry+z7wM4fYQlgIxHHnkk3HLLLeHXv/51uP3228M3v/nN8P7776f7li9fnr4uWLAgfPrpp2HGjBnqEsohYQk4r82ePTtUr169xDZmzJiD9996663hr/7qr8JXvvKV8P3vfz906NAhPP300+m+unXrpq+1a9dOLVK1atUqs+8DOH2MWQLOa927d09dbYc6NPR06dKlxH1x34BuOL8IS8B57aKLLgpf/vKXy7oYwFlMNxxAxttvv33EfqtWrdLtypUrp6/79+9Xh1COaVkCzmuff/552LRpU4ljRUVFoU6dOun2q6++msYpfe1rXwsvvfRSGtQ9ZcqUdF+9evXSLLm5c+eGyy67LFSpUiXUrFmzTL4P4PTRsgSc12LQufTSS0tsMRgV+4d/+IfwyiuvhKuvvjr88z//c/jpT38aWrdufTBUPfXUU+HZZ58NDRs2DDfddFMZfifA6VKhUCgUTtvVAc5hce2kmTNnhv79+5d1UYAypGUJACBDWAIAyDDAG+AYjFIAIi1LAAAZwhIAQIawBACQISwBAGQISwAAGcISAECGsAQAkCEsAQCEY/t/8PvnY73GdXcAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "hs[0][:, 4].plot1d(yerr=0)\n", "plt.yscale(\"log\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "328c05ef-6ddf-478d-93f2-c260436b4b0e", "metadata": {}, "source": [ "Because this automatic bining doesn't look great, for $P_T$ at least, the user has the ability to customize the axes or pass in their own axes objects." ] }, { "cell_type": "code", "execution_count": 18, "id": "10c5faad-e4a0-458c-9097-26acee2bba12", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on method plot_vars in module coffea.analysis_tools:\n", "\n", "plot_vars(\n", " vars,\n", " axes=None,\n", " bins=None,\n", " start=None,\n", " stop=None,\n", " edges=None,\n", " transform=None,\n", " weighted=None,\n", " scale=None,\n", " categorical=None\n", ") method of coffea.analysis_tools.NminusOne instance\n", " Plot the histograms of variables for each step of the N-1 selection\n", "\n", " Parameters\n", " ----------\n", " vars : dict\n", " A dictionary in the form ``{name: array}`` where ``name`` is the name of the variable,\n", " and ``array`` is the corresponding array of values.\n", " The arrays must be the same length as each mask of the N-1 selection.\n", " axes : list of hist.axis objects, optional\n", " The axes objects to histogram the variables on. This will override all the following arguments that define axes.\n", " Must be the same length as ``vars``.\n", " bins : iterable of integers or Nones, optional\n", " The number of bins for each variable histogram. If not specified, it defaults to 20.\n", " Must be the same length as ``vars``.\n", " start : iterable of floats or integers or Nones, optional\n", " The lower edge of the first bin for each variable histogram. If not specified, it defaults to the minimum value of the variable array.\n", " Must be the same length as ``vars``.\n", " stop : iterable of floats or integers or Nones, optional\n", " The upper edge of the last bin for each variable histogram. If not specified, it defaults to the maximum value of the variable array.\n", " Must be the same length as ``vars``.\n", " edges : list of iterables of floats or integers, optional\n", " The bin edges for each variable histogram. This overrides ``bins``, ``start``, and ``stop`` if specified.\n", " Must be the same length as ``vars``.\n", " transform : iterable of hist.axis.transform objects or Nones, optional\n", " The transforms to apply to each variable histogram axis. If not specified, it defaults to None.\n", " Must be the same length as ``vars``.\n", " weighted : bool, optional\n", " Whether to fill the histograms with weights. Default is None, which applies the weights\n", " if the nminusone was instantiated with weights and unweighted distributions otherwise.\n", " scale: float, optional\n", " A scalar value by which all weights will be scaled, works with both weighted and unweighted methods.\n", " categorical : dict, optional\n", " A dictionary with the following keys:\n", " axis : hist.axis object\n", " The axis to be used as a categorical axis\n", " values : list\n", " The array to be filled in the categorical axis, must be the same length as the masks\n", " labels : list\n", " The labels corresponding to the values in the categorical axis\n", " Default is None, which does not apply any categorical axis.\n", "\n", " Returns\n", " -------\n", " hists : list of hist.Hist or hist.dask.Hist objects\n", " A list of 2D histograms of the variables for each step of the N-1 selection.\n", " The first axis is the variable, the second axis is the N-1 selection step.\n", " labels : list of strings\n", " The bin labels of y axis of the histogram.\n", " catlabels : list of strings, optional\n", " The labels of the categorical axis\n", "\n" ] } ], "source": [ "help(nminusone.plot_vars)" ] }, { "cell_type": "markdown", "id": "5c3cd75f-858b-41a3-8b0b-060361a51eba", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Cutflow is implemented in a similar manner to the N-1 selection. We just have to use the `cutflow(*names)` function which will return a `Cutflow` object" ] }, { "cell_type": "code", "execution_count": 19, "id": "a856a24d-487d-4308-8236-4f89bb5917ca", "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "Cutflow(selections=('noMuon', 'twoElectron', 'leadPt20'), commonmasked=False, weighted=False, weightsmodifier=None)" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cutflow = selection.cutflow(\"noMuon\", \"twoElectron\", \"leadPt20\")\n", "cutflow" ] }, { "cell_type": "markdown", "id": "ec84e2a3-b2ab-4352-b716-d568814f3300", "metadata": {}, "source": [ "The methods of this object are similar to the `NminusOne` object. The only difference is that now we seperate things in either \"onecut\" or \"cutflow\". \"onecut\" represents results where each cut is applied alone, while \"cutflow\" represents results where the cuts are applied cumulatively in order." ] }, { "cell_type": "code", "execution_count": 20, "id": "96692df8-d25b-4e57-9eea-59acdc1a7f78", "metadata": { "slideshow": { "slide_type": "slide" }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ('labels', 'nevonecut', 'nevcutflow', 'masksonecut', 'maskscutflow')\n" ] }, { "data": { "text/plain": [ "(['initial', 'noMuon', 'twoElectron', 'leadPt20'],\n", " [40, np.int64(28), np.int64(5), np.int64(17)],\n", " [40, np.int64(28), np.int64(5), np.int64(3)],\n", " [array([ True, True, True, True, False, False, False, True, True,\n", " True, False, True, True, True, False, True, True, True,\n", " True, True, True, True, True, False, False, True, False,\n", " True, False, True, False, False, True, True, False, True,\n", " True, True, True, True]),\n", " array([False, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " True, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, False, False]),\n", " array([False, True, True, False, True, True, True, False, False,\n", " True, False, False, False, False, False, True, True, False,\n", " False, False, True, True, False, True, True, False, True,\n", " True, False, True, False, True, False, True, False, False,\n", " False, False, False, False])],\n", " [array([ True, True, True, True, False, False, False, True, True,\n", " True, False, True, True, True, False, True, True, True,\n", " True, True, True, True, True, False, False, True, False,\n", " True, False, True, False, False, True, True, False, True,\n", " True, True, True, True]),\n", " array([False, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " True, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, False, False]),\n", " array([False, False, True, False, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, False, False])])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "res = cutflow.result()\n", "print(type(res), res._fields)\n", "labels, nevonecut, nevcutflow, masksonecut, maskscutflow = res\n", "labels, nevonecut, nevcutflow, masksonecut, maskscutflow" ] }, { "cell_type": "markdown", "id": "e2a06c5f-23d0-4ad0-ab36-dfec7796b8d4", "metadata": {}, "source": [ "As you can see, again we have the same `labels`, `nev` and `masks` only now we have two \"versions\" of them since they've been split into \"onecut\" and \"cutflow\".\n", "You can again print the statistics of the cutflow exactly like `RDataFrame`." ] }, { "cell_type": "code", "execution_count": 21, "id": "4db657a5-f16f-4fef-9956-649269e4ae2c", "metadata": { "slideshow": { "slide_type": "slide" }, "tags": [] }, "outputs": [ { "data": { "text/html": [ "
\n",
       "Cutflow selection stats:\n",
       "
\n" ], "text/plain": [ "\n", "\u001b[38;2;230;159;0mCutflow selection stats:\u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut noMuon              :pass = 28                  cumulative pass = 28                  all = 40                 \n",
       "-- eff = 70.0 %                    -- cumulative eff = 70.0 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mnoMuon \u001b[0m:pass = \u001b[1;36m28\u001b[0m cumulative pass = \u001b[1;36m28\u001b[0m all = \u001b[1;36m40\u001b[0m \n", "-- eff = \u001b[1;36m70.0\u001b[0m % -- cumulative eff = \u001b[1;36m70.0\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut twoElectron         :pass = 5                   cumulative pass = 5                   all = 40                 \n",
       "-- eff = 12.5 %                    -- cumulative eff = 12.5 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mtwoElectron \u001b[0m:pass = \u001b[1;36m5\u001b[0m cumulative pass = \u001b[1;36m5\u001b[0m all = \u001b[1;36m40\u001b[0m \n", "-- eff = \u001b[1;36m12.5\u001b[0m % -- cumulative eff = \u001b[1;36m12.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut leadPt20            :pass = 17                  cumulative pass = 3                   all = 40                 \n",
       "-- eff = 42.5 %                    -- cumulative eff = 7.5 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mleadPt20 \u001b[0m:pass = \u001b[1;36m17\u001b[0m cumulative pass = \u001b[1;36m3\u001b[0m all = \u001b[1;36m40\u001b[0m \n", "-- eff = \u001b[1;36m42.5\u001b[0m % -- cumulative eff = \u001b[1;36m7.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "cutflow.print()" ] }, { "cell_type": "markdown", "id": "e6aa8edf-3953-410d-b46f-f7d54adda821", "metadata": {}, "source": [ "Again, you can extract yield hists, only now there are two of them." ] }, { "cell_type": "code", "execution_count": 22, "id": "e9e3db1b-8836-4a85-8e56-5819134b7343", "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "honecut, hcutflow, labels = cutflow.yieldhist()\n", "\n", "honecut.plot1d(yerr=0)\n", "plt.xticks(plt.gca().get_xticks(), labels, rotation=45)\n", "plt.show()\n", "\n", "hcutflow.plot1d(yerr=0)\n", "plt.xticks(plt.gca().get_xticks(), labels, rotation=45)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "b7faec21-57c7-477d-9f7b-1a22c06c0754", "metadata": {}, "source": [ "Saving to `.npz` files is again there." ] }, { "cell_type": "code", "execution_count": 23, "id": "ecc3be33-da27-4845-bba2-f163729670ce", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "labels: ['initial' 'noMuon' 'twoElectron' 'leadPt20']\n", "nevonecut: [40 28 5 17]\n", "nevcutflow: [40 28 5 3]\n", "masksonecut: [[ True True True True False False False True True True False True\n", " True True False True True True True True True True True False\n", " False True False True False True False False True True False True\n", " True True True True]\n", " [False False True True False False False False False False False False\n", " False False False False False False True False True True False False\n", " False False False False False False False False False False False False\n", " False False False False]\n", " [False True True False True True True False False True False False\n", " False False False True True False False False True True False True\n", " True False True True False True False True False True False False\n", " False False False False]]\n", "maskscutflow: [[ True True True True False False False True True True False True\n", " True True False True True True True True True True True False\n", " False True False True False True False False True True False True\n", " True True True True]\n", " [False False True True False False False False False False False False\n", " False False False False False False True False True True False False\n", " False False False False False False False False False False False False\n", " False False False False]\n", " [False False True False False False False False False False False False\n", " False False False False False False False False True True False False\n", " False False False False False False False False False False False False\n", " False False False False]]\n" ] } ], "source": [ "cutflow.to_npz(\"cutflow_results.npz\").compute()\n", "\n", "with np.load(\"cutflow_results.npz\") as f:\n", " for i in f.files:\n", " print(f\"{i}: {f[i]}\")" ] }, { "cell_type": "markdown", "id": "423a72e7-79f6-4e6c-ab59-b2d709e3f9a0", "metadata": {}, "source": [ "And finally, `plot_vars` is also there with the same axes customizability while now it returns two lists of histograms, one for \"onecut\" and one for \"cutflow\". Those can of course be plotted in a similar fashion." ] }, { "cell_type": "code", "execution_count": 24, "id": "22454105-13f9-4f22-9450-9915cab46759", "metadata": { "slideshow": { "slide_type": "slide" }, "tags": [] }, "outputs": [ { "data": { "text/plain": [ "([Hist(\n", " Regular(20, 5.81891, 60.0685, name='ept'),\n", " Integer(0, 4, name='onecut'),\n", " storage=Double()) # Sum: 69.0 (73.0 with flow),\n", " Hist(\n", " Regular(20, -2.93115, 3.11865, name='ephi'),\n", " Integer(0, 4, name='onecut'),\n", " storage=Double()) # Sum: 73.0],\n", " [Hist(\n", " Regular(20, 5.81891, 60.0685, name='ept'),\n", " Integer(0, 4, name='cutflow'),\n", " storage=Double()) # Sum: 59.0 (63.0 with flow),\n", " Hist(\n", " Regular(20, -2.93115, 3.11865, name='ephi'),\n", " Integer(0, 4, name='cutflow'),\n", " storage=Double()) # Sum: 63.0],\n", " ['initial', 'noMuon', 'twoElectron', 'leadPt20'])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "h1, h2, labels = cutflow.plot_vars({\"ept\": events.Electron.pt, \"ephi\": events.Electron.phi})\n", "h1, h2, labels" ] }, { "cell_type": "markdown", "id": "153f43de", "metadata": {}, "source": [ "## Weighted Cutflows and NMinusOnes\n", "It's also possible to apply per-event weights to a cutflow/nminusone by passing in a Weights instance, along with the `weightsmodifier` (None or the string name of the variation you want applied)" ] }, { "cell_type": "code", "execution_count": 25, "id": "a92ff201", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Cutflow(selections=('noMuon', 'twoElectron', 'leadPt20'), commonmasked=False, weighted=True, weightsmodifier=None)" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from coffea.analysis_tools import Weights\n", "\n", "weights = Weights(len(events))\n", "weights.add(\"genweight\", events.genWeight)\n", "\n", "wgtcutflow = selection.cutflow(\"noMuon\", \"twoElectron\", \"leadPt20\", weights=weights, weightsmodifier=None)\n", "wgtcutflow" ] }, { "cell_type": "code", "execution_count": 26, "id": "7dee4181", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ('labels', 'nevonecut', 'nevcutflow', 'masksonecut', 'maskscutflow', 'commonmask', 'wgtevonecut', 'wgtevcutflow', 'weights', 'weightsmodifier')\n" ] }, { "data": { "text/plain": [ "(['initial', 'noMuon', 'twoElectron', 'leadPt20'],\n", " [40, np.int64(28), np.int64(5), np.int64(17)],\n", " [40, np.int64(28), np.int64(5), np.int64(3)],\n", " [array([ True, True, True, True, False, False, False, True, True,\n", " True, False, True, True, True, False, True, True, True,\n", " True, True, True, True, True, False, False, True, False,\n", " True, False, True, False, False, True, True, False, True,\n", " True, True, True, True]),\n", " array([False, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " True, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, False, False]),\n", " array([False, True, True, False, True, True, True, False, False,\n", " True, False, False, False, False, False, True, True, False,\n", " False, False, True, True, False, True, True, False, True,\n", " True, False, True, False, True, False, True, False, False,\n", " False, False, False, False])],\n", " [array([ True, True, True, True, False, False, False, True, True,\n", " True, False, True, True, True, False, True, True, True,\n", " True, True, True, True, True, False, False, True, False,\n", " True, False, True, False, False, True, True, False, True,\n", " True, True, True, True]),\n", " array([False, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " True, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, False, False]),\n", " array([False, False, True, False, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, True, True, False, False, False, False, False,\n", " False, False, False, False, False, False, False, False, False,\n", " False, False, False, False])],\n", " None,\n", " [np.float64(578762.435546875),\n", " np.float64(315450.423828125),\n", " np.float64(25807.2109375),\n", " np.float64(237244.12109375)],\n", " [np.float64(578762.435546875),\n", " np.float64(315450.423828125),\n", " np.float64(25807.2109375),\n", " np.float64(26331.201171875)],\n", " ,\n", " None)" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "res = wgtcutflow.result()\n", "print(type(res), res._fields)\n", "(labels, nevonecut, nevcutflow, masksonecut, maskscutflow, commonmask, wgtevonecut, wgtevcutflow, rweights, rmod) = res\n", "labels, nevonecut, nevcutflow, masksonecut, maskscutflow, commonmask, wgtevonecut, wgtevcutflow, rweights, rmod" ] }, { "cell_type": "markdown", "id": "b6c92745", "metadata": {}, "source": [ "The weighted cutflow by default prints with weights if included, but passing `weighted=False` or `weighted=True` allows one to explicitly toggle between the two. Additionally, the keyword `scale` permits one to scale all value uniformly, such as with a cross-section, luminosity, sum of weights, etc." ] }, { "cell_type": "code", "execution_count": 27, "id": "952a5662", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n",
       "Cutflow selection stats: (weighted)\n",
       "
\n" ], "text/plain": [ "\n", "\u001b[38;2;230;159;0mCutflow selection stats:\u001b[0m \u001b[1;4;38;2;247;72;165m(\u001b[0m\u001b[1;4;38;2;247;72;165mweighted\u001b[0m\u001b[1;4;38;2;247;72;165m)\u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut noMuon              :pass = 315450.423828125    cumulative pass = 315450.423828125    all = 578762.435546875   \n",
       "-- eff = 54.5 %                    -- cumulative eff = 54.5 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mnoMuon \u001b[0m:pass = \u001b[1;36m315450.423828125\u001b[0m cumulative pass = \u001b[1;36m315450.423828125\u001b[0m all = \u001b[1;36m578762.435546875\u001b[0m \n", "-- eff = \u001b[1;36m54.5\u001b[0m % -- cumulative eff = \u001b[1;36m54.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut twoElectron         :pass = 25807.2109375       cumulative pass = 25807.2109375       all = 578762.435546875   \n",
       "-- eff = 4.5 %                    -- cumulative eff = 4.5 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mtwoElectron \u001b[0m:pass = \u001b[1;36m25807.2109375\u001b[0m cumulative pass = \u001b[1;36m25807.2109375\u001b[0m all = \u001b[1;36m578762.435546875\u001b[0m \n", "-- eff = \u001b[1;36m4.5\u001b[0m % -- cumulative eff = \u001b[1;36m4.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut leadPt20            :pass = 237244.12109375     cumulative pass = 26331.201171875     all = 578762.435546875   \n",
       "-- eff = 41.0 %                    -- cumulative eff = 4.5 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mleadPt20 \u001b[0m:pass = \u001b[1;36m237244.12109375\u001b[0m cumulative pass = \u001b[1;36m26331.201171875\u001b[0m all = \u001b[1;36m578762.435546875\u001b[0m \n", "-- eff = \u001b[1;36m41.0\u001b[0m % -- cumulative eff = \u001b[1;36m4.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "wgtcutflow.print()" ] }, { "cell_type": "code", "execution_count": 28, "id": "552df1d2", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n",
       "Cutflow selection stats:\n",
       "
\n" ], "text/plain": [ "\n", "\u001b[38;2;230;159;0mCutflow selection stats:\u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut noMuon              :pass = 28                  cumulative pass = 28                  all = 40                 \n",
       "-- eff = 70.0 %                    -- cumulative eff = 70.0 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mnoMuon \u001b[0m:pass = \u001b[1;36m28\u001b[0m cumulative pass = \u001b[1;36m28\u001b[0m all = \u001b[1;36m40\u001b[0m \n", "-- eff = \u001b[1;36m70.0\u001b[0m % -- cumulative eff = \u001b[1;36m70.0\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut twoElectron         :pass = 5                   cumulative pass = 5                   all = 40                 \n",
       "-- eff = 12.5 %                    -- cumulative eff = 12.5 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mtwoElectron \u001b[0m:pass = \u001b[1;36m5\u001b[0m cumulative pass = \u001b[1;36m5\u001b[0m all = \u001b[1;36m40\u001b[0m \n", "-- eff = \u001b[1;36m12.5\u001b[0m % -- cumulative eff = \u001b[1;36m12.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut leadPt20            :pass = 17                  cumulative pass = 3                   all = 40                 \n",
       "-- eff = 42.5 %                    -- cumulative eff = 7.5 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mleadPt20 \u001b[0m:pass = \u001b[1;36m17\u001b[0m cumulative pass = \u001b[1;36m3\u001b[0m all = \u001b[1;36m40\u001b[0m \n", "-- eff = \u001b[1;36m42.5\u001b[0m % -- cumulative eff = \u001b[1;36m7.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "wgtcutflow.print(weighted=False)" ] }, { "cell_type": "code", "execution_count": 29, "id": "2b4b06b3", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n",
       "Cutflow selection stats: (weighted) (scaled by 0.0008639129728627657)\n",
       "
\n" ], "text/plain": [ "\n", "\u001b[38;2;230;159;0mCutflow selection stats:\u001b[0m \u001b[1;4;38;2;247;72;165m(\u001b[0m\u001b[1;4;38;2;247;72;165mweighted\u001b[0m\u001b[1;4;38;2;247;72;165m)\u001b[0m \u001b[1m(\u001b[0m\u001b[1;4;38;2;53;155;115mscaled\u001b[0m by \u001b[1;36m0.0008639129728627657\u001b[0m\u001b[1m)\u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut noMuon              :pass = 272.5217134401749   cumulative pass = 272.5217134401749   all = 500.0003762745956  \n",
       "-- eff = 54.5 %                    -- cumulative eff = 54.5 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mnoMuon \u001b[0m:pass = \u001b[1;36m272.5217134401749\u001b[0m cumulative pass = \u001b[1;36m272.5217134401749\u001b[0m all = \u001b[1;36m500.0003762745956\u001b[0m \n", "-- eff = \u001b[1;36m54.5\u001b[0m % -- cumulative eff = \u001b[1;36m54.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut twoElectron         :pass = 22.295184322312107  cumulative pass = 22.295184322312107  all = 500.0003762745956  \n",
       "-- eff = 4.5 %                    -- cumulative eff = 4.5 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mtwoElectron \u001b[0m:pass = \u001b[1;36m22.295184322312107\u001b[0m cumulative pass = \u001b[1;36m22.295184322312107\u001b[0m all = \u001b[1;36m500.0003762745956\u001b[0m \n", "-- eff = \u001b[1;36m4.5\u001b[0m % -- cumulative eff = \u001b[1;36m4.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut leadPt20            :pass = 204.95827394831554  cumulative pass = 22.74786628344207   all = 500.0003762745956  \n",
       "-- eff = 41.0 %                    -- cumulative eff = 4.5 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mleadPt20 \u001b[0m:pass = \u001b[1;36m204.95827394831554\u001b[0m cumulative pass = \u001b[1;36m22.74786628344207\u001b[0m all = \u001b[1;36m500.0003762745956\u001b[0m \n", "-- eff = \u001b[1;36m41.0\u001b[0m % -- cumulative eff = \u001b[1;36m4.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "wgtcutflow.print(weighted=True, scale=500 / 578762)" ] }, { "cell_type": "markdown", "id": "e89c75df", "metadata": {}, "source": [ "The histograms are now by default weighted, but like the print function this can be explicitly toggled between using `weighted=True|False.`There's no option to scale the histograms by a scalar, this is left to a user to do so afterwards." ] }, { "cell_type": "code", "execution_count": 30, "id": "cc9c15b1", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "whonecut, whcutflow, wlabels = wgtcutflow.yieldhist()\n", "\n", "whonecut.plot1d(yerr=0)\n", "plt.xticks(plt.gca().get_xticks(), wlabels, rotation=45)\n", "plt.show()\n", "\n", "whcutflow.plot1d(yerr=0)\n", "plt.xticks(plt.gca().get_xticks(), wlabels, rotation=45)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "9847580d", "metadata": {}, "source": [ "Saving to npz will include the weighted summary statistics by default, as well as a `commonmask`, but the actual weights (with the appropriate `weightsmodifier`) can also be saved directly, for later inspection." ] }, { "cell_type": "code", "execution_count": 31, "id": "5dd9f140", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CutflowToNpz(file=cutflow_results_weighted.npz), labels=['initial', 'noMuon', 'twoElectron', 'leadPt20'], commonmasked=False, weighted=True, weightsmodifier=None)\n" ] } ], "source": [ "npz = wgtcutflow.to_npz(\"cutflow_results_weighted.npz\", includeweights=True)\n", "print(npz)\n", "npz.compute()" ] }, { "cell_type": "code", "execution_count": 32, "id": "13c8a29a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "labels: ['initial' 'noMuon' 'twoElectron' 'leadPt20']\n", "nevonecut: [40 28 5 17]\n", "nevcutflow: [40 28 5 3]\n", "masksonecut: [[ True True True True False False False True True True False True\n", " True True False True True True True True True True True False\n", " False True False True False True False False True True False True\n", " True True True True]\n", " [False False True True False False False False False False False False\n", " False False False False False False True False True True False False\n", " False False False False False False False False False False False False\n", " False False False False]\n", " [False True True False True True True False False True False False\n", " False False False True True False False False True True False True\n", " True False True True False True False True False True False False\n", " False False False False]]\n", "maskscutflow: [[ True True True True False False False True True True False True\n", " True True False True True True True True True True True False\n", " False True False True False True False False True True False True\n", " True True True True]\n", " [False False True True False False False False False False False False\n", " False False False False False False True False True True False False\n", " False False False False False False False False False False False False\n", " False False False False]\n", " [False False True False False False False False False False False False\n", " False False False False False False False False True True False False\n", " False False False False False False False False False False False False\n", " False False False False]]\n", "wgtevonecut: [578762.43554688 315450.42382812 25807.2109375 237244.12109375]\n", "wgtevcutflow: [578762.43554688 315450.42382812 25807.2109375 26331.20117188]\n", "weights: [ 26331.20117188 26331.20117188 26331.20117188 25807.2109375\n", " 26331.20117188 26331.20117188 -26331.20117188 26067.890625\n", " 26331.20117188 26331.20117188 26331.20117188 26331.20117188\n", " 26331.20117188 -26331.20117188 26331.20117188 26331.20117188\n", " -26067.890625 26331.20117188 -26331.20117188 26331.20117188\n", " 26331.20117188 -26331.20117188 26331.20117188 26331.20117188\n", " 26331.20117188 26331.20117188 26331.20117188 26331.20117188\n", " 26331.20117188 26331.20117188 26331.20117188 26331.20117188\n", " 26331.20117188 -26331.20117188 26331.20117188 -26331.20117188\n", " 26331.20117188 -26331.20117188 26331.20117188 -26331.20117188]\n" ] } ], "source": [ "with np.load(\"cutflow_results_weighted.npz\") as f2:\n", " for i in f2.files:\n", " print(f\"{i}: {f2[i]}\")" ] }, { "cell_type": "markdown", "id": "4f9e3dfc", "metadata": {}, "source": [ "## Commonmask support in cutflows / nminusones\n", "The `commonmask` feature allows one to specify a boolean array that is applied to every individual and combination of cuts, as well as the initial counts. Orthogonal selections like a cut for channels or gen-level requirements can be specified independant of cuts applied to all channels, e.g. cuts on jet multiplicity or invariant masses, while allowing studies in individual 'channels.' This serves two purposes, one permitting the same studies with fewer masks in the PackedSelection (which in a very complex analysis might not fit into the widest storage backend) or even injecting 'external' boolean arrays, and two, allowing the single cuts and cutflows to be interpreted from more complex initial states than all events in a sample." ] }, { "cell_type": "code", "execution_count": 33, "id": "e7029385", "metadata": {}, "outputs": [], "source": [ "selection.add_multiple(\n", " {\n", " \"lheTaus\": ak.sum(np.abs(events.LHEPart.pdgId) == 15, axis=1) >= 2,\n", " \"lheMuons\": ak.sum(np.abs(events.LHEPart.pdgId) == 13, axis=1) >= 2,\n", " \"lheElectrons\": ak.sum(np.abs(events.LHEPart.pdgId) == 11, axis=1) >= 2,\n", " }\n", ")" ] }, { "cell_type": "code", "execution_count": 34, "id": "a56a4a90", "metadata": {}, "outputs": [], "source": [ "taucutflow = selection.cutflow(\"noMuon\", \"twoElectron\", \"leadPt20\", commonmask=selection.require(lheTaus=True))\n", "elecutflow = selection.cutflow(\"noMuon\", \"twoElectron\", \"leadPt20\", commonmask=selection.require(lheElectrons=True))" ] }, { "cell_type": "code", "execution_count": 35, "id": "abd4fd01", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "TAUS\n" ] }, { "data": { "text/html": [ "
\n",
       "Cutflow selection stats:\n",
       "
\n" ], "text/plain": [ "\n", "\u001b[38;2;230;159;0mCutflow selection stats:\u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut noMuon              :pass = 12                  cumulative pass = 12                  all = 18                 \n",
       "-- eff = 66.7 %                    -- cumulative eff = 66.7 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mnoMuon \u001b[0m:pass = \u001b[1;36m12\u001b[0m cumulative pass = \u001b[1;36m12\u001b[0m all = \u001b[1;36m18\u001b[0m \n", "-- eff = \u001b[1;36m66.7\u001b[0m % -- cumulative eff = \u001b[1;36m66.7\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut twoElectron         :pass = 2                   cumulative pass = 2                   all = 18                 \n",
       "-- eff = 11.1 %                    -- cumulative eff = 11.1 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mtwoElectron \u001b[0m:pass = \u001b[1;36m2\u001b[0m cumulative pass = \u001b[1;36m2\u001b[0m all = \u001b[1;36m18\u001b[0m \n", "-- eff = \u001b[1;36m11.1\u001b[0m % -- cumulative eff = \u001b[1;36m11.1\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut leadPt20            :pass = 3                   cumulative pass = 0                   all = 18                 \n",
       "-- eff = 16.7 %                    -- cumulative eff = 0.0 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mleadPt20 \u001b[0m:pass = \u001b[1;36m3\u001b[0m cumulative pass = \u001b[1;36m0\u001b[0m all = \u001b[1;36m18\u001b[0m \n", "-- eff = \u001b[1;36m16.7\u001b[0m % -- cumulative eff = \u001b[1;36m0.0\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "ELECTRONS\n" ] }, { "data": { "text/html": [ "
\n",
       "Cutflow selection stats:\n",
       "
\n" ], "text/plain": [ "\n", "\u001b[38;2;230;159;0mCutflow selection stats:\u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut noMuon              :pass = 13                  cumulative pass = 13                  all = 13                 \n",
       "-- eff = 100.0 %                    -- cumulative eff = 100.0 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mnoMuon \u001b[0m:pass = \u001b[1;36m13\u001b[0m cumulative pass = \u001b[1;36m13\u001b[0m all = \u001b[1;36m13\u001b[0m \n", "-- eff = \u001b[1;36m100.0\u001b[0m % -- cumulative eff = \u001b[1;36m100.0\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut twoElectron         :pass = 3                   cumulative pass = 3                   all = 13                 \n",
       "-- eff = 23.1 %                    -- cumulative eff = 23.1 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mtwoElectron \u001b[0m:pass = \u001b[1;36m3\u001b[0m cumulative pass = \u001b[1;36m3\u001b[0m all = \u001b[1;36m13\u001b[0m \n", "-- eff = \u001b[1;36m23.1\u001b[0m % -- cumulative eff = \u001b[1;36m23.1\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Cut leadPt20            :pass = 9                   cumulative pass = 3                   all = 13                 \n",
       "-- eff = 69.2 %                    -- cumulative eff = 23.1 %\n",
       "
\n" ], "text/plain": [ "Cut \u001b[38;2;213;94;0mleadPt20 \u001b[0m:pass = \u001b[1;36m9\u001b[0m cumulative pass = \u001b[1;36m3\u001b[0m all = \u001b[1;36m13\u001b[0m \n", "-- eff = \u001b[1;36m69.2\u001b[0m % -- cumulative eff = \u001b[1;36m23.1\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "print(\"TAUS\")\n", "taucutflow.print()\n", "print(\"ELECTRONS\")\n", "elecutflow.print()" ] }, { "cell_type": "markdown", "id": "851963d2", "metadata": {}, "source": [ "## Categorical Axis fill for `yieldhist` and `plot_vars`\n", "In order to support subdividing a sample into subsamples or different channels in an efficient manner, a complex input `categorical` is available. This is expected to be a dictionary with several key-value pairs: `axis`: a `hist.axis` type including the axis features desired; `values`: an event-by-event array of fill values that should be passed into the histogram fill, and `labels`: the human-readable bin labels matching the axis passed in." ] }, { "cell_type": "code", "execution_count": 36, "id": "e9072a2d", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import hist\n", "\n", "cwhonecut, cwhcutflow, cutlabels, catlabels = wgtcutflow.yieldhist(\n", " categorical={\"axis\": hist.axis.IntCategory([0, 41, 43], name=\"ttbarID\"), \"values\": events.genTtbarId, \"labels\": [\"X+jj\", \"X+c\", \"X+cc\"]}\n", ")\n", "\n", "cwhcutflow.plot1d(yerr=0, overlay=\"ttbarID\")\n", "plt.xticks(plt.gca().get_xticks(), wlabels, rotation=45)\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 37, "id": "89ee2204", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[StairsArtists(stairs=, errorbar=None, legend_artist=None),\n", " StairsArtists(stairs=, errorbar=None, legend_artist=None),\n", " StairsArtists(stairs=, errorbar=None, legend_artist=None),\n", " StairsArtists(stairs=, errorbar=None, legend_artist=None)]" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "wch1, wch2, wclabels, catlabels = wgtcutflow.plot_vars(\n", " {\"ept\": events.Electron.pt, \"ephi\": events.Electron.phi},\n", " axes=[hist.axis.Regular(3, 0, 60, name=\"ept\", label=r\"$p_{T}$ [GeV]\"), hist.axis.Regular(10, -3.14, 3.14, name=\"ephi\", label=r\"$\\phi\", circular=True)],\n", " categorical={\"axis\": hist.axis.IntCategory([0, 41, 43], name=\"ttbarID\"), \"values\": events.genTtbarId, \"labels\": [\"X+jj\", \"X+c\", \"X+cc\"]},\n", ")\n", "wch2[0][:, :, 0].project(\"ept\", \"cutflow\").plot1d(overlay=\"cutflow\", yerr=False)" ] }, { "cell_type": "markdown", "id": "a96edc79-1b3b-4ff9-8459-6ef28a99d629", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "In `CalVer coffea` with `mode=\"dask\"`, everything happens in a delayed fashion. Therefore, `PackedSelection` can also operate in \"dask\" and fully support `dask_awkward` arrays. Use is still the same, but everything now is\n", "a delayed `dask` type object which can be computed whenever the user wants to. This can be done by either calling `.compute()` on the object or `dask.compute(*things)`.\n", "\n", "PackedSelection can be initialized to operate in \"dask\" mode by instantiating with `None` and adding a `dask_awkward` array for the first time instead of an \"eager\" or \"virtual\" `numpy` or `awkward` array.\n", "It should be noted that we only support `dask_awkward` arrays and not `dask.array` arrays. Please convert your `dask` arrays to `dask_awkward` via `dask_awkward.from_dask_array(array)`. It is also not possible to mix materialized and delayed arrays in the same `PackedSelection`. Let's now read the same events using dask and perform the exact same things." ] }, { "cell_type": "code", "execution_count": 38, "id": "1adf0374-eee9-471b-9582-9cbbf06d2dda", "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "dask.awkward" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import dask\n", "import dask_awkward as dak\n", "\n", "fname = \"coffea/tests/samples/nano_dy.root\"\n", "dakevents = NanoEventsFactory.from_root(\n", " {fname: \"Events\"},\n", " metadata={\"dataset\": \"nano_dy\"},\n", " schemaclass=NanoAODSchema,\n", " mode=\"dask\",\n", ").events()\n", "\n", "dakevents" ] }, { "cell_type": "markdown", "id": "8cb3c5fc-8897-4860-8fb0-924655e81ef7", "metadata": {}, "source": [ "Now `dakevents` is a delayed `dask_awkward` version of our events and if we compute it we get our normal events." ] }, { "cell_type": "code", "execution_count": 39, "id": "a54d1fcc-13c6-4919-bbac-3d6c299f65ab", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
[{Electron: [], PuppiMET: {phi: 1.64, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [{deltaEtaSC: -0.0145, ...}], PuppiMET: {...}, FsrPhoton: [], ...},\n",
       " {Electron: [Electron, ...], PuppiMET: {...}, ...},\n",
       " {Electron: [Electron, ...], PuppiMET: {...}, ...},\n",
       " {Electron: [], PuppiMET: {phi: 0.538, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [{deltaEtaSC: -0.0232, ...}], PuppiMET: {...}, FsrPhoton: [], ...},\n",
       " {Electron: [{deltaEtaSC: 0.00415, ...}], PuppiMET: {...}, FsrPhoton: [], ...},\n",
       " {Electron: [], PuppiMET: {phi: 0.105, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [], PuppiMET: {phi: -0.513, ...}, FsrPhoton: [], ChsMET: ..., ...},\n",
       " {Electron: [{deltaEtaSC: 0.00813, ...}], PuppiMET: {...}, FsrPhoton: [], ...},\n",
       " ...,\n",
       " {Electron: [{deltaEtaSC: -0.00836, ...}], PuppiMET: {...}, ...},\n",
       " {Electron: [], PuppiMET: {phi: 0.612, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [{deltaEtaSC: -0.00405, ...}], PuppiMET: {...}, ...},\n",
       " {Electron: [], PuppiMET: {phi: 2.83, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [{deltaEtaSC: 0.053, ...}], PuppiMET: {...}, FsrPhoton: [], ...},\n",
       " {Electron: [], PuppiMET: {phi: 1.44, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [{deltaEtaSC: -0.00986, ...}], PuppiMET: {...}, ...},\n",
       " {Electron: [], PuppiMET: {phi: -2.92, ...}, FsrPhoton: [], ChsMET: {...}, ...},\n",
       " {Electron: [], PuppiMET: {phi: -0.415, ...}, FsrPhoton: [], ChsMET: ..., ...}]\n",
       "--------------------------------------------------------------------------------\n",
       "backend: cpu\n",
       "nbytes: 243.3 kB\n",
       "type: 40 * event
" ], "text/plain": [ ", ...] type='40 * event'>" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dakevents.compute()" ] }, { "cell_type": "markdown", "id": "bd16d282-ace9-4d86-9079-dd66a635e508", "metadata": {}, "source": [ "Now we have to use `dask_awkward` instead of `awkward` and `dakevents` instead of `events` to do the same things. Let's add the same (now delayed) arrays to PackedSelection." ] }, { "cell_type": "code", "execution_count": 40, "id": "dc25b728-7504-44fb-b920-051dab6c99d1", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PackedSelection(selections=('twoElectron', 'eleOppSign', 'noElectron', 'twoMuon', 'muOppSign', 'noMuon', 'leadPt20'), delayed_mode=True, items=7, maxitems=32)\n" ] } ], "source": [ "selection = PackedSelection()\n", "\n", "selection.add_multiple(\n", " {\n", " \"twoElectron\": dak.num(dakevents.Electron) == 2,\n", " \"eleOppSign\": dak.sum(dakevents.Electron.charge, axis=1) == 0,\n", " \"noElectron\": dak.num(dakevents.Electron) == 0,\n", " \"twoMuon\": dak.num(dakevents.Muon) == 2,\n", " \"muOppSign\": dak.sum(dakevents.Muon.charge, axis=1) == 0,\n", " \"noMuon\": dak.num(dakevents.Muon) == 0,\n", " \"leadPt20\": dak.any(dakevents.Electron.pt >= 20.0, axis=1) | dak.any(dakevents.Muon.pt >= 20.0, axis=1),\n", " }\n", ")\n", "\n", "print(selection)" ] }, { "cell_type": "markdown", "id": "49520c74-3bac-4355-b4b8-482ac38b4ae2", "metadata": {}, "source": [ "Now, the same functions will return `dask_awkward` objects that have to be computed." ] }, { "cell_type": "code", "execution_count": 41, "id": "74c43d65-824b-49e6-a6aa-aa7bef97e7d9", "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "dask.awkward" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "selection.all(\"twoElectron\", \"noMuon\", \"leadPt20\")" ] }, { "cell_type": "markdown", "id": "87ce9147-a37d-46ba-802c-f1531cd1cf3d", "metadata": {}, "source": [ "When computing those arrays we should get the same arrays that we got when operating in eager mode." ] }, { "cell_type": "code", "execution_count": 42, "id": "be4b8e7a-5ea1-45f4-b1d9-827e90331366", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[False, False, True, False, False, ..., False, False, False, False, False]\n", "[False, False, False, True, False, ..., False, False, False, False, False]\n" ] } ], "source": [ "print(selection.all(\"twoElectron\", \"noMuon\", \"leadPt20\").compute())\n", "print(selection.require(twoElectron=True, noMuon=True, eleOppSign=False).compute())" ] }, { "cell_type": "markdown", "id": "b32ece8e-90af-4808-8248-8dfe63c16a6c", "metadata": {}, "source": [ "Now, N-1 and cutflow will just return only delayed objects that must be computed." ] }, { "cell_type": "code", "execution_count": 43, "id": "4e79a6b3-55cc-4248-a1db-a076f4667278", "metadata": { "slideshow": { "slide_type": "-" }, "tags": [] }, "outputs": [ { "data": { "text/plain": [ "NminusOne(selections=('twoElectron', 'noMuon', 'leadPt20'), commonmasked=False, weighted=True, weightsmodifier=None)" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dask_weights = Weights(None)\n", "dask_weights.add(\"genweight\", dakevents.genWeight)\n", "nminusone = selection.nminusone(\"twoElectron\", \"noMuon\", \"leadPt20\", weights=dask_weights, weightsmodifier=None)\n", "nminusone" ] }, { "cell_type": "markdown", "id": "e661f0d1-f792-423c-b698-f031209a721f", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "It is again an `NminusOne` object which has the same methods." ] }, { "cell_type": "markdown", "id": "8442cbf2-6c41-4174-a011-a0c451c2feb6", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Let's look at the results of the N-1 selection in the same way" ] }, { "cell_type": "code", "execution_count": 44, "id": "dee4c70f-d6fa-4b0a-9d04-f5555ec1856f", "metadata": { "slideshow": { "slide_type": "-" }, "tags": [] }, "outputs": [ { "data": { "text/plain": [ "(['initial', 'N - twoElectron', 'N - noMuon', 'N - leadPt20', 'N'],\n", " [dask.awkward,\n", " dask.awkward,\n", " dask.awkward,\n", " dask.awkward,\n", " dask.awkward],\n", " [dask.awkward,\n", " dask.awkward,\n", " dask.awkward,\n", " dask.awkward],\n", " [dask.awkward,\n", " dask.awkward,\n", " dask.awkward,\n", " dask.awkward,\n", " dask.awkward])" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "labels, nev, masks, _, wgtev, _, _ = nminusone.result()\n", "labels, nev, masks, wgtev" ] }, { "cell_type": "markdown", "id": "fbd64ce9-fa7d-4ff6-847a-856dae236565", "metadata": {}, "source": [ "Now however, you can see that everything is a dask awkward object (apart from the labels of course). If we compute them we should get the same things as before and indeed we do:" ] }, { "cell_type": "code", "execution_count": 45, "id": "f8fc01f5-3f07-441d-b7de-44aeeaa042ca", "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "((np.int64(40), np.int64(10), np.int64(3), np.int64(5), np.int64(3)),\n", " (,\n", " ,\n", " ,\n", " ),\n", " (np.float32(578762.44),\n", " np.float32(105588.11),\n", " np.float32(26331.201),\n", " np.float32(25807.213),\n", " np.float32(26331.201)))" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dask.compute(*nev), dask.compute(*masks), dask.compute(*wgtev)" ] }, { "cell_type": "markdown", "id": "1df3b553-70b9-4785-b5f3-f44cd25889a6", "metadata": {}, "source": [ "We can again print the statistics, however for this to happen, the object must of course compute the delayed `nev` list." ] }, { "cell_type": "code", "execution_count": 46, "id": "118ee230-eb4f-44da-9dba-05ce15e7951e", "metadata": { "slideshow": { "slide_type": "-" }, "tags": [] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/iason/Dropbox/work/pyhep_dev/coffea/src/coffea/analysis_tools.py:1062: UserWarning: Printing the N-1 selection statistics is going to compute dask_awkward objects.\n", " warnings.warn(\n" ] }, { "data": { "text/html": [ "
\n",
       "N-1 selection stats: (weighted)\n",
       "
\n" ], "text/plain": [ "\n", "\u001b[38;2;230;159;0mN-\u001b[0m\u001b[1;38;2;230;159;0m1\u001b[0m\u001b[38;2;230;159;0m selection stats:\u001b[0m \u001b[1;4;38;2;247;72;165m(\u001b[0m\u001b[1;4;38;2;247;72;165mweighted\u001b[0m\u001b[1;4;38;2;247;72;165m)\u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Ignoring twoElectron         pass = 105588.109375       all = 578762.4375         -- eff = 18.2 %\n",
       "
\n" ], "text/plain": [ "Ignoring \u001b[38;2;213;94;0mtwoElectron \u001b[0mpass = \u001b[1;36m105588.109375\u001b[0m all = \u001b[1;36m578762.4375\u001b[0m -- eff = \u001b[1;36m18.2\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Ignoring noMuon              pass = 26331.201171875     all = 578762.4375         -- eff = 4.5 %\n",
       "
\n" ], "text/plain": [ "Ignoring \u001b[38;2;213;94;0mnoMuon \u001b[0mpass = \u001b[1;36m26331.201171875\u001b[0m all = \u001b[1;36m578762.4375\u001b[0m -- eff = \u001b[1;36m4.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
Ignoring leadPt20            pass = 25807.212890625     all = 578762.4375         -- eff = 4.5 %\n",
       "
\n" ], "text/plain": [ "Ignoring \u001b[38;2;213;94;0mleadPt20 \u001b[0mpass = \u001b[1;36m25807.212890625\u001b[0m all = \u001b[1;36m578762.4375\u001b[0m -- eff = \u001b[1;36m4.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
All cuts                     pass = 26331.201171875     all = 578762.4375         -- eff = 4.5 %\n",
       "
\n" ], "text/plain": [ "\u001b[38;2;230;159;0mAll cuts\u001b[0m pass = \u001b[1;36m26331.201171875\u001b[0m all = \u001b[1;36m578762.4375\u001b[0m -- eff = \u001b[1;36m4.5\u001b[0m %\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "nminusone.print(weighted=True)" ] }, { "cell_type": "markdown", "id": "e1146ee8-5fe8-4e05-8ebe-658014f613a3", "metadata": {}, "source": [ "And now if we call `result()` again, the `nev` list is materialized." ] }, { "cell_type": "code", "execution_count": 47, "id": "700e7669-0459-4e3d-b020-805562106cab", "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "[np.int64(40), np.int64(10), np.int64(3), np.int64(5), np.int64(3)]" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nminusone.result().nev" ] }, { "cell_type": "markdown", "id": "b77aa859-7ae1-4c54-9fc4-2ab516e3a483", "metadata": { "slideshow": { "slide_type": "slide" }, "tags": [] }, "source": [ "Again the histogram of your total event yields works. This time it is returns a `hist.dask.Hist` object." ] }, { "cell_type": "code", "execution_count": 48, "id": "a2c4fb20-b241-4eeb-8312-ee5a645f30b6", "metadata": { "slideshow": { "slide_type": "-" }, "tags": [] }, "outputs": [ { "data": { "text/html": [ "\n", "
\n", "
\n", "\n", "\n", "\n", "0\n", "\n", "\n", "5\n", "\n", "\n", "N-1\n", "\n", "\n", "\n", "
\n", "
\n", "Integer(0, 5, name='nminusone', label='N-1')
\n", "
\n", "Weight() Σ=WeightedSum(value=0, variance=0)\n", "\n", "
\n", "
\n", "" ], "text/plain": [ "Hist(Integer(0, 5, name='nminusone', label='N-1'), storage=Weight()) # Sum: WeightedSum(value=0, variance=0) (has staged fills)" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "h, labels = nminusone.yieldhist()\n", "h" ] }, { "cell_type": "markdown", "id": "bc992bfd-cce3-4004-9e16-275d69044745", "metadata": {}, "source": [ "It appears empty because it hasn't been computed yet. Let's do that." ] }, { "cell_type": "code", "execution_count": 49, "id": "38a6d003-fc3c-46e5-ad3b-5d343e997dc5", "metadata": { "tags": [] }, "outputs": [ { "data": { "text/html": [ "\n", "
\n", "
\n", "\n", "\n", "\n", "0\n", "\n", "\n", "5\n", "\n", "\n", "N-1\n", "\n", "\n", "\n", "
\n", "
\n", "Integer(0, 5, name='nminusone', label='N-1')
\n", "
\n", "Weight() Σ=WeightedSum(value=762820, variance=4.21972e+10)\n", "\n", "
\n", "
\n", "" ], "text/plain": [ "Hist(Integer(0, 5, name='nminusone', label='N-1'), storage=Weight()) # Sum: WeightedSum(value=762820, variance=4.21972e+10)" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "h.compute()" ] }, { "cell_type": "markdown", "id": "c36f391a-d2a6-4364-afcc-8da81d72ec90", "metadata": {}, "source": [ "Notice that this doesn't happen in place as `h` is still not computed." ] }, { "cell_type": "code", "execution_count": 50, "id": "226cd7fa-ac79-460d-aee5-856eb3362099", "metadata": { "tags": [] }, "outputs": [ { "data": { "text/html": [ "\n", "
\n", "
\n", "\n", "\n", "\n", "0\n", "\n", "\n", "5\n", "\n", "\n", "N-1\n", "\n", "\n", "\n", "
\n", "
\n", "Integer(0, 5, name='nminusone', label='N-1')
\n", "
\n", "Weight() Σ=WeightedSum(value=0, variance=0)\n", "\n", "
\n", "
\n", "" ], "text/plain": [ "Hist(Integer(0, 5, name='nminusone', label='N-1'), storage=Weight()) # Sum: WeightedSum(value=0, variance=0)" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "h" ] }, { "cell_type": "markdown", "id": "6e496df3-8846-4678-a92a-deaf0f2cafbb", "metadata": {}, "source": [ "We can again plot this histogram but we have to call plot on the computed one, otherwise it will just be empty." ] }, { "cell_type": "code", "execution_count": 51, "id": "c96c48b2-53b3-460b-8019-e9f91473aef5", "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAH3CAYAAABXSDBbAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAATd1JREFUeJzt3QmczfX+x/GPYWYYGmsGZc2WPVxLyk1kctW13ZIkWSqaXEtRSqO0jGixk+pGN4ppt0QilUyI7JJKmWIsacY+M8bv//h87//36xyGmcMwy/f1fDyOc37n951zfo/fHOf3nu+az3EcRwAAACwUlN0HAAAAkF0IQgAAwFoEIQAAYC2CEAAAsBZBCAAAWIsgBAAArEUQAgAA1iqQ3QeQk506dUp2794tl112meTLly+7DwcAAGSCTpF4+PBhKVeunAQFnbvOhyB0DhqCypcvn5lzDgAAcpj4+Hi58sorz1mGIHQOWhPknsjw8PCs/e0AAICL4tChQ6Yiw72OnwtB6Bzc5jANQQQhAAByl8x0a6GzNAAAsBZBCAAAWIsgBAAArEUQAgAA1iIIAQAAaxGEAACAtQhCAADAWgQhAABgLYIQAACwFkEIAABYK6AglJaWJk888YRUrlxZChUqJFdddZU8/fTTZpVXlz6Ojo6WsmXLmjJt2rSRHTt2+L3OwYMHpXv37mbZimLFikmfPn3kyJEjfmU2btwo119/vRQsWNCsFzJmzJgzjic2NlZq1qxpytStW1cWLlzotz8zxwIAAOwVUBB6/vnnZerUqTJp0iTZtm2b2daAMnHiRK+Mbk+YMEGmTZsmq1atksKFC0tkZKScOHHCK6MhaMuWLbJkyRKZP3++fPnll3Lffff5LZbWtm1bqVixoqxdu1bGjh0rTz75pEyfPt0rs3LlSunWrZsJUd9995107NjR3DZv3hzQsQAAAIs5AWjfvr3Tu3dvv+c6d+7sdO/e3Tw+deqUU6ZMGWfs2LHe/sTERCc0NNR5++23zfbWrVu1+shZs2aNV+aTTz5x8uXL5/z+++9me8qUKU7x4sWd5ORkr8wjjzzi1KhRw9u+/fbbzfH4atq0qXP//fdn+lgykpSUZI5V7wEAQO4QyPU7oBqha6+9VpYuXSo//PCD2d6wYYOsWLFC2rVrZ7Z37twpCQkJpgnKVbRoUWnatKnExcWZbb3X5rDGjRt7ZbR8UFCQqbVxy7Rs2VJCQkK8MlqTs337dvnzzz+9Mr7v45Zx3yczx3K65ORkUxvlewMAAHlXgUAKP/rooyYcaL+c/Pnzmz5Dzz77rGnqUho8VEREhN/P6ba7T+9Lly7tfxAFCkiJEiX8ymg/pNNfw91XvHhxc5/R+2R0LKeLiYmRp556KpBTAgAAcrGAaoTmzp0rs2bNktmzZ8u6detk5syZ8sILL5j7vGD48OGSlJTk3eLj47P7kHKMYyknpdKjC8xNHwMAYF2N0NChQ02t0B133GG2daTWr7/+ampSevbsKWXKlDHP792714zUcul2gwYNzGMts2/fPr/XPXnypBlJ5v683uvP+HK3Myrjuz+jYzldaGiouQEAADsEVCN07Ngx05fHlzaRnTp1yjzW5iwNINqPyKVNadr3p3nz5mZb7xMTE81oMNeyZcvMa2j/HbeMjiRLTU31yugIsxo1aphmMbeM7/u4Zdz3ycyxAAAAywXSC7tnz57OFVdc4cyfP9/ZuXOn8/777zulSpVyhg0b5pUZPXq0U6xYMeejjz5yNm7c6HTo0MGpXLmyc/z4ca/MzTff7FxzzTXOqlWrnBUrVjjVqlVzunXr5je6KyIiwunRo4ezefNm55133nHCwsKcV155xSvz9ddfOwUKFHBeeOEFZ9u2bc7IkSOd4OBgZ9OmTQEdy7kwauwvR5NTnYqPzDc3fQwAQE4VyPU7oCB06NAhZ+DAgU6FChWcggULOlWqVHEef/xxv2HuOmz9iSeeMEFGh6q3bt3a2b59u9/r/PHHHyb4FClSxAkPD3d69erlHD582K/Mhg0bnOuuu868hoYvDTWnmzt3rlO9enUnJCTEqV27trNgwQK//Zk5lnMhCP2FIAQAyC0CuX7n03+yu1Yqp9KmNB1yrx2ndRZsm2kH6VrRi83jraMiJSwkoO5lAADkyOs3a40BAABrEYQAAIC1CEIAAMBaBCEAAGAtghAAALAWQQgAAFiLIAQAAKxFEAIAANYiCAEAAGsRhAAAgLUIQgAAwFoEIQAAYC2CEAAAsBZBCAAAWIsgBAAArEUQAgAA1iIIAQAAaxGEAACAtQhCAADAWgQhAABgLYIQAACwFkEIAABYiyAEAACsRRACAADWIggBAABrEYQAAIC1CEIAAMBaBCEAAGAtghAAALAWQQgAAFiLIAQAAKxFEAIAANYiCAEAAGsFFIQqVaok+fLlO+MWFRVl9p84ccI8LlmypBQpUkS6dOkie/fu9XuNXbt2Sfv27SUsLExKly4tQ4cOlZMnT/qVWb58uTRs2FBCQ0OlatWqMmPGjDOOZfLkyeZ4ChYsKE2bNpXVq1f77c/MsQAAALsFFITWrFkje/bs8W5Lliwxz992223mfvDgwTJv3jyJjY2VL774Qnbv3i2dO3f2fj4tLc2EoJSUFFm5cqXMnDnThJzo6GivzM6dO02ZVq1ayfr162XQoEHSt29fWbx4sVdmzpw5MmTIEBk5cqSsW7dO6tevL5GRkbJv3z6vTEbHAgAAIM4FGDhwoHPVVVc5p06dchITE53g4GAnNjbW279t2zZHRJy4uDizvXDhQicoKMhJSEjwykydOtUJDw93kpOTzfawYcOc2rVr+71P165dncjISG+7SZMmTlRUlLedlpbmlCtXzomJiTHbmTmWzEhKSjI/o/e2O5qc6lR8ZL656WMAAHKqQK7f591HSGt13nrrLendu7dpHlu7dq2kpqZKmzZtvDI1a9aUChUqSFxcnNnW+7p160pERIRXRmtyDh06JFu2bPHK+L6GW8Z9DX1ffS/fMkFBQWbbLZOZY0lPcnKyORbfGwAAyLvOOwh9+OGHkpiYKPfcc4/ZTkhIkJCQEClWrJhfOQ09us8t4xuC3P3uvnOV0VBy/PhxOXDggGliS6+M72tkdCzpiYmJkaJFi3q38uXLB3xeAACABUHo9ddfl3bt2km5cuUkrxg+fLgkJSV5t/j4+Ow+JAAAcBEVOJ8f+vXXX+Wzzz6T999/33uuTJkyptlKa4l8a2J0pJbuc8ucPrrLHcnlW+b00V26HR4eLoUKFZL8+fObW3plfF8jo2NJj45S0xsAALDDedUIvfHGG2bou47ucjVq1EiCg4Nl6dKl3nPbt283w+WbN29utvV+06ZNfqO7dOSZhpxatWp5ZXxfwy3jvoY2eel7+ZY5deqU2XbLZOZYAAAAAq4R0tChQahnz55SoMBfP659avr06WOGtZcoUcKEmwEDBpjg0axZM1Ombdu2JvD06NFDxowZY/rrjBgxwsz349bE9OvXTyZNmiTDhg0zHbGXLVsmc+fOlQULFnjvpe+h79+4cWNp0qSJjBs3To4ePSq9evXK9LEAAAAEPHx+8eLFZkja9u3bz9h3/Phx54EHHnCKFy/uhIWFOZ06dXL27NnjV+aXX35x2rVr5xQqVMgpVaqU89BDDzmpqf7DsT///HOnQYMGTkhIiFOlShXnjTfeOOO9Jk6c6FSoUMGU0eH033zzTcDHkhGGz/+F4fMAgNwikOt3Pv2HPJg+HammtUvacVprlWx2LOWk1Ir+36SWW0dFSljIeXUvAwAgR12/WWsMAABYiyAEAACsRRACAADWIggBAABrEYQAAIC1CEIAAMBaBCEAAGAtghAAALAWQQgAAFiLIAQAAKxFEAIAANYiCAEAAGsRhAAAgLUIQgAAwFoEIQAAYC2CEAAAsBZBCAAAWIsgBAAArEUQAgAA1iIIAQAAaxGEAACAtQhCAADAWgQhAABgLYIQAACwFkEIAABYiyAEAACsRRACAADWIggBAABrEYQAAIC1CEIAAMBaBCEAAGAtghAAALAWQQgAAFgr4CD0+++/y1133SUlS5aUQoUKSd26deXbb7/19juOI9HR0VK2bFmzv02bNrJjxw6/1zh48KB0795dwsPDpVixYtKnTx85cuSIX5mNGzfK9ddfLwULFpTy5cvLmDFjzjiW2NhYqVmzpimjx7Fw4UK//Zk5FgAAYK+AgtCff/4pLVq0kODgYPnkk09k69at8uKLL0rx4sW9MhpYJkyYINOmTZNVq1ZJ4cKFJTIyUk6cOOGV0RC0ZcsWWbJkicyfP1++/PJLue+++7z9hw4dkrZt20rFihVl7dq1MnbsWHnyySdl+vTpXpmVK1dKt27dTIj67rvvpGPHjua2efPmgI4FAABYzAnAI4884lx33XVn3X/q1CmnTJkyztixY73nEhMTndDQUOftt98221u3bnX0bdesWeOV+eSTT5x8+fI5v//+u9meMmWKU7x4cSc5OdnvvWvUqOFt33777U779u393r9p06bO/fffn+ljyUhSUpI5Vr233dHkVKfiI/PNTR8DAJBTBXL9DqhG6OOPP5bGjRvLbbfdJqVLl5ZrrrlGXn31VW//zp07JSEhwTRBuYoWLSpNmzaVuLg4s6332hymr+PS8kFBQabWxi3TsmVLCQkJ8cpoTc727dtNrZRbxvd93DLu+2TmWE6XnJxsaqN8bwAAIO8KKAj9/PPPMnXqVKlWrZosXrxY+vfvL//+979l5syZZr8GDxUREeH3c7rt7tN7DVG+ChQoICVKlPArk95r+L7H2cr47s/oWE4XExNjwpJ7075JAAAg7wooCJ06dUoaNmwozz33nKkN0n499957r+mDkxcMHz5ckpKSvFt8fHx2HxIAAMgpQUhHX9WqVcvvuauvvlp27dplHpcpU8bc792716+Mbrv79H7fvn1++0+ePGlGkvmWSe81fN/jbGV892d0LKcLDQ01I9l8bwAAIO8KKAjpiDHtp+Prhx9+MKO7VOXKlU3IWLp0qbdf+9lo35/mzZubbb1PTEw0o8Fcy5YtM7VN2n/HLaMjyVJTU70yOsKsRo0a3gg1LeP7Pm4Z930ycywAAMBygfTCXr16tVOgQAHn2WefdXbs2OHMmjXLCQsLc9566y2vzOjRo51ixYo5H330kbNx40anQ4cOTuXKlZ3jx497ZW6++WbnmmuucVatWuWsWLHCqVatmtOtWze/0V0RERFOjx49nM2bNzvvvPOOeZ9XXnnFK/P111+bY3nhhRecbdu2OSNHjnSCg4OdTZs2BXQs58Kosb8wagwAkFsEcv0OKAipefPmOXXq1DHD0GvWrOlMnz7db78OW3/iiSdMkNEyrVu3drZv3+5X5o8//jDBp0iRIk54eLjTq1cv5/Dhw35lNmzYYIbq62tcccUVJtScbu7cuU716tWdkJAQp3bt2s6CBQsCPpZzIQj9hSAEAMgtArl+59N/srtWKqfSpjQdPaYdp23vL3Qs5aTUil5sHm8dFSlhIQWy+5AAALjg6zdXs2yg2fN4aprktiCU3uPcolBwfsmXL192HwYAIIchCGUDDUFu7Upu1PgZ/07quQG1WACA9LD6PAAAsBY1Qtns2xFtJCwkv+R02hzm1gR9O6J1rugjdCwlTRo/81l2HwYAIAfL+VezPE5DUG4IFb70eHPbMQMAkB6axgAAgLUIQgAAwFoEIQAAYC2CEAAAsBZBCAAAWIsgBAAArEUQAgAA1iIIAQAAaxGEAACAtQhCAADAWgQhAABgLYIQAACwFkEIAABYiyAEAACsRRACAADWIggBAABrEYQAAIC1CEIAAMBaBCEAAGAtghAAALAWQQgAAFiLIAQAAKxFEAIAANYiCAEAAGsRhAAAgLUIQgAAwFoEIQAAYC2CEAAAsFZAQejJJ5+UfPny+d1q1qzp7T9x4oRERUVJyZIlpUiRItKlSxfZu3ev32vs2rVL2rdvL2FhYVK6dGkZOnSonDx50q/M8uXLpWHDhhIaGipVq1aVGTNmnHEskydPlkqVKknBggWladOmsnr1ar/9mTkWAABgt4BrhGrXri179uzxbitWrPD2DR48WObNmyexsbHyxRdfyO7du6Vz587e/rS0NBOCUlJSZOXKlTJz5kwTcqKjo70yO3fuNGVatWol69evl0GDBknfvn1l8eLFXpk5c+bIkCFDZOTIkbJu3TqpX7++REZGyr59+zJ9LAAAAOIEYOTIkU79+vXT3ZeYmOgEBwc7sbGx3nPbtm1zRMSJi4sz2wsXLnSCgoKchIQEr8zUqVOd8PBwJzk52WwPGzbMqV27tt9rd+3a1YmMjPS2mzRp4kRFRXnbaWlpTrly5ZyYmJhMH0tmJCUlmZ/R+6x0NDnVqfjIfHPTx7kBxwwAyC0CuX4HXCO0Y8cOKVeunFSpUkW6d+9umrrU2rVrJTU1Vdq0aeOV1WazChUqSFxcnNnW+7p160pERIRXRmtyDh06JFu2bPHK+L6GW8Z9Da1N0vfyLRMUFGS23TKZOZb0JCcnm2PxvQEAgLwroCCkfXG0KWvRokUydepU04x1/fXXy+HDhyUhIUFCQkKkWLFifj+joUf3Kb33DUHufnffucpoKDl+/LgcOHDANLGlV8b3NTI6lvTExMRI0aJFvVv58uUDOT0AACCXKRBI4Xbt2nmP69WrZ4JRxYoVZe7cuVKoUCHJ7YYPH276Hrk0fBGGAADIuy5o+LzWuFSvXl1+/PFHKVOmjGm2SkxM9CujI7V0n9L700duudsZlQkPDzdhq1SpUpI/f/50y/i+RkbHkh4dpabv43sDAAB51wUFoSNHjshPP/0kZcuWlUaNGklwcLAsXbrU2799+3bTh6h58+ZmW+83bdrkN7pryZIlJnDUqlXLK+P7Gm4Z9zW0yUvfy7fMqVOnzLZbJjPHAgAAEFDT2MMPPyy33nqraQ7T4eg6fF1rZ7p162b61PTp08c0LZUoUcKEmwEDBpjg0axZM/Pzbdu2NYGnR48eMmbMGNNfZ8SIEWa+H62NUf369ZNJkybJsGHDpHfv3rJs2TLT9LZgwQLvOPQ9evbsKY0bN5YmTZrIuHHj5OjRo9KrVy+zPzPHAgAAEFAQ+u2330zo+eOPP+Tyyy+X6667Tr755hvzWL388stmBJdOXqgjsHS015QpU7yf19A0f/586d+/vwklhQsXNoFm1KhRXpnKlSub0KPzAI0fP16uvPJKee2118xrubp27Sr79+838w9pmGrQoIHpwO3bgTqjYwEAAMinY+g5DenTztJau5SUlJSl/YWOpZyUWtH/myBy66hICQsJKI9mC44ZAJAXr9+sNQYAAKxFEAIAANYiCAEAAGsRhAAAgLUIQgAAwFoEIQAAYC2CEAAAsBZBCAAAWIsgBAAArEUQAgAA1iIIAQAAaxGEAACAtQhCAADAWgQhAABgLYIQAACwFkEIAABYiyAEAACsRRACAADWIggBAABrEYQAAIC1CEIAAMBaBCEAAGAtghAAALAWQQgAAFiLIAQAAKxFEAIAANYiCAEAAGsRhAAAgLUIQgAAwFoEIQAAYC2CEAAAsFaB7D4A5A5hIQXkl9Hts/swAADIUtQIAQAAaxGEAACAtS4oCI0ePVry5csngwYN8p47ceKEREVFScmSJaVIkSLSpUsX2bt3r9/P7dq1S9q3by9hYWFSunRpGTp0qJw8edKvzPLly6Vhw4YSGhoqVatWlRkzZpzx/pMnT5ZKlSpJwYIFpWnTprJ69Wq//Zk5FgAAYK/zDkJr1qyRV155RerVq+f3/ODBg2XevHkSGxsrX3zxhezevVs6d+7s7U9LSzMhKCUlRVauXCkzZ840ISc6Otors3PnTlOmVatWsn79ehO0+vbtK4sXL/bKzJkzR4YMGSIjR46UdevWSf369SUyMlL27duX6WMBAACWc87D4cOHnWrVqjlLlixx/v73vzsDBw40zycmJjrBwcFObGysV3bbtm2Ovk1cXJzZXrhwoRMUFOQkJCR4ZaZOneqEh4c7ycnJZnvYsGFO7dq1/d6za9euTmRkpLfdpEkTJyoqyttOS0tzypUr58TExGT6WE534sQJJykpybvFx8eb8vo4Kx1NTnUqPjLf3PQxLg7OMwDYKSkpKdPX7/OqEdLmJq2xadOmjd/za9euldTUVL/na9asKRUqVJC4uDizrfd169aViIgIr4zW5Bw6dEi2bNnilTn9tbWM+xpam6Tv5VsmKCjIbLtlMnMsp4uJiZGiRYt6t/Lly5/P6QEAALlEwEHonXfeMU1RGhpOl5CQICEhIVKsWDG/5zX06D63jG8Icve7+85VRsPS8ePH5cCBA6aJLb0yvq+R0bGcbvjw4ZKUlOTd4uPjM31eAABAHp9HSIPBwIEDZcmSJaaDcl6jHbP1BgAA7BBQjZA2N2lnZB3NVaBAAXPTTsgTJkwwj7W2RZutEhMT/X5OR2qVKVPGPNb700duudsZlQkPD5dChQpJqVKlJH/+/OmW8X2NjI4FAADYLaAg1Lp1a9m0aZMZyeXeGjduLN27d/ceBwcHy9KlS72f2b59uxku37x5c7Ot9/oavqO7tIZJQ06tWrW8Mr6v4ZZxX0ObvBo1auRX5tSpU2bbLaP7MzoWAABgt4Caxi677DKpU6eO33OFCxc28/S4z/fp08cMay9RooQJNwMGDDDBo1mzZmZ/27ZtTeDp0aOHjBkzxvTXGTFihOmA7TZL9evXTyZNmiTDhg2T3r17y7Jly2Tu3LmyYMEC7331PXr27GnCV5MmTWTcuHFy9OhR6dWrl9mvnZ0zOhYAAGC3LF9r7OWXXzYjuHTywuTkZDPaa8qUKd5+bdKaP3++9O/f34QSDVIaaEaNGuWVqVy5sgk9Og/Q+PHj5corr5TXXnvNvJara9eusn//fjP/kIapBg0ayKJFi/w6UGd0LAAAwG75dAx9dh9ETqWj1LRmSUeQaY1SVjmWclJqRf9vcsitoyLNgqbIepxnALDToQCu36w1BgAArEUQAgAA1iIIAQAAaxGEAACAtQhCAADAWgQhAABgLYIQAACwFkEIAABYiyAEAACsRRACAADWIggBAABrEYQAAIC1CEIAAMBaBCEAAGAtghAAALAWQQgAAFiLIAQAAKxFEAIAANYiCAEAAGsRhAAAgLUIQgAAwFoEIQAAYC2CEAAAsBZBCAAAWIsgBAAArEUQAgAA1iIIAQAAaxGEAACAtQhCAADAWgQhAABgLYIQAACwFkEIAABYiyAEAACsFVAQmjp1qtSrV0/Cw8PNrXnz5vLJJ594+0+cOCFRUVFSsmRJKVKkiHTp0kX27t3r9xq7du2S9u3bS1hYmJQuXVqGDh0qJ0+e9CuzfPlyadiwoYSGhkrVqlVlxowZZxzL5MmTpVKlSlKwYEFp2rSprF692m9/Zo4FAADYLaAgdOWVV8ro0aNl7dq18u2338qNN94oHTp0kC1btpj9gwcPlnnz5klsbKx88cUXsnv3buncubP382lpaSYEpaSkyMqVK2XmzJkm5ERHR3tldu7cacq0atVK1q9fL4MGDZK+ffvK4sWLvTJz5syRIUOGyMiRI2XdunVSv359iYyMlH379nllMjoWAAAAcS5Q8eLFnddee81JTEx0goODndjYWG/ftm3bHBFx4uLizPbChQudoKAgJyEhwSszdepUJzw83ElOTjbbw4YNc2rXru33Hl27dnUiIyO97SZNmjhRUVHedlpamlOuXDknJibGbGfmWNJz4sQJJykpybvFx8ebn9HHWelocqpT8ZH55qaPcXFwngHATklJSZm+fp93HyGt3XnnnXfk6NGjpolMa4lSU1OlTZs2XpmaNWtKhQoVJC4uzmzrfd26dSUiIsIrozU5hw4d8mqVtIzva7hl3NfQ2iR9L98yQUFBZtstk5ljSU9MTIwULVrUu5UvX56oDABAHhZwENq0aZPpc6P9d/r16ycffPCB1KpVSxISEiQkJESKFSvmV15Dj+5Teu8bgtz97r5zldGwdPz4cTlw4IAJYemV8X2NjI4lPcOHD5ekpCTvFh8fH+jpAQAAuUiBQH+gRo0apu+OBoV3331Xevbsafrg5AUa7vQGAADsEHAQ0poWHcmlGjVqJGvWrJHx48dL165dTbNVYmKiX02MjtQqU6aMeaz3p4/uckdy+ZY5fXSXbusotUKFCkn+/PnNLb0yvq+R0bEAAABc8DxCp06dkuTkZBOKgoODZenSpd6+7du3m+Hy2odI6b02rfmO7lqyZIkJOdq85pbxfQ23jPsaGsT0vXzL6DHotlsmM8cCAAAQUI2Q9qFp166d6XR8+PBhmT17tpnzR4e2a+fiPn36mGHtJUqUMOFmwIABJng0a9bM/Hzbtm1N4OnRo4eMGTPG9NcZMWKEme/HbZLSfkeTJk2SYcOGSe/evWXZsmUyd+5cWbBggXcc+h7aJNe4cWNp0qSJjBs3znTa7tWrl9mfmWMBAAAIKAhpTc7dd98te/bsMWFDJ1fUEHTTTTeZ/S+//LIZwaWTF2otkY72mjJlivfz2qQ1f/586d+/vwklhQsXNoFm1KhRXpnKlSub0KPzAGmTm85d9Nprr5nXcmkz3P79+838QxqmGjRoIIsWLfLrQJ3RsQAAAOTTMfSchvTpSDUNfNoxXGuVssqxlJNSK/p/E0RuHRUpYSEBd9UC5xnIFfi+Q06/frPWGAAAsBZBCAAAWIsgBAAArEUQAgAA1iIIAQAAaxGEgBw2wqbSowvMTR8DAC4ughAAALAWQQgAAFiLIAQAAKxFEAIAANYiCAEAAGsRhAAAgLUIQgAAwFoEIQAAYC2CEAAAsBZBCAAAWIsgBAAArEUQAgAA1iIIAQAAaxGEAACAtQhCAADAWgQhAABgLYIQAACwFkEIAABYiyAEAACsRRACAADWIggBAABrEYQAAIC1CEIAAMBaBCEAAGAtghAAALAWQQgAAFiLIAQAAKwVUBCKiYmRv/3tb3LZZZdJ6dKlpWPHjrJ9+3a/MidOnJCoqCgpWbKkFClSRLp06SJ79+71K7Nr1y5p3769hIWFmdcZOnSonDx50q/M8uXLpWHDhhIaGipVq1aVGTNmnHE8kydPlkqVKknBggWladOmsnr16oCPBQAA2CugIPTFF1+YYPHNN9/IkiVLJDU1Vdq2bStHjx71ygwePFjmzZsnsbGxpvzu3bulc+fO3v60tDQTglJSUmTlypUyc+ZME3Kio6O9Mjt37jRlWrVqJevXr5dBgwZJ3759ZfHixV6ZOXPmyJAhQ2TkyJGybt06qV+/vkRGRsq+ffsyfSwAAMByzgXYt2+foy/xxRdfmO3ExEQnODjYiY2N9cps27bNlImLizPbCxcudIKCgpyEhASvzNSpU53w8HAnOTnZbA8bNsypXbu233t17drViYyM9LabNGniREVFedtpaWlOuXLlnJiYmEwfy+lOnDjhJCUlebf4+HhTXh9npaPJqU7FR+abmz7GxZEbz3NuPGbgXPhMIzvodTuz1+8L6iOUlJRk7kuUKGHu165da2qJ2rRp45WpWbOmVKhQQeLi4sy23tetW1ciIiK8MlqTc+jQIdmyZYtXxvc13DLua2htkr6Xb5mgoCCz7ZbJzLGk1/RXtGhR71a+fPkLOT0AACCHO+8gdOrUKdNk1aJFC6lTp455LiEhQUJCQqRYsWJ+ZTX06D63jG8Icve7+85VRsPS8ePH5cCBA6aJLb0yvq+R0bGcbvjw4Sbcubf4+PjzOjcAACB3KHC+P6h9hTZv3iwrVqyQvEI7ZusNAADY4bxqhB588EGZP3++fP7553LllVd6z5cpU8Y0WyUmJvqV15Faus8tc/rILXc7ozLh4eFSqFAhKVWqlOTPnz/dMr6vkdGxAAAAuwUUhBzHMSHogw8+kGXLlknlypX99jdq1EiCg4Nl6dKl3nM6vF6Hyzdv3txs6/2mTZv8RnfpCDQNObVq1fLK+L6GW8Z9DW3y0vfyLaNNdbrtlsnMsQAAALsVCLQ5bPbs2fLRRx+ZuYTcvjbasVhravS+T58+Zli7dqDWcDNgwAATPJo1a2bK6nB7DTw9evSQMWPGmNcYMWKEeW23Wapfv34yadIkGTZsmPTu3duErrlz58qCBQu8Y9H36NmzpzRu3FiaNGki48aNM8P4e/Xq5R1TRscCAADsFlAQmjp1qrm/4YYb/J5/44035J577jGPX375ZTOCSycvTE5ONqO9pkyZ4pXVJi1tVuvfv78JJYULFzaBZtSoUV4ZrWnS0KPzAI0fP940v7322mvmtVxdu3aV/fv3m/mHNEw1aNBAFi1a5NeBOqNjAQAAdsunY+iz+yByKh2lpjVLOoJMa5SyyrGUk1Ir+n+TQ24dFSlhIefdZx157DznxmPOjTjPnOu8hs/0+V+/WWsMAABYiyAEAACsRRACAADWIggBAABrEYQAAIC1CEIAAMBaBCEAAGAtghAAALAWQQgAAFiLIAQAAKxFEAIAANYiCAEAAGsRhAAAgLUIQgAAwFoEIQAAYC2CEAAAsBZBCAAAWIsgBAAArEUQAgAA1iIIAQAAaxGEAACAtQhCAADAWgQhAABgLYIQAACwFkEIAABYiyAEAACsRRACAADWIggBAABrEYQAAIC1CEIAAMBaBCEAAGAtghAAALBWgew+AOBSOJaSlitO9LGUk+k+zi0KBeeXfPnyZfdhAMDFC0JffvmljB07VtauXSt79uyRDz74QDp27OjtdxxHRo4cKa+++qokJiZKixYtZOrUqVKtWjWvzMGDB2XAgAEyb948CQoKki5dusj48eOlSJEiXpmNGzdKVFSUrFmzRi6//HJTftiwYX7HEhsbK0888YT88ssv5vWff/55+cc//hHQscAOjZ/5THKbxs8sldxm66hICQvh7ysAebhp7OjRo1K/fn2ZPHlyuvvHjBkjEyZMkGnTpsmqVaukcOHCEhkZKSdOnPDKdO/eXbZs2SJLliyR+fPnm3B13333efsPHTokbdu2lYoVK5rApcHrySeflOnTp3tlVq5cKd26dZM+ffrId999Z8KY3jZv3hzQsQAAAHsF/Kdbu3btzC09WgMzbtw4GTFihHTo0ME89+abb0pERIR8+OGHcscdd8i2bdtk0aJFpqancePGpszEiRNNTc4LL7wg5cqVk1mzZklKSor85z//kZCQEKldu7asX79eXnrpJS8waQ3SzTffLEOHDjXbTz/9tAlWkyZNMsEnM8dyuuTkZHPzDWTIvbSZRmsochNtDnNrgr4d0TpX1K5os2NurHEDAJWl37I7d+6UhIQEadOmjfdc0aJFpWnTphIXF2fCh94XK1bMC0FKy2sTmdbadOrUyZRp2bKlCUEurcnRpq8///xTihcvbsoMGTLE7/21jIaczB7L6WJiYuSpp57ik5FHaF+V3BAkzkaPPTcfPwBYN2pMg4fSWhdfuu3u0/vSpUv77S9QoICUKFHCr0x6r+H7Hmcr47s/o2M53fDhwyUpKcm7xcfHB3wOAABA7sGfmz5CQ0PNDQAA2CFLa4TKlClj7vfu3ev3vG67+/R+3759fvtPnjxpRpL5lknvNXzf42xlfPdndCwAAMBuWRqEKleubELG0qVL/Toca9+f5s2bm22916HsOhrMtWzZMjl16pTpv+OW0ZFkqampXhntCF2jRg3TP8gt4/s+bhn3fTJzLAAAwG4BB6EjR46YEVx6czsl6+Ndu3aZzqmDBg2SZ555Rj7++GPZtGmT3H333WYkmDvX0NVXX21Ge917772yevVq+frrr+XBBx80nZe1nLrzzjtNR2kdGq/D7OfMmWNGifl2jh44cKAZffbiiy/K999/b4bXf/vtt+a1VGaOBQAA2C3gPkIaNlq1auVtu+GkZ8+eMmPGDDPpoc41pMPctebnuuuuM4GlYMGC3s/o8HgNLK1bt/YmVNT5fnxHd3366admQsVGjRpJqVKlJDo62m+uoWuvvVZmz55thsc/9thjZpJEHTFWp04dr0xmjgUAANgr4CB0ww03mDl6zkZrYkaNGmVuZ6MjxDTEnEu9evXkq6++OmeZ2267zdwu5FgAAIC9WHQVAABYiyAEAACsRRACAADWIggBAABrEYQAAIC1CEIAAMBaBCEAAGAtghAAALAWQQgAAFiLIAQAAKxFEAIAANYiCAEAAGsRhAAAgLUIQgAAwFoEIQAAYC2CEAAAsBZBCAAAWIsgBAAArEUQAgAA1iIIAQAAaxGEAACAtQhCAADAWgQhAABgrQLZfQAA/hIWUkB+Gd0+156SYylpkhscSzmZ7mNwrnOr3P6ZLhScX/Lly5ct700QApBlGj/zWa47m42fWZrdh2ANzjXn+Wy2joo0fwhmB5rGAACAtagRAnDBVdr611xuok0Hbu3EtyNaZ9tfojbgXHOez9WUnhNqkfnfD+CCaLt+bg4Seuy5+fhzE8415zknomkMAABYiyAEAACsRRACAADWIggBAABrEYQAAIC1rAhCkydPlkqVKknBggWladOmsnr16uw+JAAAkAPk+SA0Z84cGTJkiIwcOVLWrVsn9evXl8jISNm3b192HxoAAMhmeT4IvfTSS3LvvfdKr169pFatWjJt2jQJCwuT//znP9l9aAAAIJvl6VnEUlJSZO3atTJ8+HDvuaCgIGnTpo3ExcWdUT45OdncXElJSeb+0KFDWT7T6qnkY95rn2QyN+CS4v8g5zqvyY2f6WMX8Zjd67bjOBmWzfln6gIcOHBA0tLSJCIiwu953f7+++/PKB8TEyNPPfXUGc+XL1/+oh1j2XEX7aUB8H8wR+H7jvN8qT8bhw8flqJFi9obhAKlNUfan8h16tQpOXjwoJQsWdIsI2A7TdgaCuPj4yU8PDy7DyfP4jxznvMaPtOc50tNa4I0BJUrVy7Dsnk6CJUqVUry588ve/fu9Xtet8uUKXNG+dDQUHPzVaxYsYt+nLmNhiCCEOc5r+DzzLnOa/hM/09GNUFWdJYOCQmRRo0aydKl/1tl2q3l0e3mzZtn67EBAIDsl6drhJQ2dfXs2VMaN24sTZo0kXHjxsnRo0fNKDIAAGC3PB+EunbtKvv375fo6GhJSEiQBg0ayKJFi87oQI2MabOhzsd0evMhshbn+dLgPF86nGvOc06Wz8nM2DIAAIA8KE/3EQIAADgXghAAALAWQQgAAFiLIAQAAKxFEAIA5HqM+8H5IgghS+zbt8+bsBIALjb3u+b48ePm/tix/y3eaaNff/2VIHgBCEK4YO+9955ZsmT9+vUSFBREGMojf1W7j/lL+/zPoYs/ELKWnk/9rtm8ebOZK65p06bSpUsXeeutt8Q2ycnJcscdd0iVKlX4v3qeCEK4YM2aNZNbb71V2rZtKxs2bCAM5eILuC4u/Omnn8qgQYOkb9++smnTJhYcPo9z+PXXX8u0adNkypQp5jm9aCPr6Pn88ccf5frrr5eKFSvKzTffLFdddZXcfffd8uCDD5rJc22hS0mNHTtWihQpYpaU4g+X86ATKgIXas+ePU6nTp2c4sWLO+vXrzfPpaWlcWJzmYULFzqFChVybrnlFueaa65xwsLCnFmzZjmpqanZfWi5xvvvv2/OW/369Z3LL7/cqV27thMfH5/dh5XnPP/8807Lli39nps/f74TEhLi9OrVy/nzzz8dW+h3bVxcnFOzZk3z//bUqVPZfUi5Cn+mIEto09jkyZPlhhtukFatWlEzlAsdOnRIVq1aZdbjmzdvnqxbt06ioqLMunxvv/22nDx5MrsPMcdy/wrXZor58+fL1KlTTa3Ql19+aVbAvvHGG+WXX37J7sPMU/744w+/5lv9fLZv314++eQTmTVrlowfP17yKq3x+uabb/xqyLQ2aObMmXLkyBFqhgJEEEKWKVu2rEycOJEwlAtpk+aVV14pH374oQm1rjFjxsjAgQNNM9mcOXMIQ2ehzWFfffWV6auiaxtec801UrhwYalZs6bExsZK6dKl5aabbjKdWnF+Tm/y0XMdFxcnK1asMOc/f/78kpaWZkKnBlFtLvr222/z3OmOj4+XOnXqyLXXXmv+6Hzsscdk2bJlptO4LiyuIVDpupo0k2UOQQjnxf0Ppl/s+pfutm3bzPYVV1xhaob+/ve/UzOUi+gXa+fOnWXjxo2yd+9ev9+xhqEhQ4ZIjx49TMd4pE+Dj16IFy9ebC7KbqfecuXKydy5c83/jYYNG8quXbs4hQFwO5pr2PHVokUL00H68ccfNwM1dL9bpnXr1lKqVKk8WQun56N8+fJSvXp1U/uze/duUxOm37naR2rnzp0yfPhwUzup54EwlAnZ3TaH3Mdtf/7www9N/4fq1as7pUuXdmJiYrx92meoY8eO5vlvv/02m48Yme1ncNdddzlFixZ1li1bdsb+6OhoZ+vWrZzMs9B+VOvWrXOuvvpq529/+5tz/Phx87z7f0L7Cd18883Ojh07OIeZ5PYz/Omnn5xnnnnGGTx4sPPiiy96+z/66COndevW5ryuXr3aez4lJcVp0KCBM3v27Dx5rvUzpH0yO3To4HzzzTfOr7/+6rz99ttOixYtnCZNmpg+anXr1nXy5ctnyuHcCELINN8OeAsWLHCKFCniTJo0yXxJjRs3zvynGz58uPkScsPQjTfe6FSuXNk5ceIEZzqH/R43bNhgLiQffPCBs3PnTm//7bff7hQrVizdMAT/c6jnbdOmTebC5F60dbBA1apVnaZNm3qfe7f8yZMnOYWZ5J7PjRs3OmXKlDEd+Fu1amWCet++fb1ysbGxzj/+8Q/nqquucv773/86n376qTNs2DCnVKlSzi+//JJnz/f333/vREZGOjfddJNfCNRO4m+++abz2GOPmY7TGs5xbgQhZEi/WA4dOuRt79271+nSpYsZtaF27drlVKlSxYSe4OBg56GHHvL+Gk5ISGDETA707rvvmhF+jRo1Mr+zZs2aOc8++6y3/4477jAjnhYtWpStx5kTuaHmvffecypUqGBCT4ECBUxt2tKlS/3C0HXXXef9X0Dg9LulRo0aJtgoPZd63rUW2h2dqjQI6PfOZZdd5tSpU8epV6+eFQHghx9+MGFIb8uXLz9jP6M9M4cghAyHAl9//fUm/LgOHjzoTJw40XxJ6fP6xeP+hfbEE0+YmqF///vfXs0Qcha9gOhfy6+88opz5MgR5+eff3aGDBliQtHo0aO9cv/85z+dihUrOkePHs3W482JVqxY4dWIbt++3fw/0doKbaL5/PPPTZnvvvvOhEn9ix3nFzj1/OofWAcOHPCe19o3Pa9ff/31GT/z+++/m7L6HWULDUP6udMwlN45QcYIQsjQb7/9Zu5//PFHb26OxMREc//yyy+bC8C+ffu8bQ1GERERpmkM2e/0OUW0Nkj7sSQlJfn9jgcMGGBqMNzQq00TemHBmZ566imnTZs2fs999dVX5o8G948CPX/a/Kj/b3B+1qxZ47zwwgvettu0qDVCbm2l7+fb1vlzNAxp06HW7Op8QggMo8ZwVu68MTra5YcffjCjil566SUz34zOjaJBWkeL6UiNyy+/3JT9/fffzXDrn3/+2W8YNrKfzmujo8JCQ0PlxIkTZrSJ0t+j/o779+/vlXHnJtERTziTfuZ1xI6OzPn/Pyjluuuuk379+sl///tf+e2338z5q1evnpnxGBlLbxkSPXcPPfSQ9zl1R+MFBweb8+/+Lj766CMzfPz0kWW2qFatmpkuQKfA4P9s4AhCOOuXUYECBcy9DkHVoZr6Rb9kyRIzV1BSUpL50omMjJTPP/9c7rrrLjOU9dVXXzXzW4SFhXFmcwj9PenvrWXLlmZx3AoVKpjfn16w9ULuXjxKlCgh9evXN1P240z6x4CratWqsmbNGm8OG/cc6oVb13xibbHAaXDUod/vvPOO2dYpB3SOHP2sup9jnZ5Az21KSooULFjQPB8dHS2dOnXyFn62lc5ZpXMI6f9vBIYgBP8PRFCQ7NixQx544AGz/e6775qwo7UHOj+QTmL2wQcfmDCUmJhoaolef/11s1+Dk86kW6tWLc5qDqLzAm3fvl2effZZadOmjamlmDRpksTExMjIkSNl7dq15iKiM0rrPTUYZ/rpp5/M4p4DBgww2926dTPh/1//+pdZm03/L2iNhc6zpP+HdN0nBEZDuX7HaA2QrnWnC4nqOoZa++zSc6xhSF122WVmjiutpdZQqmuO2Y4/Ys5TgE1psIC2vWuHZ+0DofczZ8702z9w4EDTsVbn9XD7CmmH2uTk5Gw6Yvjy7SehUxvo71A7l06YMMGvnM47osOSr7jiCjMyp3z58s7atWs5men4448/nEcffdTM0fLwww97/VV69+5t1rbS+bS0f0aJEiWsGK2UVU7v06NzLbnfO/369fOeP33dwubNm5t+bqGhoaYfEXAh8uk/5xuikHfo7Ky33HKLNG/e3Gw/8sgjps1Zm8O0lkdpdbT7F4f+xaZr3eh09lrW9682XHraXKA1Edqvy23S1PWItJ+W/h71d6Srcr/wwgvmd+iukq59ubRf19GjR6Vu3bqmrxD+WkXe18GDB2XChAny8ccfm+Uynn/+efO8LkuiNaL6O2jXrh01agF+ZnXNMG0S0+Z0reV56qmn5Pvvvzfn+9FHHzWzJbvl9Xei/dtq165tmuy1P5vOig5ckAuKUchTMwrrCBfX5MmTzSginVivR48e3vO+EyPqX2w6SsZ3aCuyj84uGxUVZR7rcG6dx8Yd8adzPgUFBTlTp07lV5QBd2SSztjrO4uxWzOkI8a0BkgnD8X5cWt4dDJKnQG6UqVKZg4g/R7SGp79+/c7999/v6mpPL1GWkeuLly40IyUArICQQh+lixZ4nz55Zfe9rx585zw8HC/MOTOaqrcYfPIftOmTTNNltq0oJMk6iy7vnTCRA1DOn8Q0g+Su3fvNo91fqV7773XTAWhs6b70mkHdI6lkiVLmj8WEBjfGbgLFy5s5hz74osvnKFDhzpXXnml8+CDD3ohqX///qYJbMaMGea5J5980pRnbitkJYIQ/Oi6NHoR1Qnj3DZ8DUM6rb3+taZzzOikiXqB0L+OkbNojZD2r2jZsqV3sfBd1kH7dRUsWPCMi7vtdCkGPW9aA+Euy6Dz/zzwwANmqYyXXnrJr/yYMWOcmjVrmqUddPZ0BEYnRdQ/sNzQ47rzzjvNkjzHjh0z21u2bDHBR8vqHFf62aVPELIao8bgZ86cOWYoaocOHbyhwbqysQ5lnT9/vukz9Morr8iMGTPMcGtkP7ebn46miYiIkHvvvddsR0VFmX5COveKOyeU9gV7+OGH5emnnzYjnfA/W7dulfDwcNNn5dZbbzUjJ3X0nJ6rBg0amM+/jk5yaf+Ve+65x0xBoOccgdF5f7Qvm/Zh8x32rivKFypUyJxfpSNQhw4dKm+88YZZXX3Dhg3SuHFjTjeyFJ2lLeZ2CNUvHb2IupMi6vM6J5B2ktaOoBp+lH5haQfphg0bmom7kHN+hzqXk4aeVq1amYvL+PHjzcVb538aPXq0d7H+8ccfzRw42kG1ZMmS2X34OYZOgKjTRDRq1MicU73g6jQRGoa0I++LL75o/j8ULlxYKleuLPPmzZP169fTMToA+l2ifzzpfFbqiSeekAULFpjzrlM56HxBlSpVkiFDhph9wCWT5XVMyFW0U60O+9U1pXTRQt/h09pMpv0g3GYy5Ey6ZIY2HQwaNMjZtm2b9/z48eNNc8Ldd99t1hOLjo4+Y2kN22l/FXcI9xtvvOE0btzY9EfRtZvq16/vLY+hS43MmTPH+de//uXcc889pv8KAmsKq1atmnPbbbf5fZ/oCul6zrVJV6dy0GYw25fLwKVHELKM75eLtrXr/DLa50c70moY0vDjrqCt9ItL+06wfk3OpMFVf4d6EU/vwjFlyhTTx0XnCtKOqDoSCv9b1VznWPK1ceNG0+dHV/HW/xs33HCDXxhyzy/zZZ2fDz/80PzR1a1bN9M52vX44487ZcuWdRo2bOitT3j6vEHAxUQQssQ777zjV1ugX+5jx451nn76ae85/fLXUUcdOnRwli1b5j2vI8Z0hW3kzN/rtddeaya2TE1NTfcisnXrVueTTz7xOgHbbufOnWZAgK4erwt66jl0aedo7WjuLqKqI/C0xkJrNHB+tLO+GyK1Vq1FixYmDPn+cTVy5EgThDQUuSNRqRHCpUJnaUv6P+iSCtq/Qf3555+m46Gu0ePbUVE7IU6ZMkXi4+PNVPeLFy82z7/55pumrwlyHp14Tvuw6ISW2vlU+3pph1+lk83p7/rqq6+Wm2++mSUI/t+mTZtMPx9d0kEnk9QJJ3VAwMKFC82iqaVKlZKvvvrK9I3Tta70fPbu3dvrcI7A6PnTfmw62GLdunWmf1psbKyZkHLlypWmzJNPPmn6CumaeM8995wcOHDA2gVUcekRhCygHZt1PaTy5cubi4C7hph2jv7uu+9Mp09XkyZNzKgw/cLSETHHjh3LxiNHRjTg6ErcGnTd1bk1DOks4Lp2mHZGhb/WrVubzrk6O7GOFvvkk09MB3IN/3o+9WKsnaGVdj7X2bjfeustb8ZuBEYDzbJly8xIVF0QVD+XulahBnWdqdsNQxqAdGZ7/U5iwQNcUpes7gnZTjvJ1q1b11RL6xxAWjWt60tp50/tH3F63xPtYIucwW0m2Lx5s7NgwQJz09+PNod1797d9Gd5+eWXvY692jFaO5/SpJn+edR5arSTeYUKFczn3+37o/MDaRPN6bMZ48I+t9oJul27dn773nvvPXP+O3bs6Nd3jUlacakRhCyj/YC0z4MuFnnw4EEzgsMNQ4yEydn0wqHhRkeC6WR+2gn6gw8+MJNc6izIV111lVkSRZcs0M7RLP75l/T6m+iEk3pO9fOvF2MXF+KspwvWtmrVyklJSfHrw6bhPSwszLnlllsYnYpsQ9OYZbQf0PTp003Tl04WpxOWvf3222aOFG2n16YC5Ay6yKTr22+/lfvuu8/Mr6L9V7R5Ye3ataZ5oXTp0jJmzBjTp+uZZ56RZ5991jQ3XHPNNdl6/DltrqW4uDgzv9LIkSPNY13ks2PHjuY5bY755z//acprkzH9gbJWjRo1zGdy9erVps+Q2/RVtmxZM3eQfta13xaQLbIvgyE7aW2B1hxozZAuYvj555+bZTO0WQXZ6+uvv/YeuyPBdH0wt2lBRz3pIpW6KKWLEWHnFhsbaxb11BF211xzjZM/f35nxIgRpjZNRzVpzZDOc3PjjTdepN+qXTVvOopRz61vTdwdd9zhlCpVyqxlePjwYfOcLlw7atQoUzsNZBeCkOVhSJvJbr/9dvPF5a7vg+zz6aefOtWrVzcXB1+6anzfvn3NPCva7KUhyG1i0IVytW+LBlqcSVcp1zmUXn/9dS9YTp8+3SlRooQZtu02k82ePdvMGxQfH89pPA9u6Pn4449NM5jODaTrE7oLpur3i/ZPDA0NNd87zZs3N2uHnd4/EbjUaBqzmDad6HB5XZpBR4fpGj/IXnXr1pWbbrpJFi1aZEbRuLS5RkfxaVOmLn8ybdo0b5i8DkXWJjIdPYYzHTlyREJCQqRZs2beOdP12PT8ajOiNotpM1nnzp1NsyPLx5wfd4h8t27d5MYbbzTrER49etQ022rzo36/zJ4926wbdtttt0nbtm3NiFX9zAPZ6pJHL+Q4x48fz+5DsJpbs6O1ckpXMx84cKDpDK2rxbsefvhhJygoyEyOqLU/+/fvdx555BEzs7ROmoj06cSIOoGiOxjA9/OutW8TJkzg1GUBHcWoE7JOnDjRbB85csTUCmmTe7169bxRjUBOQ40QpGDBgpyFbKKdRLWWQjs+61w2uuq5LpCqE/lpDYbOZ6MrxSvtzH7nnXea+Vi007tOAjhnzhzTSVonTbTd/zf1n9HRXCdG1LmDevbsKXv27DGfdy2ntaBaE6STUeLCFS9e3NSqaQf03bt3S4MGDaRTp05mDjOtrdQ5g9zPMpCTsPo8kM0hSFc6v/7666Vv377y0ksveaOc9u7da5pvvvnmGxN+NBwpnQBQZ+fVC49ebK644gp+hz6jw5YvXy4ff/yxWelcZyv+29/+Zs7ho48+amba1lGTWlZnktYmxlWrVjFiKYvoCvIaLB966CEzo72ea90eOHCg+Z1oM5g2jZUsWZLPLHIMghCQzSFIZ9MdPHiw6a/i2r9/v+kXpGFIZ0HW4d633HKLGT6Ps9PaMa0pu/XWW01/nzp16piaoF69esmaNWtk1KhR8tlnn5lZ1nUW7lmzZknDhg05pecZOnV5l8TERAkNDTWzRhcpUsTs11ohXdJHz68aMGCAXHXVVdK9e3fzuQZyEoIQkE22bdsm9evXl6eeekqGDx/uPa+BSGt99HbZZZeZ9eC0ZkjnEmrZsqVfJ2r8RWsgdDkMbSa8//77zbbWAunFWoOQ1rgpbYYsVqyYhIeHc1G+gBD0wQcfyJAhQ0yNj9ZQaq2mnmft7K81QtoJXZslDx06ZDr669xlFStW5COLHIc+QkA20PXAdP0qnbhPazBco0ePlpdfftnU/GgI0pojnTDx8ccfNxd4nZBOLzrwpyHxgQcekBUrVphwqXT0l9amValSxTTHTJ061TzfqFEjUztBzURg3H5XGoK0tk1Dj07KqiO/NMzPnTtXfv75Z1NGQ6c22epadzqR4tKlSwlByLmyu7c2YCudvFLnWSlSpIgZcaOjbXRum8WLF6db/sCBA2ZEGc6kI8J06ZFChQo548eP99v322+/mSVkdPTSa6+9xukL0Pfff+89dudh0rXs7rzzTvP4119/dapUqeI3waeOhNS123SEnjsaEsipqBECskm5cuXkxRdfNDVCOmJs2LBhpjlM51fxXX1bR9q4HUx1RBn86bnSvkB6jrR55r333pP333/f2681E1pj0aJFCzN6DJmny+/cfffd8u6775rtAgUKmHsdcVevXj0zR9O1115rmsPcGrePPvrIzBekvxcdoceoPOR0BCEgG2mzl64b1q9fP9Nc5k6K6AYhvYDr2lg6Ogzp06YaPV8aJvVcasddHQ3mG4a0I+/kyZPNulbIPA2Y2gH69ddf9zufpUqVkueff16qVatmJkecNGmS+T1o85n2HdKO6UBuQWdp4BJ3Mv3hhx/MMOPjx4+bzs9KR95oB18d0q2jmpo2bWr6CY0dO9b0sWBkU+bPry4cPGjQIFN70aNHDzPTMc5/ZKN26tfh70oX/v3Xv/5lHusM5zpK7/vvvzf9sfTzrLWXOqP0559/bhZaBXIDghBwCS/S2sSgFxUdWvzTTz+ZZjAdWvyPf/zDhCMNQ0uWLJF27dqZv6y//PJL07kXgZ1nvTjfc889pvlx5syZpuM5LjxcKv2MagjS0XcPPvig2afzA+kyJnretYO0Lt8D5BYEIeAS0Yn7dII/nTTx73//uyQnJ5uLijblDB061OzTofIajLSfBTVBZ6ej7dz+KueqedM+KtoshqwLQ7qtn9F//vOfpjlX+wYdPHhQypYtK23atGFySuQ6BCHgEtF+FDqfig7x1sn8tNlh165d0rVrVzOUW2feVboMhO7X/kM4k1589fzo/EAaLu+4446zXrxx8cKQ9mvTmiEgt6OzNHCR+I78UjrC5sSJE6ZDtIYgrRHS2oqJEyeavkHa1KD0L2tC0Nn7rWgI+vXXX6VJkyayaNGidMsRgi5Oh/RatWqZleT186sdqHUurLN93oHcgiAEXMSLh3Ym1b4+SjtGb9q0SV599VWzrU1i5j9hUJAZ8UQ/lkx8YQUFyYEDB0zfKq2N0CHzuLRhSCf21DCkzWE6kuzw4cPefiA3Sr+RHUCW0AVAtcZHmxR0vhVdQV77V2jzjs7PohcWDUpa06HLPkDk6NGjpjO5O2rpdDqzts651Lt3by6+l7gPlhuGatasKW+++abpg0WAR25HHyEgC53eN2X37t2mQ7QOJdY1xPQi/8orr0h0dLTpVFqoUCFJSEgwEykyRF5MZ/HatWvLlClTzPw09PW59OiDBdvQNAZkIQ1BGmrGjBlj5gbS4ds6c7SutaSjmEqUKGEWWNW1sR555BFTs6EdfglB//+FFBRkRiPdddddZuScWwOBS4M+WLARNUJAFtLwc+ONN5qFKHW+IO1PoZPQdejQQf78808zLxAyrhXS2jNtUtRmQz131AxlnYzOpfbB0uVIWrVqZYbG0/cHeR01QkAW0n4+GoDci8fXX39t5gcaPHiw/PLLLzJhwgTO92m0ufDQoUPeto6Ye/TRRyUqKko6depEzVAWcWvWdJ0w39Xkz9YHixAEW1AjBGQBrQHau3evCT3q3//+t+zfv9/UbGgHad2vtUW6cOqcOXOkevXqnHcR2bFjh9x+++1mPat7771XypQpY0aEKZ1e4KGHHjL9hXQhVQ1F7sWcWorzQx8s4EyMGgMCkN5IJp0fSCeZ0wu3XrC1M7Sux6RrLunkiDq6Rlfx1gCkkykyyuavc6nnaMOGDWb0kQZFra3QflQ6R5COCuvVq5cJj+66VrrKOX2GsqYPli6JQbMjQI0QELDffvtN1q1bZy4os2fPlp9//ll69uxphsprJ2m9UOuq8TrHjV7Eda0rpTVGOhmgrtyN/9ERc7qKua67pnMpaXPYrFmz5KuvvpKNGzeaUFSlShUz2aTWZug5dheqxfn1B6IPFuCPpjEggItKamqq3HnnnaZDqa4Qr6vDT5s2zXSIVlor1KdPH9Mspn9x6wKUuraYu2AlzqRTDDz33HOyevVqUwPUv39/87yOptN906dPl99//102b95sbjq7MTJfe6l9sHRIfHh4uLdPayr1nE+ePJkO6bAeQQgIkF6cb731Vvnuu+/M5Ig6y+7pk9BpU5he2HWfBqbPPvvMTBKI9LkXZg0/HTt2lMcee8zbp+FTL+pJSUksPRIg+mABGSMIAQHQv6yPHz8u7dq1M31adK0w7cviLj6ZkpJiaoKUris2b948qVOnjhlGj4ybybRz+Zo1a0wY0pFjGa00j7PT8PjEE09ITEyM6YN11VVXndEHS+liv08//bRfHyw6o8MmBCHgPGgI0pvbJKb32kHadbblIZC5MKS1ba1btzZ9rXD+6IMFZIxvaiAA7ogl7W9RqVIlGTdunNnWlbhjY2PN4xEjRphh3wicDp9//PHHpVq1arJy5Uozpw0u7HwOHTrU1FzqiMVPP/3ULO+yZMkSUxOkzZEa2nXuJkVHftiIGiHgPLlNCNu2bTMXm127dpn5cHSFee0TpH2DcH50hJ2KiIjgFGYB+mABZ0cQArIgDOkQev1rOz4+Xnr06GFW5wZyEvpgAekjCAGZcK4Ou3QuRW5BHyzgTPQRAjIxUkxD0M6dO+Wdd945Yz8jbJBb0AcLOBM1QsA5uKO/fv31V2ncuLG0b9/eLAsB5Gb0wQL+QhCC9TJq2tJZpFu0aCGtWrViRW4AyGMIQhDbA5AuQaCzPp9t7p/t27ebocc6AR3NYACQtxCEYDVdgLJ27doyZcoUue222+j4DACWobM0rKY1QLqK/F133SUfffSRqfFxJ00EAOR9LOADq/sD6Uy6uhaTToTYqVMnVuIGAMsQhGANtw+Q9gnSIfG6TIbS5QV0gU/dTxgCALsQhGANDUE7duyQ22+/3dQA3XvvvWZelbZt20rZsmXlhRdeMDVGGobee+89c+82k9FJGgDyJoIQrKE1PjoH0IYNG6RgwYJm9fhjx45JiRIlpEmTJmZUWK9evaRkyZLSpUsXWbx4sdx00030GQKAPIxRY7BuiYHnn39efvrpJ6latapERUXJrFmz5KuvvpKNGzeaUFSlShVZu3atGVG2fPlyadmyZXYfNgDgIqFGCFbRpjBdKf65554zcwNVq1ZNoqOjzb5Vq1bJ7t27Zfr06abfkAYh7UwNAMi7qBGClfbs2WPCkIafjh07ymOPPebtS01NNc1oSUlJJhABAPIughDE9pW416xZY8KQjhzLaKV5AEDeQhCC1dww9N1330nr1q3lqaeeyu5DAgBcQswsDbG9z9Djjz9u+gqtXLlS/vjjj+w+JADAJUSNECAie/fuNechIiKC8wEAFiEIAQAAa9E0BgAArEUQAgAA1iIIAQAAaxGEAACAtQhCAADAWgQhAABgLYIQAACwFkEIAABYiyAEIM+55557JF++fDJ69Gi/5z/88EPz/Nns2bNH7rzzTqlevboEBQXJoEGDLsHRAshOBCEAeVLBggXl+eeflz///DPTP5OcnCyXX365jBgxQurXr39Rjw9AzkAQApAntWnTxiyqGxMTk+mfqVSpkowfP17uvvtuKVq06EU9PgA5A0EIQJ6UP39+ee6552TixIny22+/ZffhAMihCEIA8qxOnTpJgwYNZOTIkdl9KAByKIIQgDxN+wnNnDlTtm3b5vd8kSJFvFu/fv2y7fgAZK8C2fz+AHBRtWzZUiIjI2X48OFmNJlr/fr13uPw8HB+C4ClCEIA8jwdRq9NZDVq1PCeq1q1arYeE4CcgSAEIM+rW7eudO/eXSZMmJBhWbem6MiRI7J//36zHRISIrVq1boERwrgUsvnOI5zyd8VAC4ibQJLTEw0Eyi6fvnlF1MjlJKSIuf62ktvwsWKFSuanweQ9xCEAACAtRg1BgAArEUQAgAA1iIIAQAAaxGEAACAtQhCAADAWgQhAABgLYIQAACwFkEIAABYiyAEAACsRRACAADWIggBAACx1f8By8A7YrD4qioAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "h.compute().plot1d()\n", "plt.xticks(plt.gca().get_xticks(), labels, rotation=45)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "8ca4e1f0-f5a3-46b3-9bcb-848aa3e04a99", "metadata": {}, "source": [ "And we got exactly the same thing. Saving to `.npz` files is still possible but the delayed arrays will be naturally materalized while saving." ] }, { "cell_type": "code", "execution_count": 52, "id": "d0d57fbb-633b-4140-95b6-7ac551a4c271", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "labels: ['initial' 'N - twoElectron' 'N - noMuon' 'N - leadPt20' 'N']\n", "nev: [40 10 3 5 3]\n", "masks: [[False True True False False False False False False True False False\n", " False False False True True False False False True True False False\n", " False False False True False True False False False True False False\n", " False False False False]\n", " [False False True False False False False False False False False False\n", " False False False False False False False False True True False False\n", " False False False False False False False False False False False False\n", " False False False False]\n", " [False False True True False False False False False False False False\n", " False False False False False False True False True True False False\n", " False False False False False False False False False False False False\n", " False False False False]\n", " [False False True False False False False False False False False False\n", " False False False False False False False False True True False False\n", " False False False False False False False False False False False False\n", " False False False False]]\n" ] } ], "source": [ "nminusone.to_npz(\"nminusone_results.npz\")\n", "\n", "with np.load(\"nminusone_results.npz\") as f:\n", " for i in f.files:\n", " print(f\"{i}: {f[i]}\")" ] }, { "cell_type": "markdown", "id": "7dd71131-d0df-4930-b853-d126d7c0c2db", "metadata": {}, "source": [ "Same logic applies to the `plot_vars` function. Remember to use `dakevents` now and not `events`." ] }, { "cell_type": "code", "execution_count": 53, "id": "621cc56b-7bf1-4be8-b24c-04c89125e6b0", "metadata": { "slideshow": { "slide_type": "slide" }, "tags": [] }, "outputs": [ { "data": { "text/plain": [ "(ColormeshArtists(pcolormesh=, cbar=None, text=[]),\n", " [StairsArtists(stairs=, errorbar=, legend_artist=)],\n", " [StairsArtists(stairs=, errorbar=, legend_artist=)])" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "dask_categorical = {\"axis\": hist.axis.IntCategory([0, 41, 43], name=\"ttbarID\"), \"values\": dakevents.genTtbarId, \"labels\": [\"X+jj\", \"X+c\", \"X+cc\"]}\n", "hs, labels, catlabels = nminusone.plot_vars({\"Ept\": dakevents.Electron.pt, \"Ephi\": dakevents.Electron.phi}, categorical=dask_categorical)\n", "hs[0].compute()[{\"ttbarID\": 0}].plot2d_full()" ] }, { "cell_type": "markdown", "id": "8e94ed9c-dfd7-47d3-997a-4c7561f51147", "metadata": {}, "source": [ "Those histograms are also delayed and have to be computed before plotting them." ] }, { "cell_type": "markdown", "id": "0877deac-0e27-480d-b471-bafba2441328", "metadata": {}, "source": [ "Exactly the same things apply to the cutflow in delayed mode." ] } ], "metadata": { "kernelspec": { "display_name": "awkward-coffea", "language": "python", "name": "awkward-coffea" }, "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.13.9" } }, "nbformat": 4, "nbformat_minor": 5 }