From 26a003e2db1f19a7c20c342c569bd0fe5b3a0977 Mon Sep 17 00:00:00 2001 From: ekauffma Date: Tue, 27 Jun 2023 15:07:58 +0200 Subject: [PATCH] minimal working version of ttbar notebook with new coffea --- .../cms-open-data-ttbar/ttbar_newcoffea.ipynb | 416 ++++++++++++++++++ .../cms-open-data-ttbar/ttbar_newcoffea.py | 235 ++++++++++ 2 files changed, 651 insertions(+) create mode 100644 analyses/cms-open-data-ttbar/ttbar_newcoffea.ipynb create mode 100644 analyses/cms-open-data-ttbar/ttbar_newcoffea.py diff --git a/analyses/cms-open-data-ttbar/ttbar_newcoffea.ipynb b/analyses/cms-open-data-ttbar/ttbar_newcoffea.ipynb new file mode 100644 index 00000000..248e0f4e --- /dev/null +++ b/analyses/cms-open-data-ttbar/ttbar_newcoffea.ipynb @@ -0,0 +1,416 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 14, + "id": "3ac589bb-b84b-49b4-ae9c-cece70a0882c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from coffea.analysis_tools import PackedSelection\n", + "from coffea.lookup_tools.correctionlib_wrapper import correctionlib_wrapper\n", + "from coffea.nanoevents import NanoEventsFactory\n", + "import correctionlib\n", + "import dask\n", + "import dask_awkward as dak\n", + "import hist.dask\n", + "import numpy as np\n", + "import dask\n", + "import awkward as ak\n", + "import os\n", + "import urllib" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad41087a-a810-4e8f-ac42-61e5d4738a6c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "ttbar_file = \"https://xrootd-local.unl.edu:1094//store/user/AGC/nanoAOD/TT_TuneCUETP8M1_13TeV-powheg-pythia8/cmsopendata2015_ttbar_19980_PU25nsData2015v1_76X_mcRun2_asymptotic_v12_ext3-v1_00000_0000.root\"\n", + "\n", + "# download for subsequent use\n", + "local_file_name = \"ttbar__nominal.root\"\n", + "if not os.path.exists(local_file_name):\n", + " urllib.request.urlretrieve(ttbar_file, filename=local_file_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e9874e44-c2b7-44ac-aa33-a95ec2091829", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "fileset = {\n", + " 'ttbar__nominal': {\n", + " 'files': ['ttbar__nominal.root'],\n", + " 'metadata': {'process': 'ttbar',\n", + " 'variation': 'nominal',\n", + " 'nevts': 1334428,\n", + " 'xsec': 729.84\n", + " }\n", + " },\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "83dc4049-7ad4-4a35-b66e-a974ccc60046", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def rand_gauss(item):\n", + " randomstate = np.random.Generator(np.random.PCG64())\n", + "\n", + " def getfunction(layout, depth, **kwargs):\n", + " if isinstance(layout, ak.contents.NumpyArray):\n", + " return ak.contents.NumpyArray(randomstate.normal(loc=1.0, scale=0.05, size=len(layout)).astype(np.float32))\n", + " return None\n", + "\n", + " out = ak.transform(getfunction, ak.typetracer.length_zero_if_typetracer(item), behavior=item.behavior)\n", + " if ak.backend(item) == \"typetracer\":\n", + " out = ak.Array(out.layout.to_typetracer(forget_length=True), behavior=out.behavior)\n", + "\n", + " assert out is not None\n", + " return out\n", + "\n", + "def jet_pt_resolution(pt):\n", + " # normal distribution with 5% variations, shape matches jets\n", + " resolution_variation = dak.map_partitions(rand_gauss, pt)\n", + " \n", + " return resolution_variation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "84ff0f3e-6ec7-4b22-859d-e0a7a036e07d", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/elmaka8700/Documents/coffea/src/coffea/nanoevents/schemas/nanoaod.py:215: RuntimeWarning: Missing cross-reference index for FatJet_subJetIdx1 => SubJet\n", + " warnings.warn(\n", + "/Users/elmaka8700/Documents/coffea/src/coffea/nanoevents/schemas/nanoaod.py:215: RuntimeWarning: Missing cross-reference index for FatJet_subJetIdx2 => SubJet\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "with dask.config.set({\"awkward.compute-unknown-meta\": False,\n", + " \"awkward.optimization.enabled\": False}):\n", + " \n", + " events = NanoEventsFactory.from_root(\n", + " {fileset[\"ttbar__nominal\"][\"files\"][0]: \"Events\"}, \n", + " permit_dask=True,\n", + " ).events()\n", + " \n", + " # initialize histogam\n", + " histogram = (\n", + " hist.dask.Hist.new.Reg(25, 50, 550, name=\"observable\", label=\"observable [GeV]\")\n", + " .StrCat([\"4j1b\", \"4j2b\"], name=\"region\", label=\"Region\")\n", + " .StrCat([], name=\"process\", label=\"Process\", growth=True)\n", + " .StrCat([], name=\"variation\", label=\"Systematic variation\", growth=True)\n", + " .Weight()\n", + " )\n", + " \n", + " xsec_weight = (396.87 + 332.97) * 3378 / 1191997\n", + " \n", + " events[\"pt_scale_up\"] = 1.03\n", + " events[\"pt_res_up\"] = jet_pt_resolution(events.Jet.pt)\n", + " syst_variations = [\"nominal\"]\n", + " jet_kinematic_systs = [\"pt_scale_up\", \"pt_res_up\"]\n", + " event_systs = [f\"btag_var_{i}\" for i in range(4)]\n", + " syst_variations.extend(jet_kinematic_systs)\n", + " syst_variations.extend(event_systs)\n", + " \n", + " cset = correctionlib.CorrectionSet.from_file(\"corrections.json\")\n", + " \n", + " \n", + " for syst_var in syst_variations:\n", + "\n", + " ### event selection\n", + " elecs = events.Electron\n", + " muons = events.Muon\n", + " jets = events.Jet\n", + " evtnum = events.event\n", + " if syst_var in jet_kinematic_systs:\n", + " jets[\"pt\"] = jets.pt * events[syst_var]\n", + "\n", + " electron_reqs = ((elecs.pt > 30) & (np.abs(elecs.eta) < 2.1) \n", + " & (elecs.cutBased == 4) & (elecs.sip3d < 4))\n", + " muon_reqs = ((muons.pt > 30) & (np.abs(muons.eta) < 2.1) & (muons.tightId) \n", + " & (muons.sip3d < 4) &(muons.pfRelIso04_all < 0.15))\n", + " jet_reqs = (jets.pt > 30) & (np.abs(jets.eta) < 2.4) & (jets.isTightLeptonVeto)\n", + "\n", + " # Only keep objects that pass our requirements\n", + " elecs = elecs[electron_reqs]\n", + " muons = muons[muon_reqs]\n", + " jets = jets[jet_reqs]\n", + " \n", + " B_TAG_THRESHOLD = 0.5\n", + "\n", + " ######### Store boolean masks with PackedSelection ##########\n", + " selections = PackedSelection()\n", + " # Basic selection criteria\n", + " selections.add(\"exactly_1l\", (dak.num(elecs) + dak.num(muons)) == 1)\n", + " selections.add(\"atleast_4j\", dak.num(jets) >= 4)\n", + " selections.add(\"exactly_1b\", dak.sum(jets.btagCSVV2 >= B_TAG_THRESHOLD, axis=1) == 1)\n", + " selections.add(\"atleast_2b\", dak.sum(jets.btagCSVV2 > B_TAG_THRESHOLD, axis=1) >= 2)\n", + " # Complex selection criteria\n", + "\n", + " selections.add(\"4j1b\", selections.all(\"exactly_1l\", \"atleast_4j\", \"exactly_1b\"))\n", + " selections.add(\"4j2b\", selections.all(\"exactly_1l\", \"atleast_4j\", \"atleast_2b\"))\n", + " \n", + " for region in [\"4j1b\", \"4j2b\"]:\n", + " \n", + " region_selection = selections.all(region)\n", + " region_jets = jets[region_selection]\n", + " region_elecs = elecs[region_selection]\n", + " region_muons = muons[region_selection]\n", + " region_evtnum = evtnum[region_selection]\n", + " region_weights = dak.full_like(region_evtnum, xsec_weight)\n", + " \n", + "\n", + " if region == \"4j1b\":\n", + " observable = dak.sum(region_jets.pt, axis=-1)\n", + "\n", + " elif region == \"4j2b\":\n", + "\n", + " # reconstruct hadronic top as bjj system with largest pT\n", + " trijet = dak.combinations(region_jets, 3, fields=[\"j1\", \"j2\", \"j3\"]) # trijet candidates\n", + " trijet[\"p4\"] = trijet.j1 + trijet.j2 + trijet.j3 # calculate four-momentum of tri-jet system\n", + " trijet[\"max_btag\"] = np.maximum(trijet.j1.btagCSVV2, np.maximum(trijet.j2.btagCSVV2, trijet.j3.btagCSVV2))\n", + " trijet = trijet[trijet.max_btag > B_TAG_THRESHOLD] # at least one-btag in trijet candidates\n", + " # pick trijet candidate with largest pT and calculate mass of system\n", + " trijet_mass = trijet[\"p4\"][dak.argmax(trijet.p4.pt, axis=1, keepdims=True)].mass\n", + " observable = dak.flatten(trijet_mass)\n", + "\n", + "\n", + " syst_var_name = f\"{syst_var}\"\n", + " # Break up the filling into event weight systematics and object variation systematics\n", + " if syst_var in event_systs:\n", + "\n", + " for i_dir, direction in enumerate([\"up\", \"down\"]):\n", + " # Should be an event weight systematic with an up/down variation\n", + " if syst_var.startswith(\"btag_var\"):\n", + " i_jet = int(syst_var.rsplit(\"_\",1)[-1]) # Kind of fragile\n", + " wrap_c = correctionlib_wrapper(cset[\"event_systematics\"])\n", + " wgt_variation = wrap_c(\"btag_var\", direction, region_jets.pt[:,i_jet])\n", + " # wgt_variation = cset[\"event_systematics\"].evaluate(\"btag_var\", direction, region_jets.pt[:,i_jet])\n", + " elif syst_var == \"scale_var\":\n", + " # The pt array is only used to make sure the output array has the correct shape\n", + " wrap_c = correctionlib_wrapper(cset[\"event_systematics\"])\n", + " wgt_variation = wrap_c(\"scale_var\", direction, region_jets.pt[:,0])\n", + " # wgt_variation = cset[\"event_systematics\"].evaluate(\"scale_var\", direction, region_jets.pt[:,0])\n", + " syst_var_name = f\"{syst_var}_{direction}\"\n", + " histogram.fill(\n", + " observable=observable, region=region, process=\"ttbar\",\n", + " variation=syst_var_name, weight=region_weights * wgt_variation\n", + " )\n", + "\n", + " else:\n", + " # Should either be 'nominal' or an object variation systematic\n", + " histogram.fill(\n", + " observable=observable, region=region, process=\"ttbar\",\n", + " variation=syst_var, weight=region_weights\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4e9d3d13-0a55-485b-88db-36adabcabad0", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "with dask.config.set({\"awkward.optimization.enabled\": False, \"awkward.compute-unknown-meta\": False}):\n", + " histogram_computed = histogram.compute()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6697b041-ffab-497d-957f-83aa3bfa3218", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Hist(\n", + " Regular(25, 50, 550, name='observable', label='observable [GeV]'),\n", + " StrCategory(['4j1b', '4j2b'], name='region', label='Region'),\n", + " StrCategory(['ttbar'], growth=True, name='process', label='Process'),\n", + " StrCategory(['nominal', 'pt_scale_up', 'pt_res_up', 'btag_var_0_up', 'btag_var_0_down', 'btag_var_1_up', 'btag_var_1_down', 'btag_var_2_up', 'btag_var_2_down', 'btag_var_3_up', 'btag_var_3_down'], growth=True, name='variation', label='Systematic variation'),\n", + " storage=Weight()) # Sum: WeightedSum(value=850506, variance=1.72594e+06) (WeightedSum(value=912312, variance=1.85745e+06) with flow)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "histogram_computed" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "666eb27a-930d-440a-9e1b-4aa33ad4bdec", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjAAAAHRCAYAAAB0AYPVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABGpElEQVR4nO3deVRV573/8Y8ySg5iFNSIJspBQQ0qGoxKIHpN1JsajQZrNVKjZDB6TSU/MMYhYJxjo0ZvE5ta5yGJVr3Q2tYaG4c636BxQBxj5EcbD9QgeJDDcH5/ZHF+OQEHEDxsfb/WOmux9/Ocvb8Pu8RP93723nXsdrtdAAAABlLX1QUAAABUFgEGAAAYDgEGAAAYDgEGAAAYDgEGAAAYDgEGAAAYDgEGAAAYDgEGAAAYDgEGAAAYDgEGAAAYDgEGAAAYDgEGwB3LzMyU2WxWYmKiq0upFfh9AK5DgAEeQFu3bpXZbJbZbNZnn312z/fv6n/4//znPys5OVlDhw5Vx44dZTab9dZbb7mklh9z9e8FMBJ3VxcA4N7KyspScnKyHnroIV2/fr1S323SpIm2b98uX1/fGqru3vjNb36j9PR0PfTQQ2ratKny8/NdXRKASuIMDOAikyZN0sqVK3Xx4sV7tk+73a63335bDz/8sIYNG1bp73t4eMhsNqtx48Y1UN29M2XKFO3YsUPHjh3Te++95+pyAFQBAQZwkcOHD2vGjBl65pln1KtXLyUnJ+vLL7/UjRs3amyfK1eu1P79+zVv3jz5+PhU+vu3u8Rx9OhRjRs3Tk8++aRCQ0MVGRmpKVOm6LvvvnP0+fDDD/X0009LkjZv3uy4lGU2m7Vp0yZHvx07dmjEiBHq1q2b2rZtq+7du2vYsGFau3Ztpev+qe7du6tVq1aqU6fOXW+rzPnz5/X666+rc+fOevzxx/Xzn/9ce/bsuePv3+nvZdOmTRo7dqx69uypdu3aqWPHjhoyZIi2bt1a4XbtdrtWrFihvn37qm3bturRo4eSk5OVl5en6OhoRUdH39W4AVfhEhLgIn/605+0f/9+7dq1S7t27dKaNWu0Zs0aeXl56cknn9TTTz+tp59+Wq1ataqW/Z07d07z58/Xyy+/rK5du2r//v3Vst0yGzdu1JQpU+Tp6anevXvrkUce0TfffKPPP/9cO3fu1B/+8Ac1a9ZMTz75pF5++WWtXLlSbdu21bPPPuvYRrt27SRJGzZs0NSpUxUQEKD/+I//UMOGDZWTk6PTp09r06ZNGjFiRLXWfrcyMzMVExOjkJAQDRs2TFeuXNGf/vQnjR49WgsXLlT//v1vu407+b1I0rvvvqvWrVsrIiJCjRs31tWrV7Vr1y79n//zf3ThwoVyc3mSkpK0bt06NWnSRL/4xS/k4eGhL774QseOHVNxcbHc3flnAAZlB1ArnDt3zv773//eHhsbaw8NDbUHBQXZg4KC7D179rQnJSXZ09LSqrztoqIi+4ABA+y9e/e2FxQU2O12u33RokX2oKAg+6effnrH27l8+bI9KCjInpCQ4LT+woUL9pCQEHvPnj3t//znP53a9u7daw8ODra//vrrt91Omeeff94eGhpqt1gs5dpycnLuuN47sX//fntQUJA9Pj6+0t8tG0dQUJB99uzZTm3Hjh2zt2nTxt6pUyf7tWvXKrW9m/1e7Ha7/Ztvvim3rrCw0P7SSy/Z27Rp4/T7P3TokD0oKMjeu3dve25urlP/oUOH2oOCguxRUVF3VBtQ23AJCaglzGazRo8erdWrV+t///d/NW3aNDVo0EDffvut1qxZo9WrV1d520uWLNGpU6f0/vvvy9vbuxqr/sG6detUVFSkd999V02bNnVqi4yMVO/evbVz585KTZZ1c3OTh4dHufUNGza863qrm6+vr8aPH++0rkOHDhowYICuXbum7du3V9u+HnvssXLrPD09FRsbq+LiYu3bt8+xfvPmzZKksWPHqn79+k79ExISqq0mwBU4dwjUEjabTYcPH9auXbu0e/dunT17VtIPE2c7d+7sdEmhMo4ePaqPP/5YcXFx6ty5c3WW7JCWliZJOnjwoL7++uty7Tk5OSopKdHFixcVFhZ22+0NHDhQs2fPVt++fdW/f3917dpVXbp0UaNGjaq99urQvn17mUymcuuffPJJbd68WadOndKLL74o6Ye5Lj/14osvqnnz5ne0r6ysLP32t7/Vvn37lJWVVW7O1I/nG508eVKS9MQTT5TbTnh4OJePYGj8rxdwoczMTO3evVu7du3Svn37ZLVaJf1wu/KQIUPUs2dPRUZGVvm25eLiYiUkJKhVq1aKj4+vztKdXL16VZL0u9/97pb9ysZ3O3FxcXr44Ye1bt06rVq1SitWrFCdOnXUtWtXTZo0SR06dLjrmquTv79/hesDAgIkSXl5eY51ixcvLtfvySefvKMA8+2332rw4MHKzc1VRESEnnrqKfn6+srNzU2ZmZnavHmzbDabo3/Zfiuqz83NTQ0aNLjtPoHaigADuMjw4cN18OBBSZK7u7s6deqknj176umnn3aatHk3rFar4zbtm21z8uTJmjx5sl5++WVNmzatSvspC1hHjx6ttmfEDB48WIMHD9a1a9f0v//7v9q+fbs2bdqkUaNGafv27bXqbEx2dnaF6y0WiyQ5/U7Onz9f5f0sX75cV69e1bx58xQTE+PUlpKS4rhkVKZsv9nZ2Xr00Ued2kpKSvT999+rSZMmVa4HcCUCDOAiNptNL774onr27KmnnnrKaY5CdfH09NTPf/7zCttOnjypkydP6oknnlBQUJDCw8OrvJ/w8HCdOHFCR44cUa9evW7bv27dH6bflZaW3rZv/fr11atXL/Xq1Ut2u10bN27U4cOH1a9fvyrXW91Onjyp/Pz8cpeRygLqnQbS2/1evvnmG0mqcOyHDh0qt65du3Y6efKkjhw5Ui7ApKWlqbi4+I7qAmojAgzgIj9+tkdN8fb21pw5cyps+/DDD3Xy5EkNHjxYQ4cOvav9xMbG6tNPP9XMmTPVsmXLcrd+22w2HTt2TBEREZIkPz8/1alTR1lZWRVub//+/erWrVu557Tk5OQ4xvVjiYmJ2rx5c4VnJu6FvLw8LVmyRO+8845j3ddff62UlBT5+vqqT58+d7Sd2/1eyi4zHTx4UL1793as3717tz7//PNy/QcNGqSNGzfqo48+0rPPPus4I2Oz2fTBBx/c8fiA2ogAA7jIiBEjnCZc3k7v3r01adKkGqyo6sxms+bOnatJkyapX79+io6OVqtWrVRUVKSsrCwdOXJEDRs21N/+9jdJ0kMPPaROnTrp8OHDio+PV6tWrVS3bl0988wzCg0N1RtvvOHoExgYKOmHB/99/fXXevzxxxUZGem0/7IzFnc6KXX79u2OWsou86SlpTke0Pfwww9r8uTJdzz+rl276vPPP9exY8fUpUsXx3NgSktLNXPmzDu+rHa738uIESP0hz/8Qf/1X/+l//zP/1Tjxo115swZ7d69W88995z+9Kc/OW3vySef1C9+8Qt9+umn6tevn/r27St3d3ft3LlTvr6+atKkieOsD2A0BBjARb799lv93//7f++4/53cveNKL7zwgtq2batly5bpwIED2rt3r+rVq6fGjRurX79++tnPfubU/9e//rVmzZql3bt3KzU1VXa7XU2bNlVoaKgmTpyo3bt36+TJk/ryyy/l5eWlwMBATZw4US+99FK526vPnDkjk8l0R5evJCk9Pb3cfJFvv/1W3377rSQpMDCwUgGmefPmmjFjhubPn6/169fLZrOpffv2Gj9+fKWfdHur30toaKjWrl2rBQsW6O9//7tKSkoUGhqqjz76SPXr1y8XYCRpxowZMpvN2rBhgzZs2KAGDRqoT58+SkhIUGRkZLlLS4BR1LHb7XZXFwHAGM6fP68+ffroF7/4hWbNmuXqciRJ165dU5cuXRQXF1drz1DVRhcvXtQzzzyj/v37V3hrN1Dbce4QwB0ru6Pppw+rc6XDhw/L3d1dcXFxri6lVrJYLOUmBRcUFGjmzJmSdMfzc4DahktIAG7r9OnT+p//+R+lpKSobt26teofvd69eys9Pd3VZdRaK1asUGpqqp588kk1btxYFotF+/bt07/+9S89/fTTeu6551xdIlAlBBgAt3XixAmtXr1aZrNZM2bMUEhIiKtLwh2KjIxUenq69u7dq9zcXLm5ualVq1YaOXKkRo0aVa1v5AbuJebAAAAAw2EODAAAMBwCDAAAMJz7dg7Mv//9b+3Zs0fNmzeXl5eXq8sBAAB3oLCwUJmZmYqKilLDhg1v2u++DTB79uzRW2+95eoyAABAFSxYsEADBw68aft9G2DK3hmyYMECmc1mF1cDAADuxPnz5/XWW285/h2/mfs2wJRdNjKbzXr88cddXA0AAKiM203/YBIvAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwnPv2VQIAANS03NxcWa3We7Y/Hx8f+fn5Vft2hw8frrZt22ratGnVvu2aQoABAKAKcnNz9ZslS1RUUnLP9unh5qZx48ffcYj5aTA5cOCAXnrpJaWlpal+/fo1WWqNI8AAAFAFVqtVRSUlevr8V/IryK/x/eXWM2mXubOsVmuNnIWpbna7XSUlJXJ3r5moQYABAOAu+BXky9+a6+oyyklMTNTBgwd18OBBrVy50qktPDxckjR48GDNnz9fklRSUqLk5GRt2bJFHh4eGj58uOLj41WnTh1J0pYtW7Ry5UpdvHhR9erVU/fu3TV16lT5+/tL+v9nd37/+99rwYIFOnPmjFauXKlu3brVyPgIMMAt3Ovr21VRU9fEARjbu+++q4sXL6pNmzaKj49XSUmJjh49qnHjxmnHjh0ymUzy9vZ29N+8ebOGDBmiLVu26Pjx45oyZYqaNWumX/ziF5Kk4uJixcfHKygoSDk5OZo1a5YmTpyo5cuXO+13/vz5euedd9SiRYsa/W8TAQa4CVdc366Kyl4TB/Bg8PX1laenp+rVq6eAgABJUoMGDSRJjRo1KjcH5pFHHtHUqVNVp04dBQUFKSMjQytWrHAEmCFDhjj6Pvroo3r33Xc1aNAgXb9+XQ899JCjbcKECXrqqadqeHQEGOCm7vX17aow2jVxALVXp06dHJeLpB8uM/3+979XSUmJ3NzcdPz4cS1evFjp6em6du2aSktLJUlZWVlq3bq143thYWH3pF4CDHAbtfX6NgDcK1arVaNGjVJUVJQWLlyohg0bKisrSy+//LKKioqc+vr4+NyTmggwAADcpzw8PFTyo8vgHh4ekuS0rsyxY8eclo8ePaqWLVvKzc1N58+f19WrV5WYmKhmzZpJko4fP16Dld8eT+IFAOA+FRgYqGPHjikzM1P//ve/FRgYqDp16mjnzp3KycnR9evXHX2zsrI0a9YsXbhwQSkpKVq9erVGjhwpSWrWrJk8PT21evVqffvtt9qxY4f++7//21XDksQZGAAA7kpuPVOt3c+rr76qxMRE9e3bVzdu3NCuXbv0q1/9SvPnz9fbb7+tQYMGOW6jHjRokG7cuKFBgwbJzc1NI0eO1LBhwyT9MOl33rx5+uCDD7Rq1Sq1b99e77zzjl577bVqHWNlEGAAAKgCHx8febi5aZe58z3bp4ebW6XmmLRq1UqbNm1yWjd+/HiNHz/ead369esdP8+YMaPCbQ0YMEADBgxwWnf+/HnHz926dXNarmkEGAAAqsDPz0/jxo+/L96FZEQEGAAAqsjPz49A4SJM4gUAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZzVwFm6dKlMpvNTo8dLiwsVFJSkrp06aKwsDCNHTtW2dnZTt/LyspSXFyc2rdvr4iICM2ZM0fFxcVOfQ4cOKABAwaobdu26tWrV7lHIQMAgAdXlQPM119/rQ0bNig0NNRp/cyZM/XFF19oyZIlWr9+va5cuaI33njD0V5SUqK4uDgVFRVp48aNmj9/vjZv3qxFixY5+ly+fFmvvPKKunXrptTUVI0aNUqTJ0/W7t27q1ouAAC4j1QpwFy/fl3x8fGaPXu20yOU8/LytHHjRk2ZMkU9evRQWFiY5s2bp6+++kppaWmSpD179ujcuXNasGCB2rVrp549eyo+Pl5r1qyRzWaT9MNLpZo3b67JkycrODhYv/zlL9WvXz8tX768GoYMAACMrkoBJikpSb169VJkZKTT+uPHj6uoqMhpvdlsVrNmzRwBJi0tTSEhIfL393f0iYqKUn5+vs6ePevo89NtR0dHO7ZRkcLCQuXl5Tk+9/LlWgAA4N6q9MscU1NTdfLkSW3durVcW3Z2tjw9PVW/fn2n9f7+/rJYLJIki8XiFF7K2svabtanUaNGys/P140bN+Tt7V1u30uXLtXixYsrOxwAAGBAlQowWVlZmjFjhlavXi0vL6+aqqlKxowZo9GjRzuW09PTNWzYMBdWBAAAakqlAsyJEyeUk5OjAQMGONaVlJTo0KFDWrNmjVasWCGbzaZr1645nYXJzs5WQECAJCkgIEBff/2103bL7lL6cZ+f3rmUk5Mjk8lU4dkXSfLy8nIKVT4+PpUZGgAAMJBKBZgePXpo27ZtTuvefvttmc1mvfbaa2rWrJk8PDy0b98+9evXT5J04cIFZWVlKTw8XJIUHh6ujz76SNnZ2Y7LRHv37pXJZFJwcLCjz5dffum0n7179zq2AQAAHmyVCjAmk0khISFO63x8fNSgQQPH+iFDhmjWrFny8/OTyWTS9OnTFR4e7ggfUVFRCg4OVkJCgt5++21ZLBYtWLBAsbGxjjMow4cP15o1azR37lwNGTJE+/fv17Zt27Rs2bLqGDMAADC4Sk/ivZ2pU6eqbt26GjdunGw2m6KiovTee+852t3c3LRs2TJNmzZNMTEx8vHx0aBBgzRhwgRHnxYtWmjZsmWaNWuWVq1apaZNm2r27NmKjo6u7nIBAIAB3XWAWb9+vdOyl5eXpk+frunTp9/0O4GBgbd9pkvZQ+wAAAB+inchAQAAwyHAAAAAwyHAAAAAwyHAAAAAwyHAAAAAwyHAAAAAwyHAAAAAwyHAAAAAwyHAAAAAwyHAAAAAwyHAAAAAwyHAAAAAwyHAAAAAwyHAAAAAw3F3dQEA7p7FYnF1Cbfk4+MjPz8/V5cB4D5CgAEMzLvYJnd7qbZs2eLqUm7Jw81N48aPJ8QAqDYEGMDATLYCDT62UzfcPV1dyk3l1jNpl7mzrFYrAQZAtSHAAAZnshXIZCtwdRkAcE8xiRcAABgOAQYAABgOAQYAABgOAQYAABgOAQYAABgOAQYAABgOAQYAABgOAQYAABgOAQYAABgOAQYAABgOAQYAABgOAQYAABhOpQLMunXr9Nxzz6ljx47q2LGjYmJi9OWXXzrahw8fLrPZ7PSZOnWq0zaysrIUFxen9u3bKyIiQnPmzFFxcbFTnwMHDmjAgAFq27atevXqpU2bNlV9hAAA4L5TqbdRN23aVImJiWrZsqUk6Q9/+IPGjBmjlJQUtWnTRpI0dOhQxcfHO77j7e3t+LmkpERxcXEKCAjQxo0bdeXKFSUmJsrDw0MJCQmSpMuXL+uVV17R8OHDtWDBAu3bt0+TJ09W48aNFR0dfbfjBQAA94FKBZjevXs7LSckJGj9+vU6evSoI8DUq1dPAQEBFX5/z549OnfunNasWSN/f3+1a9dO8fHxmjdvnt588015enpq/fr1at68uSZPnixJCg4O1pEjR7R8+XICDAAAkHQXc2BKSkqUmpqqgoIChYeHO9anpKToiSeeUL9+/TR//nwVFBQ42tLS0hQSEiJ/f3/HuqioKOXn5+vs2bOOPpGRkU77io6OVlpa2i3rKSwsVF5enuNjtVqrOjQAAFDLVeoMjCRlZGQoJiZGhYWF8vHx0UcffaTWrVtLkp5//nkFBgaqSZMmOn36tN5//31duHBBH3/8sSTJYrE4hRdJjmWLxXLTPo0aNVJ+fr5u3LjhdEnqx5YuXarFixdXdjgAAMCAKh1gWrVqpdTUVOXl5ekvf/mLJk6cqPXr16t169YaNmyYo19ISIgCAgIUGxurS5cu6bHHHqvWwn9qzJgxGj16tGM5PT3dqR4AAHD/qPQlJE9PT7Vs2VJhYWFKTExUaGioVq5cWWHfTp06SZIuXbokSQoICFB2drZTn7LlsnkzFfXJycmRyWS66dkXSfLy8pKvr6/j4+PjU9mhAQAAg7jr58CUlpbKZrNV2Hbq1ClJUuPGjSVJ4eHhysjIcAooe/fulclkUnBwsKPPvn37nLazd+9ep3k2AADgwVapADN//nwdOnRImZmZysjI0Pz583Xw4EENHDhQly5d0pIlS3T8+HFlZmZqx44dSkxMVNeuXRUaGirphwm7wcHBSkhIUHp6unbv3q0FCxYoNjZWXl5ekn54lszly5c1d+5cnT9/XmvXrtW2bducLg8BAIAHW6XmwOTk5CghIUEWi0Umk8lx+eipp55SVlaW9u3bp5UrV8pqteqRRx5R3759NW7cOMf33dzctGzZMk2bNk0xMTHy8fHRoEGDNGHCBEefFi1aaNmyZZo1a5ZWrVqlpk2bavbs2dxCDQAAHCoVYObOnXvTtmbNmmnDhg233UZgYKCWL19+yz7dunVTampqZUqDAeXm5tbq293L7owDANQ+lb4LCagOubm5+s2SJSoqKXF1Kbfkbi+Vd3HFc7wAAK5DgIFLWK1WFZWU6OnzX8mvIN/V5dyUd7FNJlvB7TsCAO4pAgxcyq8gX/7WXFeXAQAwmLu+jRoAAOBeI8AAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDIcAAAADDcXd1AQAeDBaLxdUl3JKPj4/8/PxcXQaAO0SAAVCjvIttcreXasuWLa4u5ZY83Nw0bvx4QgxgEAQYADXKZCvQ4GM7dcPd09Wl3FRuPZN2mTvLarUSYACDIMAAqHEmW4FMtgJXlwHgPsIkXgAAYDgEGAAAYDgEGAAAYDgEGAAAYDiVCjDr1q3Tc889p44dO6pjx46KiYnRl19+6WgvLCxUUlKSunTporCwMI0dO1bZ2dlO28jKylJcXJzat2+viIgIzZkzR8XFxU59Dhw4oAEDBqht27bq1auXNm3aVPURAgCA+06lAkzTpk2VmJiorVu3auvWrerWrZvGjBmjM2fOSJJmzpypL774QkuWLNH69et15coVvfHGG47vl5SUKC4uTkVFRdq4caPmz5+vzZs3a9GiRY4+ly9f1iuvvKJu3bopNTVVo0aN0uTJk7V79+7qGTEAADC8St1G3bt3b6flhIQErV+/XkePHtUjjzyijRs3auHCherRo4ckad68eerTp4/S0tIUHh6uPXv26Ny5c1qzZo38/f3Vrl07xcfHa968eXrzzTfl6emp9evXq3nz5po8ebIkKTg4WEeOHNHy5csVHR1dTcMGAABGVuU5MCUlJUpNTVVBQYHCw8N1/PhxFRUVKTIy0tHHbDarWbNmSktLkySlpaUpJCRE/v7+jj5RUVHKz8/X2bNnHX1+vA1Jio6OdmwDAACg0g+yy8jIUExMjAoLC+Xj46OPPvpIrVu3Vnp6ujw9PVW/fn2n/v7+/o53oFgsFqfwUtZe1nazPo0aNVJ+fr5u3Lghb2/vCusqLCyUzWZzLFut1soODQAAGESlA0yrVq2UmpqqvLw8/eUvf9HEiRO1fv36mqitUpYuXarFixe7ugwAAHAPVDrAeHp6qmXLlpKksLAwff3111q5cqV+9rOfyWaz6dq1a05nYbKzsxUQECBJCggI0Ndff+20vbK7lH7c56d3LuXk5MhkMt307IskjRkzRqNHj3Ysp6ena9iwYZUdHgAAMIC7fg5MaWmpbDabwsLC5OHhoX379jnaLly4oKysLIWHh0uSwsPDlZGR4RRQ9u7dK5PJpODgYEefH2+jrE/ZNm7Gy8tLvr6+jo+Pj8/dDg0AANRSlQow8+fP16FDh5SZmamMjAzNnz9fBw8e1MCBA+Xr66shQ4Zo1qxZ2r9/v44fP66JEycqPDzcET6ioqIUHByshIQEpaena/fu3VqwYIFiY2Pl5eUlSRo+fLguX76suXPn6vz581q7dq22bdvmdHYFAAA82Cp1CSknJ0cJCQmyWCwymUwKDQ3VypUr9dRTT0mSpk6dqrp162rcuHGy2WyKiorSe++95/i+m5ubli1bpmnTpikmJkY+Pj4aNGiQJkyY4OjTokULLVu2TLNmzdKqVavUtGlTzZ49m1uoAQCAQ6UCzNy5c2/Z7uXlpenTp2v69Ok37RMYGKjly5ffcjtlD7EDAACoCO9CAgAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhkOAAQAAhlOpAPPxxx/rhRdeUIcOHRQREaHXX39dFy5ccOozfPhwmc1mp8/UqVOd+mRlZSkuLk7t27dXRESE5syZo+LiYqc+Bw4c0IABA9S2bVv16tVLmzZtquIQAQDA/ca9Mp0PHjyoESNGqEOHDiopKdGvf/1rjRw5Un/961/l4+Pj6Dd06FDFx8c7lr29vR0/l5SUKC4uTgEBAdq4caOuXLmixMREeXh4KCEhQZJ0+fJlvfLKKxo+fLgWLFigffv2afLkyWrcuLGio6PvdswAAMDgKhVgVq5c6bT8/vvvq2vXrjpx4oS6du3qWF+vXj0FBARUuI09e/bo3LlzWrNmjfz9/dWuXTvFx8dr3rx5evPNN+Xp6an169erefPmmjx5siQpODhYR44c0fLlywkwAADg7ubA5OXlSZL8/Pyc1qekpOiJJ55Qv379NH/+fBUUFDja0tLSFBISIn9/f8e6qKgo5efn6+zZs44+kZGRTtuMjo5WWlraTWspLCxUXl6e42O1Wu9maAAAoBar1BmYHystLdXMmTPVpUsXhYSEONY///zzCgwMVJMmTXT69Gm9//77unDhgj7++GNJksVicQovkhzLFovlpn0aNWqk/Px83bhxw+mSVJmlS5dq8eLFVR0OAAAwkCoHmKSkJJ05c0afffaZ0/phw4Y5fg4JCVFAQIBiY2N16dIlPfbYY1Wv9DbGjBmj0aNHO5bT09OdagEAAPePKl1CSk5O1s6dO7Vu3To98sgjt+zbqVMnSdKlS5ckSQEBAcrOznbqU7ZcNm+moj45OTkymUwVnn2RJC8vL/n6+jo+P55UDAAA7i+VCjB2u13Jycnavn271q5dqxYtWtz2O6dOnZIkNW7cWJIUHh6ujIwMp4Cyd+9emUwmBQcHO/rs27fPaTt79+5VeHh4ZcoFAAD3qUoFmKSkJG3dulULFy6UyWSSxWKRxWLRjRs3JP1wlmXJkiU6fvy4MjMztWPHDiUmJqpr164KDQ2V9MOE3eDgYCUkJCg9PV27d+/WggULFBsbKy8vL0k/PEvm8uXLmjt3rs6fP6+1a9dq27ZtTpeIAADAg6tSc2DWrVsn6YeA8WPz5s1TTEyMPDw8tG/fPq1cuVJWq1WPPPKI+vbtq3Hjxjn6urm5admyZZo2bZpiYmLk4+OjQYMGacKECY4+LVq00LJlyzRr1iytWrVKTZs21ezZs7mFGgAASKpkgDl//vwt25s1a6YNGzbcdjuBgYFavnz5Lft069ZNqamplSkPAAA8IHgXEgAAMBwCDAAAMBwCDAAAMBwCDAAAMBwCDAAAMBwCDAAAMBwCDAAAMJwqv8wRAO43FovF1SXcko+Pj/z8/FxdBlArEGAAPPC8i21yt5dqy5Ytri7lljzc3DRu/HhCDCACDADIZCvQ4GM7dcPd09Wl3FRuPZN2mTvLarUSYAARYABA0g8hxmQrcHUZAO4Qk3gBAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhEGAAAIDhVCrAfPzxx3rhhRfUoUMHRURE6PXXX9eFCxec+hQWFiopKUldunRRWFiYxo4dq+zsbKc+WVlZiouLU/v27RUREaE5c+aouLjYqc+BAwc0YMAAtW3bVr169dKmTZuqOEQAAHC/qVSAOXjwoEaMGKFNmzZp9erVKi4u1siRI2W1Wh19Zs6cqS+++EJLlizR+vXrdeXKFb3xxhuO9pKSEsXFxamoqEgbN27U/PnztXnzZi1atMjR5/Lly3rllVfUrVs3paamatSoUZo8ebJ279599yMGAACG516ZzitXrnRafv/999W1a1edOHFCXbt2VV5enjZu3KiFCxeqR48ekqR58+apT58+SktLU3h4uPbs2aNz585pzZo18vf3V7t27RQfH6958+bpzTfflKenp9avX6/mzZtr8uTJkqTg4GAdOXJEy5cvV3R0dPWMHAAAGNZdzYHJy8uTJPn5+UmSjh8/rqKiIkVGRjr6mM1mNWvWTGlpaZKktLQ0hYSEyN/f39EnKipK+fn5Onv2rKPPj7chSdHR0Y5tVKSwsFB5eXmOz4/PCgEAgPtLpc7A/FhpaalmzpypLl26KCQkRJKUnZ0tT09P1a9f36mvv7+/LBaLJMlisTiFl7L2srab9WnUqJHy8/N148YNeXt7l6tn6dKlWrx4cVWHAwAADKTKASYpKUlnzpzRZ599Vp31VNmYMWM0evRox3J6erqGDRvmwooAAEBNqdIlpOTkZO3cuVPr1q3TI4884ljv7+8vm82ma9euOfXPzs5WQECAJCkgIKDcXUlly7fqk5OTI5PJVOHZF0ny8vKSr6+v4+Pj41OVoQEAAAOoVICx2+1KTk7W9u3btXbtWrVo0cKpPSwsTB4eHtq3b59j3YULF5SVlaXw8HBJUnh4uDIyMpwCyt69e2UymRQcHOzo8+NtlPUp2wYAAHiwVSrAJCUlaevWrVq4cKFMJpMsFossFotu3LghSfL19dWQIUM0a9Ys7d+/X8ePH9fEiRMVHh7uCB9RUVEKDg5WQkKC0tPTtXv3bi1YsECxsbHy8vKSJA0fPlyXL1/W3Llzdf78ea1du1bbtm1zukQEAAAeXJWaA7Nu3TpJPwSMH5s3b55iYmIkSVOnTlXdunU1btw42Ww2RUVF6b333nP0dXNz07JlyzRt2jTFxMTIx8dHgwYN0oQJExx9WrRooWXLlmnWrFlatWqVmjZtqtmzZ3MLNQAAkFTJAHP+/Pnb9vHy8tL06dM1ffr0m/YJDAzU8uXLb7mdsofYAQAA/BTvQgIAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIZDgAEAAIbj7uoCAAB3zmKxuLqEW/Lx8ZGfn5+ry8ADgAADAAbgXWyTu71UW7ZscXUpt+Th5qZx48cTYlDjCDAAYAAmW4EGH9upG+6eri7lpnLrmbTL3FlWq5UAgxpHgAEAgzDZCmSyFbi6DKBWYBIvAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwnEoHmEOHDunVV19V9+7dZTabtX37dqf2xMREmc1mp8/LL7/s1Of7779XfHy8OnbsqE6dOmnSpEm6fv26U5/Tp09r6NChatu2rSIjI/Xb3/628qMDAAD3pUq/SsBqtSo0NFQxMTEaO3ZshX2io6P1/vvvO5Y9PZ3f3REfHy+LxaJVq1apuLhYEydO1JQpU7Ro0SJJUl5enkaOHKnIyEjNmDFDGRkZmjRpkurXr69hw4ZVtmQAAHCfqXSA6dmzp3r27HnLPp6engoICKiw7dy5c9q9e7e2bNmiDh06SJKSkpIUFxend955R02aNFFKSoqKioo0d+5ceXp6qk2bNkpPT9fy5csJMAAAoGbmwBw8eFARERF65plnNG3aNF29etXRlpaWpvr16zvCiyRFRkaqbt26Onr0qCTpq6++UkREhNOZm6ioKF24cEG5ubk1UTIAADCQan8bdXR0tPr27asWLVro0qVL+uCDDzR69Ght2rRJbm5uslgsatSokXMR7u7y8/NTdna2JCk7O1vNmzd36uPv7y9JslgsFb6mvbCwUDabzbFstVqre2gAAKCWqPYA8/zzzzt+DgkJUWhoqHr16qUDBw4oMjKyunfnsHTpUi1evLjGtg8AAGqPGr+N+tFHH1XDhg116dIlSVJAQIBycnKc+hQXFys3N9dxlsXf399xNqZM2fLN5taMGTNGR48edXw2bNhQ3UMBAAC1RI0HmH/+85+6evWqGjduLEkKDw/XtWvXdPz4cUef/fv3q7S0VJ06dZIkde7cWYcPH1ZRUZGjzz/+8Q8FBQVVePlIkry8vOTr6+v4+Pj41NygAACAS1U6wFy/fl2nTp3SqVOnJEmZmZk6deqUsrKydP36dc2ZM0dpaWnKzMzUP/7xD73++ut67LHHFBUVJUkKDg5WdHS0pkyZomPHjunIkSNKTk5W//791aRJE0nSgAED5OHhoUmTJunMmTP64x//qJUrV2r06NHVOHQAAGBUlZ4Dc/z4cb300kuO5VmzZkmSBg8e7Hhmy+bNm5WXl6fGjRvrqaee0ltvvSUvLy/HdxYuXKjk5GTFxsaqTp066tevn959911Hu6+vr1atWqWkpCQNHDhQDRs21Pjx47mFGgAASKpCgOnWrZvOnz9/0/aVK1fedhsNGjRwPLTuZkJDQ/XZZ59VsjoAAPAg4F1IAADAcAgwAADAcAgwAADAcAgwAADAcAgwAADAcAgwAADAcKr9XUgAgAebxWJxdQm35OPjc9OnusM4CDAAgGrhXWyTu71UW7ZscXUpt+Th5qZx48cTYgyOAAMAqBYmW4EGH9upG+6eri7lpnLrmbTL3FlWq5UAY3AEGABAtTHZCmSyFbi6DDwAmMQLAAAMhwADAAAMhwADAAAMhzkw96nc3FxZrVZXl3FTtf02SwBA7UaAuQ/l5ubqN0uWqKikxNWl3JK7vVTexTZXlwEAMCACzH3IarWqqKRET5//Sn4F+a4u56a8i23crQAAqBICzH3MryBf/tZcV5cBAEC1YxIvAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwHAIMAAAwnEoHmEOHDunVV19V9+7dZTabtX37dqd2u92uhQsXqlu3bmrXrp1iY2N18eJFpz7ff/+94uPj1bFjR3Xq1EmTJk3S9evXnfqcPn1aQ4cOVdu2bRUZGanf/va3VRgeAAC4H1U6wFitVoWGhio5ObnC9k8++USrVq3SjBkztHnzZvn4+GjUqFEqLCx09ImPj9fZs2e1atUqLVu2TIcOHdKUKVMc7Xl5eRo5cqQCAwP1P//zP5o0aZIWL16sDRs2VH6EAADgvuNe2S/07NlTPXv2rLDNbrdrxYoVGjdunJ599llJ0q9//Wt17dpV27dv1/PPP69z585p9+7d2rJlizp06CBJSkpKUlxcnN555x01adJEKSkpKioq0ty5c+Xp6ak2bdooPT1dy5cv17Bhw6o+WgAAcF+o1jkwly9flsViUWRkpGOdr6+vOnXqpLS0NElSWlqa6tev7wgvkhQZGam6devq6NGjkqSvvvpKERER8vT0dPSJiorShQsXlJubW+G+CwsLlZeX5/hYrdbqHBoAAKhFKn0G5lYsFoskyd/f32m9v7+/o81isahRo0bORbi7y8/PT9nZ2ZKk7OxsNW/evNw2yr7v5+dXbt9Lly7V4sWLq2cgAACgVqvWAONKY8aM0ejRox3L6enpXG4CAOA+Va2XkAICAiTJcSalTHZ2tqMtICBAOTk5Tu3FxcXKzc11nGXx9/evcBs/3sdPeXl5ydfX1/Hx8fG5+wEBAIBaqVoDTIsWLRQQEKB9+/Y51uXl5eno0aMKDw+XJIWHh+vatWs6fvy4o8/+/ftVWlqqTp06SZI6d+6sw4cPq6ioyNHnH//4h4KCgiq8fAQAAB4slQ4w169f16lTp3Tq1ClJUmZmpk6dOqWsrCzVqVNHo0aN0m9+8xvt2LFDGRkZSkhIUJMmTdSnTx9JUnBwsKKjozVlyhQdO3ZMR44cUXJysvr3768mTZpIkgYMGCAPDw9NmjRJZ86c0R//+EetXLnS6RIRAAB4cFV6Dszx48f10ksvOZZnzZolSRo8eLDmz5+v1157TVarVVOmTNG1a9f0xBNPaMWKFfLy8nJ8Z+HChUpOTlZsbKzq1Kmjfv366d1333W0+/r6atWqVUpKStLAgQPVsGFDjR8/njktAABAUhUCTLdu3XT+/PmbttepU0fx8fGKj4+/aZ8GDRpo0aJFt9xPaGioPvvss8qWBwAAHgC8CwkAABjOfXMbNQAAd6rs2WS1lY+PDzet3AYBBgDwwPAutsndXqotW7a4upRb8nBz07jx4wkxt0CAAQA8MEy2Ag0+tlM33D1v39lFcuuZtMvcWVarlQBzCwQYAMADxWQrkMlW4OoycJeYxAsAAAyHAAMAAAyHAAMAAAyHAAMAAAyHAAMAAAyHAAMAAAyHAAMAAAyHAAMAAAyHAAMAAAyHAAMAAAyHAAMAAAyHAAMAAAyHAAMAAAyHt1EDAFALWSwWV5dwSz4+PvLz83PZ/gkwAADUIt7FNrnbS7VlyxZXl3JLHm5uGjd+vMtCDAEGAIBaxGQr0OBjO3XD3dPVpdxUbj2Tdpk7y2q1EmAAAMAPTLYCmWwFri6jVmMSLwAAMBwCDAAAMBwCDAAAMBwCDAAAMBwCDAAAMBwCDAAAMBwCDAAAMBwCDAAAMJxqDzAffvihzGaz0+fZZ591tBcWFiopKUldunRRWFiYxo4dq+zsbKdtZGVlKS4uTu3bt1dERITmzJmj4uLi6i4VAAAYVI08ibd169Zas2aNY9nNzc3x88yZM/X3v/9dS5Yska+vr6ZPn6433nhDGzdulCSVlJQoLi5OAQEB2rhxo65cuaLExER5eHgoISGhJsoFAAAGUyOXkNzd3RUQEOD4NGzYUJKUl5enjRs3asqUKerRo4fCwsI0b948ffXVV0pLS5Mk7dmzR+fOndOCBQvUrl079ezZU/Hx8VqzZo1sNltNlAsAAAymRgLMN998o+7duzvCR1ZWliTp+PHjKioqUmRkpKOv2WxWs2bNHAEmLS1NISEh8vf3d/SJiopSfn6+zp49e9N9FhYWKi8vz/GxWq01MTQAAFALVPslpI4dO+r9999XUFCQrly5osWLF2vo0KH685//rOzsbHl6eqp+/fpO3/H395fFYpEkWSwWp/BS1l7WdjNLly7V4sWLq3k0AACgNqr2ANOzZ0/Hz6GhoerUqZOioqK0bds2eXt7V/fuHMaMGaPRo0c7ltPT0zVs2LAa2x8AAHCdGr+Nun79+mrVqpUuXbokf39/2Ww2Xbt2zalPdna2AgICJEkBAQHl7koqWy7rUxEvLy/5+vo6Pj4+PtU8EgAAUFvUeIC5fv26vv32WwUEBCgsLEweHh7at2+fo/3ChQvKyspSeHi4JCk8PFwZGRlOIWbv3r0ymUwKDg6u6XIBAIABVPslpNmzZ6t3794KDAzUd999pw8//FBubm56/vnn5evrqyFDhmjWrFny8/OTyWTS9OnTFR4e7ggwUVFRCg4OVkJCgt5++21ZLBYtWLBAsbGx8vLyqu5yAQCAAVV7gPnXv/6lCRMm6Pvvv1fDhg3VpUsXbdq0SY0aNZIkTZ06VXXr1tW4ceNks9kUFRWl9957z/F9Nzc3LVu2TNOmTVNMTIx8fHw0aNAgTZgwobpLBQAABlXtAeZ2dwJ5eXlp+vTpmj59+k37BAYGavny5dVdGgAAuE/wLiQAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA4BBgAAGA47q4uwIhyc3NltVpdXcZNWSwWV5cAAECNIsBUUm5urn6zZImKSkpcXcotudtL5V1sc3UZAADUiFodYNasWaPf/e53slgsatu2rZKSktSxY0eX1mS1WlVUUqKnz38lv4J8l9ZyK97FNplsBa4uAwCAGlFrA8wf//hHzZ49WzNmzFDHjh21YsUKvfzyy/rb3/4mf39/V5cnv4J8+VtzXV0GAAAPpFo7iXf58uUaOnSoYmJi1Lp1a82cOVP16tXTpk2bXF0aAABwsVoZYGw2m06cOKEePXo41tWtW1c9evRQWlqaCysDAAC1Qa28hHT16lWVlJSUu1Tk7++vCxcuVPidwsJC2Wz/f9Lq1atXJUnnz5+v1tqys7OVk5OjNLuH/ORdrdsGAMAI8kvclJOTo4yMDOXk5FTrtsv+3S4sLLxlv1oZYKpi6dKlWrx4cbn1b731Vo3s7081slUAAAzi2Hn96U81969hZmamunTpctP2WhlgHn74Ybm5uSk7O9tpfXZ2tgICAir8zpgxYzR69GjH8tWrV3X48GG1bNlSXl5et92n1WrVsGHDtGHDBvn4+NzdAFCtODa1E8el9uLY1E4clztTWFiozMxMRUVF3bJfrQwwnp6eevzxx7Vv3z716dNHklRaWqr9+/crNja2wu94eXk5BRVfX189+uijd7zPvLw8SVLbtm3l6+t7F9WjunFsaieOS+3FsamdOC537lZnXsrUygAjSaNHj1ZiYqLCwsIct1FbrVbFxMS4ujQAAOBitTbA9O/fX//+97+1aNEiZWdnq23btlqxYkWteAYMAABwrVobYCTpl7/8pX75y1/ek315enrqzTfflKen5z3ZH+4cx6Z24rjUXhyb2onjUr3q2O12u6uLAAAAqIxa+SA7AACAWyHAAAAAwyHAAAAAwyHAAAAAw7nvA8yhQ4f06quvqnv37jKbzdq+fbtTu91u18KFC9WtWze1a9dOsbGxunjxolOf77//XvHx8erYsaM6deqkSZMm6fr16/dyGPeVjz/+WC+88II6dOigiIgIvf766+XecVVYWKikpCR16dJFYWFhGjt2bLknM2dlZSkuLk7t27dXRESE5syZo+Li4ns5lPvOunXr9Nxzz6ljx47q2LGjYmJi9OWXXzraOS61w9KlS2U2mzVjxgzHOo6Na3z44Ycym81On2effdbRznGpOfd9gLFarQoNDVVycnKF7Z988olWrVqlGTNmaPPmzfLx8dGoUaOcXiIVHx+vs2fPatWqVVq2bJkOHTqkKVOm3KMR3H8OHjyoESNGaNOmTVq9erWKi4s1cuRIWa1WR5+ZM2fqiy++0JIlS7R+/XpduXJFb7zxhqO9pKREcXFxKioq0saNGzV//nxt3rxZixYtcsGI7h9NmzZVYmKitm7dqq1bt6pbt24aM2aMzpw5I4njUht8/fXX2rBhg0JDQ53Wc2xcp3Xr1jpw4IDj89lnnznaOC41yP4ACQoKsv/1r391LJeWltqffPJJ+yeffOJYd+3aNXtoaKg9JSXFbrfb7WfPnrUHBQXZjx075ujz5Zdf2s1ms/1f//rXvSv+PpadnW0PCgqyHzx40G63/3AMQkJC7Nu2bXP0OXfunD0oKMj+1Vdf2e12u/3vf/+7PTg42G6xWBx91q1bZ+/QoYO9sLDw3g7gPhceHm7/7LPPOC61QH5+vv0//uM/7Hv37rUPGzbM/t5779ntdv5mXGnRokX2n/3sZxW2cVxq1n1/BuZWLl++LIvFosjISMc6X19fderUSWlpaZKktLQ01a9fXx06dHD0iYyMVN26dXX06NF7XfJ9qez9IH5+fpKk48ePq6ioyOm4mM1mNWvWzOm4hISEOD2ZOSoqSvn5+Tp79uw9rP7+VVJSotTUVBUUFCg8PJzjUgskJSWpV69eTsdA4m/G1b755ht1795dPXv2VHx8vLKysiRxXGparX4Sb02zWCySVO71BP7+/o42i8WiRo0aObW7u7vLz8+v3HVMVF5paalmzpypLl26KCQkRNIPbx339PRU/fr1nfr+9LhUdNzK2lB1GRkZiomJUWFhoXx8fPTRRx+pdevWSk9P57i4UGpqqk6ePKmtW7eWa+NvxnU6duyo999/X0FBQbpy5YoWL16soUOH6s9//jPHpYY90AEGrpeUlKQzZ844XTOGa7Vq1UqpqanKy8vTX/7yF02cOFHr1693dVkPtKysLM2YMUOrV6+Wl5eXq8vBj/Ts2dPxc2hoqDp16qSoqCht27ZN3t7erivsAfBAX0IKCAiQpHJnUrKzsx1tAQEBysnJcWovLi5Wbm4uL5a8S8nJydq5c6fWrVunRx55xLHe399fNptN165dc+r/0+NS0XEra0PVeXp6qmXLlgoLC1NiYqJCQ0O1cuVKjosLnThxQjk5ORowYIDatGmjNm3a6ODBg1q1apXatGmjRo0acWxqifr166tVq1a6dOkSfzM17IEOMC1atFBAQID27dvnWJeXl6ejR48qPDxckhQeHq5r167p+PHjjj779+9XaWmpOnXqdK9Lvi/Y7XYlJydr+/btWrt2rVq0aOHUHhYWJg8PD6fjcuHCBWVlZTkdl4yMDKc//L1798pkMik4OPjeDOQBUVpaKpvNxnFxoR49emjbtm1KTU11fMLCwjRw4EClpqaqQ4cOHJta4vr16/r2228VEBDA30wNu+8vIV2/fl2XLl1yLGdmZurUqVNq0KCBmjVrplGjRuk3v/mNWrZsqRYtWmjBggVq0qSJ+vTpI0kKDg5WdHS0pkyZohkzZqioqEjJycnq37+/mjRp4qphGVpSUpJSUlL029/+ViaTyXGd19fXV97e3vL19dWQIUM0a9Ys+fn5yWQyafr06QoPD3f80UdFRSk4OFgJCQl6++23ZbFYtGDBAsXGxnKK/S7Mnz9fTz/9tJo1a6br168rJSVFBw8e1MqVKzkuLmQymRxzxMr4+PioQYMGjvUcG9eYPXu2evfurcDAQH333Xf68MMP5ebmpueff56/mZrm6tugatr+/fvtQUFB5T4JCQl2u/2HW6kXLFhg79q1qz00NNQ+YsQI+4ULF5y2cfXqVfuvfvUre1hYmL1Dhw72iRMn2vPz810xnPtCRccjKCjIvnHjRkefGzdu2N999117eHi4vX379vYxY8bYr1y54rSdzMxM+6hRo+zt2rWzP/HEE/ZZs2bZi4qK7vVw7itvv/22PSoqyh4aGmp/4okn7CNGjLDv2bPH0c5xqT1+fBu13c6xcZXx48fbu3XrZg8NDbX36NHDPn78ePs333zjaOe41Jw6drvd7uoQBQAAUBkP9BwYAABgTAQYAABgOAQYAABgOAQYAABgOAQYAABgOAQYAABgOAQYAABgOAQYAABgOAQYAABgOAQYALVKYmKizGazzGaz+vXr5+pyKrRixQpHjWazWf/+979dXRLwwCHAAKiU3bt3y2w2KyUlpcL21157TY8//rhKS0urvI+GDRvqgw8+0MSJE8u1Xb58WcnJyerdu7fat2+v9u3bq2/fvkpKStLp06crva/XXntN7du3V35+/k37xMfHKzQ0VFevXpUkRUdH64MPPnC89BXAvXffv40aQPVKT0+XJIWFhVXYfuLECbVp00Z161b9/x/Vq1dPL7zwQrn1O3fu1Jtvvik3NzcNHDhQoaGhqlu3ri5cuKC//vWvWrdunXbt2qXAwMA73teAAQP0xRdfaPv27Ro8eHC59oKCAu3YsUPR0dF6+OGHJclx5uXSpUvavn17lccJoOoIMAAqJSMjQyaTSS1btizXZrFY9N1336lnz57Vvt9Lly7pV7/6lQIDA7VmzRo1btzYqX3ixIlau3at6tSpU6ntPvPMMzKZTEpJSakwwPztb3+T1WrVgAED7qp+ANWLS0gAKiU9PV3t27evMCicOHFCktS2bdtq3+8nn3wiq9WqefPmlQsvkuTu7q6XX35ZzZo1c1r/r3/9S2+//ba6du2qtm3bql+/ftq4caOj3dvbW3369NH+/fuVnZ1dbrupqakymUx65plnqn1MAKqOMzAA7pjNZtPFixfVvn17ffPNN+Xa9+/fL0kKDQ2t9n3//e9/12OPPaZOnTrd8Xeys7P14osvqk6dOoqNjVWjRo20a9cuTZo0Sfn5+Ro1apQkaeDAgdq8ebO2bdumX/7yl47vf//999qzZ4/69+8vb2/v6h4SgLtAgAFwx86dO6eioiJt2bJFW7ZsuWm/6g4weXl5+u677/Tss8+Wa7t27ZqKi4sdyz4+Po6w8cEHH6i0tFTbtm1zzF8ZPny4fvWrX+nDDz/UsGHD5O3tre7du6tx48ZKSUlxCjDbtm1TUVGRBg4cWK3jAXD3CDAA7ljZXT5Tp05V06ZNy7VPmzZNDz30kHx9fat1v2V3CD300EPl2oYPH+6YWCxJkyZN0quvviq73a6//OUveu6552S3251udY6KitIf//hHnThxQk888YTc3NzUv39/LV++XJmZmWrevLmkHy4f+fv7q0ePHtU6HgB3jwAD4I6dPn1abm5uGj58uLy8vJzabty4odzcXHXp0kWS9Pnnn2vGjBmSpKKiItntdnl6ekqSOnfurFWrVt3xfk0mkyTp+vXr5dpmzpyp69evKzs7W2+99ZZjfU5Ojq5du6ZPP/1Un376aYXbzcnJcfw8YMAALV++XCkpKRo7dqz++c9/6vDhwxo5cqTc3NzuuFYA9wYBBsAdO336tB599NFy4UX64fJSaWmp4/LRz3/+c/385z+XJE2ePFkPPfSQpkyZUqX9+vr6qnHjxjpz5ky5trI5MZmZmU7r7Xa7JOmFF16o8O4iSQoJCXH8HBYWJrPZrNTUVI0dO1apqamy2+1cPgJqKQIMgDt2+vRpxxmWnzp79qykiu9AysjI0LBhw+5q3z179tTnn3+uY8eOqWPHjrft37BhQ5lMJpWUlCgyMvKO9jFgwAAtXLhQp0+fVmpqqlq2bKkOHTrcVd0Aaga3UQO4IxaLRTk5OWrdunWF7WUB5qcTeO12u86cOXPXE3tfe+011atXT2+//XaFtzuXnXEp4+bmpr59++qvf/2rMjIyyvX/8eWjMmVnWxYuXKhTp05x9gWoxTgDA+COlE2UvVWAeeihh/TYY485rb906ZJsNttNv3enWrVqpYULF2rChAl65plnHE/itdvtyszMVEpKiurWres0uXjixIk6cOCAXnzxRQ0dOlTBwcHKzc3VyZMn9Y9//ENfffWV0z5atGihzp07a8eOHZLEw+uAWowAA+COlN2B1KZNmwrbz549qzZt2pR7wN3p06fVqlWrCufNVNazzz6rbdu26fe//7327NmjjRs3qk6dOgoMDFSvXr00fPhwp0tY/v7+2rx5s/77v//b8aqBBg0aqHXr1hW+Z0n64SzMV199pY4dO1b4tGEAtUMd+0/PuwJANVq0aJEuXryoDz/88I76JyYmav/+/UpJSZG7u7vq169fwxVWXmFhoa5fv65PPvlEv/vd73T48GE1bNjQ1WUBDxTmwACoUadPn670/Jd//vOfioiIcNzFVNusX79eERER+t3vfufqUoAHFpeQANSojIwMDR069I77v/baa443Ufv4+NRQVXenb9++TpfSqvvBfQBuj0tIAADAcLiEBAAADIcAAwAADIcAAwAADIcAAwAADIcAAwAADIcAAwAADIcAAwAADIcAAwAADIcAAwAADIcAAwAADIcAAwAADOf/AYpua4ZHPC55AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import utils\n", + "utils.set_style()\n", + "\n", + "histogram_computed[120j::hist.rebin(2), \"4j1b\", :, \"nominal\"].stack(\"process\")[::-1].plot(stack=True, histtype=\"fill\", linewidth=1, edgecolor=\"grey\")\n", + "plt.legend(frameon=False)\n", + "plt.title(\"$\\geq$ 4 jets, 1 b-tag\")\n", + "plt.xlabel(\"$H_T$ [GeV]\");" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "14e2108f-8b39-42c5-9db0-e77f0be3a940", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "histogram_computed[:, \"4j2b\", :, \"nominal\"].stack(\"process\")[::-1].plot(stack=True, histtype=\"fill\", linewidth=1,edgecolor=\"grey\")\n", + "plt.legend(frameon=False)\n", + "plt.title(\"$\\geq$ 4 jets, $\\geq$ 2 b-tags\")\n", + "plt.xlabel(\"$m_{bjj}$ [GeV]\");" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b54f83f7-fb4d-48f7-bb45-ac495df71155", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# b-tagging variations\n", + "histogram_computed[120j::hist.rebin(2), \"4j1b\", \"ttbar\", \"nominal\"].plot(label=\"nominal\", linewidth=2)\n", + "histogram_computed[120j::hist.rebin(2), \"4j1b\", \"ttbar\", \"btag_var_0_up\"].plot(label=\"NP 1\", linewidth=2)\n", + "histogram_computed[120j::hist.rebin(2), \"4j1b\", \"ttbar\", \"btag_var_1_up\"].plot(label=\"NP 2\", linewidth=2)\n", + "histogram_computed[120j::hist.rebin(2), \"4j1b\", \"ttbar\", \"btag_var_2_up\"].plot(label=\"NP 3\", linewidth=2)\n", + "histogram_computed[120j::hist.rebin(2), \"4j1b\", \"ttbar\", \"btag_var_3_up\"].plot(label=\"NP 4\", linewidth=2)\n", + "plt.legend(frameon=False)\n", + "plt.xlabel(\"$H_T$ [GeV]\")\n", + "plt.title(\"b-tagging variations\");" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5c2112e5-4d88-4e4a-ac4b-83bfc80a2c3f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# jet energy scale variations\n", + "histogram_computed[:, \"4j2b\", \"ttbar\", \"nominal\"].plot(label=\"nominal\", linewidth=2)\n", + "histogram_computed[:, \"4j2b\", \"ttbar\", \"pt_scale_up\"].plot(label=\"scale up\", linewidth=2)\n", + "histogram_computed[:, \"4j2b\", \"ttbar\", \"pt_res_up\"].plot(label=\"resolution up\", linewidth=2)\n", + "plt.legend(frameon=False)\n", + "plt.xlabel(\"$m_{bjj}$ [Gev]\")\n", + "plt.title(\"Jet energy variations\");" + ] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,py" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/analyses/cms-open-data-ttbar/ttbar_newcoffea.py b/analyses/cms-open-data-ttbar/ttbar_newcoffea.py new file mode 100644 index 00000000..e9163d14 --- /dev/null +++ b/analyses/cms-open-data-ttbar/ttbar_newcoffea.py @@ -0,0 +1,235 @@ +# --- +# jupyter: +# jupytext: +# formats: ipynb,py +# text_representation: +# extension: .py +# format_name: light +# format_version: '1.5' +# jupytext_version: 1.14.1 +# kernelspec: +# display_name: Python 3 (ipykernel) +# language: python +# name: python3 +# --- + +# + tags=[] +from coffea.analysis_tools import PackedSelection +from coffea.lookup_tools.correctionlib_wrapper import correctionlib_wrapper +from coffea.nanoevents import NanoEventsFactory +import correctionlib +import dask +import dask_awkward as dak +import hist.dask +import numpy as np +import dask +import awkward as ak +import os +import urllib + +# + tags=[] +ttbar_file = "https://xrootd-local.unl.edu:1094//store/user/AGC/nanoAOD/TT_TuneCUETP8M1_13TeV-powheg-pythia8/cmsopendata2015_ttbar_19980_PU25nsData2015v1_76X_mcRun2_asymptotic_v12_ext3-v1_00000_0000.root" + +# download for subsequent use +local_file_name = "ttbar__nominal.root" +if not os.path.exists(local_file_name): + urllib.request.urlretrieve(ttbar_file, filename=local_file_name) + +# + tags=[] +fileset = { + 'ttbar__nominal': { + 'files': ['ttbar__nominal.root'], + 'metadata': {'process': 'ttbar', + 'variation': 'nominal', + 'nevts': 1334428, + 'xsec': 729.84 + } + }, +} + + +# + tags=[] +def rand_gauss(item): + randomstate = np.random.Generator(np.random.PCG64()) + + def getfunction(layout, depth, **kwargs): + if isinstance(layout, ak.contents.NumpyArray): + return ak.contents.NumpyArray(randomstate.normal(loc=1.0, scale=0.05, size=len(layout)).astype(np.float32)) + return None + + out = ak.transform(getfunction, ak.typetracer.length_zero_if_typetracer(item), behavior=item.behavior) + if ak.backend(item) == "typetracer": + out = ak.Array(out.layout.to_typetracer(forget_length=True), behavior=out.behavior) + + assert out is not None + return out + +def jet_pt_resolution(pt): + # normal distribution with 5% variations, shape matches jets + resolution_variation = dak.map_partitions(rand_gauss, pt) + + return resolution_variation + + +# + tags=[] +with dask.config.set({"awkward.compute-unknown-meta": False, + "awkward.optimization.enabled": False}): + + events = NanoEventsFactory.from_root( + {fileset["ttbar__nominal"]["files"][0]: "Events"}, + permit_dask=True, + ).events() + + # initialize histogam + histogram = ( + hist.dask.Hist.new.Reg(25, 50, 550, name="observable", label="observable [GeV]") + .StrCat(["4j1b", "4j2b"], name="region", label="Region") + .StrCat([], name="process", label="Process", growth=True) + .StrCat([], name="variation", label="Systematic variation", growth=True) + .Weight() + ) + + xsec_weight = (396.87 + 332.97) * 3378 / 1191997 + + events["pt_scale_up"] = 1.03 + events["pt_res_up"] = jet_pt_resolution(events.Jet.pt) + syst_variations = ["nominal"] + jet_kinematic_systs = ["pt_scale_up", "pt_res_up"] + event_systs = [f"btag_var_{i}" for i in range(4)] + syst_variations.extend(jet_kinematic_systs) + syst_variations.extend(event_systs) + + cset = correctionlib.CorrectionSet.from_file("corrections.json") + + + for syst_var in syst_variations: + + ### event selection + elecs = events.Electron + muons = events.Muon + jets = events.Jet + evtnum = events.event + if syst_var in jet_kinematic_systs: + jets["pt"] = jets.pt * events[syst_var] + + electron_reqs = ((elecs.pt > 30) & (np.abs(elecs.eta) < 2.1) + & (elecs.cutBased == 4) & (elecs.sip3d < 4)) + muon_reqs = ((muons.pt > 30) & (np.abs(muons.eta) < 2.1) & (muons.tightId) + & (muons.sip3d < 4) &(muons.pfRelIso04_all < 0.15)) + jet_reqs = (jets.pt > 30) & (np.abs(jets.eta) < 2.4) & (jets.isTightLeptonVeto) + + # Only keep objects that pass our requirements + elecs = elecs[electron_reqs] + muons = muons[muon_reqs] + jets = jets[jet_reqs] + + B_TAG_THRESHOLD = 0.5 + + ######### Store boolean masks with PackedSelection ########## + selections = PackedSelection() + # Basic selection criteria + selections.add("exactly_1l", (dak.num(elecs) + dak.num(muons)) == 1) + selections.add("atleast_4j", dak.num(jets) >= 4) + selections.add("exactly_1b", dak.sum(jets.btagCSVV2 >= B_TAG_THRESHOLD, axis=1) == 1) + selections.add("atleast_2b", dak.sum(jets.btagCSVV2 > B_TAG_THRESHOLD, axis=1) >= 2) + # Complex selection criteria + + selections.add("4j1b", selections.all("exactly_1l", "atleast_4j", "exactly_1b")) + selections.add("4j2b", selections.all("exactly_1l", "atleast_4j", "atleast_2b")) + + for region in ["4j1b", "4j2b"]: + + region_selection = selections.all(region) + region_jets = jets[region_selection] + region_elecs = elecs[region_selection] + region_muons = muons[region_selection] + region_evtnum = evtnum[region_selection] + region_weights = dak.full_like(region_evtnum, xsec_weight) + + + if region == "4j1b": + observable = dak.sum(region_jets.pt, axis=-1) + + elif region == "4j2b": + + # reconstruct hadronic top as bjj system with largest pT + trijet = dak.combinations(region_jets, 3, fields=["j1", "j2", "j3"]) # trijet candidates + trijet["p4"] = trijet.j1 + trijet.j2 + trijet.j3 # calculate four-momentum of tri-jet system + trijet["max_btag"] = np.maximum(trijet.j1.btagCSVV2, np.maximum(trijet.j2.btagCSVV2, trijet.j3.btagCSVV2)) + trijet = trijet[trijet.max_btag > B_TAG_THRESHOLD] # at least one-btag in trijet candidates + # pick trijet candidate with largest pT and calculate mass of system + trijet_mass = trijet["p4"][dak.argmax(trijet.p4.pt, axis=1, keepdims=True)].mass + observable = dak.flatten(trijet_mass) + + + syst_var_name = f"{syst_var}" + # Break up the filling into event weight systematics and object variation systematics + if syst_var in event_systs: + + for i_dir, direction in enumerate(["up", "down"]): + # Should be an event weight systematic with an up/down variation + if syst_var.startswith("btag_var"): + i_jet = int(syst_var.rsplit("_",1)[-1]) # Kind of fragile + wrap_c = correctionlib_wrapper(cset["event_systematics"]) + wgt_variation = wrap_c("btag_var", direction, region_jets.pt[:,i_jet]) + # wgt_variation = cset["event_systematics"].evaluate("btag_var", direction, region_jets.pt[:,i_jet]) + elif syst_var == "scale_var": + # The pt array is only used to make sure the output array has the correct shape + wrap_c = correctionlib_wrapper(cset["event_systematics"]) + wgt_variation = wrap_c("scale_var", direction, region_jets.pt[:,0]) + # wgt_variation = cset["event_systematics"].evaluate("scale_var", direction, region_jets.pt[:,0]) + syst_var_name = f"{syst_var}_{direction}" + histogram.fill( + observable=observable, region=region, process="ttbar", + variation=syst_var_name, weight=region_weights * wgt_variation + ) + + else: + # Should either be 'nominal' or an object variation systematic + histogram.fill( + observable=observable, region=region, process="ttbar", + variation=syst_var, weight=region_weights + ) + +# + tags=[] +with dask.config.set({"awkward.optimization.enabled": False, "awkward.compute-unknown-meta": False}): + histogram_computed = histogram.compute() + +# + tags=[] +histogram_computed + +# + +import matplotlib.pyplot as plt +import utils +utils.set_style() + +histogram_computed[120j::hist.rebin(2), "4j1b", :, "nominal"].stack("process")[::-1].plot(stack=True, histtype="fill", linewidth=1, edgecolor="grey") +plt.legend(frameon=False) +plt.title("$\geq$ 4 jets, 1 b-tag") +plt.xlabel("$H_T$ [GeV]"); + +# + tags=[] +histogram_computed[:, "4j2b", :, "nominal"].stack("process")[::-1].plot(stack=True, histtype="fill", linewidth=1,edgecolor="grey") +plt.legend(frameon=False) +plt.title("$\geq$ 4 jets, $\geq$ 2 b-tags") +plt.xlabel("$m_{bjj}$ [GeV]"); + +# + tags=[] +# b-tagging variations +histogram_computed[120j::hist.rebin(2), "4j1b", "ttbar", "nominal"].plot(label="nominal", linewidth=2) +histogram_computed[120j::hist.rebin(2), "4j1b", "ttbar", "btag_var_0_up"].plot(label="NP 1", linewidth=2) +histogram_computed[120j::hist.rebin(2), "4j1b", "ttbar", "btag_var_1_up"].plot(label="NP 2", linewidth=2) +histogram_computed[120j::hist.rebin(2), "4j1b", "ttbar", "btag_var_2_up"].plot(label="NP 3", linewidth=2) +histogram_computed[120j::hist.rebin(2), "4j1b", "ttbar", "btag_var_3_up"].plot(label="NP 4", linewidth=2) +plt.legend(frameon=False) +plt.xlabel("$H_T$ [GeV]") +plt.title("b-tagging variations"); + +# + tags=[] +# jet energy scale variations +histogram_computed[:, "4j2b", "ttbar", "nominal"].plot(label="nominal", linewidth=2) +histogram_computed[:, "4j2b", "ttbar", "pt_scale_up"].plot(label="scale up", linewidth=2) +histogram_computed[:, "4j2b", "ttbar", "pt_res_up"].plot(label="resolution up", linewidth=2) +plt.legend(frameon=False) +plt.xlabel("$m_{bjj}$ [Gev]") +plt.title("Jet energy variations");