From c0b7e781102376dc5c9284b8574b29bc99158f17 Mon Sep 17 00:00:00 2001 From: Alexander Held <45009355+alexander-held@users.noreply.github.com> Date: Wed, 2 Nov 2022 21:14:29 +0100 Subject: [PATCH] feat: benchmarking setup (#85) * switch to merged input files * pass custom schema to ServiceX (requires coffea>=0.7.18) * split coffea pre-processing into separate step * track and save metrics when running coffea * add I/O testing option * add option to scale fraction of files read * add updated data sizes for merged files --- .gitignore | 1 + analyses/cms-open-data-ttbar/coffea.ipynb | 371 ++++++++++++------ .../cms-open-data-ttbar/utils/__init__.py | 14 +- 3 files changed, 254 insertions(+), 132 deletions(-) diff --git a/.gitignore b/.gitignore index 08fcfe29..042beaf1 100644 --- a/.gitignore +++ b/.gitignore @@ -25,6 +25,7 @@ workshops/agctools2022/statistical-inference/input # CMS ttbar analyses/cms-open-data-ttbar/workspace.json +analyses/cms-open-data-ttbar/metrics # dask dask-worker-space/ diff --git a/analyses/cms-open-data-ttbar/coffea.ipynb b/analyses/cms-open-data-ttbar/coffea.ipynb index 8d47a77f..31dbe065 100644 --- a/analyses/cms-open-data-ttbar/coffea.ipynb +++ b/analyses/cms-open-data-ttbar/coffea.ipynb @@ -50,8 +50,9 @@ "outputs": [], "source": [ "import asyncio\n", - "import time\n", "import logging\n", + "import os\n", + "import time\n", "\n", "import vector; vector.register_awkward()\n", "\n", @@ -90,13 +91,16 @@ "\n", "| setting | number of files | total size |\n", "| --- | --- | --- |\n", - "| `10` | 90 | 15.6 GB |\n", - "| `100` | 850 | 150 GB |\n", - "| `500` | 3545| 649 GB |\n", - "| `1000` | 5864 | 1.05 TB |\n", - "| `-1` | 22635 | 3.44 TB |\n", + "| `1` | 9 | 16.3 GB |\n", + "| `5` | 45 | 81.7 GB |\n", + "| `10` | 86 | 157 GB |\n", + "| `50` | 357 | 678 GB |\n", + "| `100` | 590 | 1.09 TB |\n", + "| `500` | 1542 | 2.58 TB |\n", + "| `1000` | 2249 | 3.57 TB |\n", + "| `-1` | 2269 | 3.59 TB |\n", "\n", - "The input files are all in the 100–200 MB range.\n", + "The input files are all in the 1–2 GB range.\n", "\n", "Some files are also rucio-accessible (with ATLAS credentials):\n", "\n", @@ -128,7 +132,7 @@ "### GLOBAL CONFIGURATION\n", "\n", "# input files per process, set to e.g. 10 (smaller number = faster)\n", - "N_FILES_MAX_PER_SAMPLE = 10\n", + "N_FILES_MAX_PER_SAMPLE = 5\n", "\n", "# pipeline to use:\n", "# - \"coffea\" for pure coffea setup\n", @@ -140,10 +144,30 @@ "USE_DASK = True\n", "\n", "# ServiceX behavior: ignore cache with repeated queries\n", - "SERVICEX_IGNORE_CACHE = True\n", + "SERVICEX_IGNORE_CACHE = False\n", "\n", "# analysis facility: set to \"coffea_casa\" for coffea-casa environments, \"EAF\" for FNAL, \"local\" for local setups\n", - "AF = \"coffea_casa\"" + "AF = \"coffea_casa\"\n", + "\n", + "### BENCHMARKING-SPECIFIC SETTINGS\n", + "\n", + "# chunk size to use\n", + "CHUNKSIZE = 500_000\n", + "\n", + "# metadata to propagate through to metrics\n", + "AF_NAME = \"coffea_casa\" # \"ssl-dev\" allows for the switch to local data on /data\n", + "SYSTEMATICS = \"all\" # currently has no effect\n", + "CORES_PER_WORKER = 2 # does not do anything, only used for metric gathering (set to 2 for distributed coffea-casa)\n", + "\n", + "# scaling for local setups with FuturesExecutor\n", + "NUM_CORES = 4\n", + "\n", + "# only I/O, all other processing disabled\n", + "DISABLE_PROCESSING = False\n", + "\n", + "# read additional branches (only with DISABLE_PROCESSING = True)\n", + "# acceptable values are 4, 15, 25, 50 (corresponding to % of file read), 4% corresponds to the standard branches used in the notebook\n", + "IO_FILE_PERCENT = 4" ] }, { @@ -191,7 +215,7 @@ "\n", "\n", "class TtbarAnalysis(processor_base):\n", - " def __init__(self):\n", + " def __init__(self, disable_processing, io_file_percent):\n", " num_bins = 25\n", " bin_low = 50\n", " bin_high = 550\n", @@ -204,8 +228,36 @@ " .StrCat([], name=\"variation\", label=\"Systematic variation\", growth=True)\n", " .Weight()\n", " )\n", + " self.disable_processing = disable_processing\n", + " self.io_file_percent = io_file_percent\n", + "\n", + " def only_do_IO(self, events):\n", + " # standard AGC branches cover 4% of the data\n", + " branches_to_read = [\"jet_pt\", \"jet_eta\", \"jet_phi\", \"jet_btag\", \"jet_e\", \"muon_pt\", \"electron_pt\"]\n", + " if self.io_file_percent not in [4, 15, 25, 50]:\n", + " raise NotImplementedError(\"supported values for I/O percentage are 4, 15, 25, 50\")\n", + " if self.io_file_percent >= 15:\n", + " branches_to_read += [\"trigobj_e\"]\n", + " if self.io_file_percent >= 25:\n", + " branches_to_read += [\"trigobj_pt\"]\n", + " if self.io_file_percent >= 50:\n", + " branches_to_read += [\"trigobj_eta\", \"trigobj_phi\", \"jet_px\", \"jet_py\", \"jet_pz\", \"jet_ch\"]\n", + "\n", + " for branch in branches_to_read:\n", + " if \"_\" in branch:\n", + " object_type, property_name = branch.split(\"_\")\n", + " if property_name == \"e\":\n", + " property_name = \"energy\"\n", + " ak.materialized(events[object_type][property_name])\n", + " else:\n", + " ak.materialized(events[branch])\n", + " return {\"hist\": {}}\n", "\n", " def process(self, events):\n", + " if self.disable_processing:\n", + " # IO testing with no subsequent processing\n", + " return self.only_do_IO(events)\n", + "\n", " histogram = self.hist.copy()\n", "\n", " process = events.metadata[\"process\"] # \"ttbar\" etc.\n", @@ -266,33 +318,23 @@ " region_filter = ak.sum(selected_jets.btag >= B_TAG_THRESHOLD, axis=1) == 1\n", " selected_jets_region = selected_jets[region_filter]\n", " # use HT (scalar sum of jet pT) as observable\n", - " pt_var_modifier = events[event_filters][region_filter][pt_var] if \"res\" not in pt_var else events[pt_var][jet_filter][event_filters][region_filter]\n", + " pt_var_modifier = (\n", + " events[event_filters][region_filter][pt_var]\n", + " if \"res\" not in pt_var\n", + " else events[pt_var][jet_filter][event_filters][region_filter]\n", + " )\n", " observable = ak.sum(selected_jets_region.pt * pt_var_modifier, axis=-1)\n", "\n", " elif region == \"4j2b\":\n", " region_filter = ak.sum(selected_jets.btag > B_TAG_THRESHOLD, axis=1) >= 2\n", " selected_jets_region = selected_jets[region_filter]\n", "\n", - " if PIPELINE == \"servicex_processor\":\n", - " import vector\n", - "\n", - " vector.register_awkward()\n", - "\n", - " # wrap into a four-vector object to allow addition\n", - " selected_jets_region = ak.zip(\n", - " {\n", - " \"pt\": selected_jets_region.pt, \"eta\": selected_jets_region.eta, \"phi\": selected_jets_region.phi,\n", - " \"mass\": selected_jets_region.mass, \"btag\": selected_jets_region.btag,\n", - " },\n", - " with_name=\"Momentum4D\",\n", - " )\n", - "\n", " # reconstruct hadronic top as bjj system with largest pT\n", " # the jet energy scale / resolution effect is not propagated to this observable at the moment\n", " trijet = ak.combinations(selected_jets_region, 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.btag, np.maximum(trijet.j2.btag, trijet.j3.btag))\n", - " trijet = trijet[trijet.max_btag > B_TAG_THRESHOLD] # require at least one-btag in trijet candidates\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\"][ak.argmax(trijet.p4.pt, axis=1, keepdims=True)].mass\n", " observable = ak.flatten(trijet_mass)\n", @@ -301,7 +343,8 @@ " if pt_var == \"pt_nominal\":\n", " # nominal pT, but including 2-point systematics\n", " histogram.fill(\n", - " observable=observable, region=region, process=process, variation=variation, weight=xsec_weight\n", + " observable=observable, region=region, process=process,\n", + " variation=variation, weight=xsec_weight\n", " )\n", "\n", " if variation == \"nominal\":\n", @@ -309,10 +352,12 @@ " for weight_name in events.systematics.fields:\n", " for direction in [\"up\", \"down\"]:\n", " # extract the weight variations and apply all event & region filters\n", - " weight_variation = events.systematics[weight_name][direction][f\"weight_{weight_name}\"][event_filters][region_filter]\n", + " weight_variation = events.systematics[weight_name][direction][\n", + " f\"weight_{weight_name}\"][event_filters][region_filter]\n", " # fill histograms\n", " histogram.fill(\n", - " observable=observable, region=region, process=process, variation=f\"{weight_name}_{direction}\", weight=xsec_weight*weight_variation\n", + " observable=observable, region=region, process=process,\n", + " variation=f\"{weight_name}_{direction}\", weight=xsec_weight*weight_variation\n", " )\n", "\n", " # calculate additional systematics: b-tagging variations\n", @@ -324,13 +369,15 @@ " else:\n", " weight_variation = 1 # no events selected\n", " histogram.fill(\n", - " observable=observable, region=region, process=process, variation=f\"{weight_name}_{direction}\", weight=xsec_weight*weight_variation\n", + " observable=observable, region=region, process=process,\n", + " variation=f\"{weight_name}_{direction}\", weight=xsec_weight*weight_variation\n", " )\n", "\n", " elif variation == \"nominal\":\n", " # pT variations for nominal samples\n", " histogram.fill(\n", - " observable=observable, region=region, process=process, variation=pt_var, weight=xsec_weight\n", + " observable=observable, region=region, process=process,\n", + " variation=pt_var, weight=xsec_weight\n", " )\n", "\n", " output = {\"nevents\": {events.metadata[\"dataset\"]: len(events)}, \"hist\": histogram}\n", @@ -381,9 +428,9 @@ " output[name] = zip_forms(content, name, 'PtEtaPhiELorentzVector', offsets=offsets)\n", "\n", " # Handle GenPart, PV, MET. Note that all the nPV_*'s should be the same. We just use one.\n", - " output['met'] = zip_forms({k[len('met')+1:]: branch_forms[k] for k in branch_forms if k.startswith('met_')}, 'met')\n", + " #output['met'] = zip_forms({k[len('met')+1:]: branch_forms[k] for k in branch_forms if k.startswith('met_')}, 'met')\n", " #output['GenPart'] = zip_forms({k[len('GenPart')+1:]: branch_forms[k] for k in branch_forms if k.startswith('GenPart_')}, 'GenPart', offsets=transforms.counts2offsets_form(branch_forms['numGenPart']))\n", - " output['PV'] = zip_forms({k[len('PV')+1:]: branch_forms[k] for k in branch_forms if (k.startswith('PV_') & ('npvs' not in k))}, 'PV', offsets=transforms.counts2offsets_form(branch_forms['nPV_x']))\n", + " #output['PV'] = zip_forms({k[len('PV')+1:]: branch_forms[k] for k in branch_forms if (k.startswith('PV_') & ('npvs' not in k))}, 'PV', offsets=transforms.counts2offsets_form(branch_forms['nPV_x']))\n", " return output\n", "\n", " @property\n", @@ -420,14 +467,14 @@ "\n", "example of information in fileset:\n", "{\n", - " 'files': [https://xrootd-local.unl.edu:1094//store/user/AGC/datasets/RunIIFall15MiniAODv2/TT_TuneCUETP8M1_13TeV-powheg-pythia8/MINIAODSIM//PU25nsData2015v1_76X_mcRun2_asymptotic_v12_ext3-v1/00000/00DF0A73-17C2-E511-B086-E41D2D08DE30.root, ...],\n", - " 'metadata': {'process': 'ttbar', 'variation': 'nominal', 'nevts': 442122, 'xsec': 729.84}\n", + " 'files': [https://xrootd-local.unl.edu:1094//store/user/AGC/datasets/merged/TT_TuneCUETP8M1_13TeV-powheg-pythia8/1.root, ...],\n", + " 'metadata': {'process': 'ttbar', 'variation': 'nominal', 'nevts': 2229374, 'xsec': 729.84}\n", "}\n" ] } ], "source": [ - "fileset = utils.construct_fileset(N_FILES_MAX_PER_SAMPLE, use_xcache=False)\n", + "fileset = utils.construct_fileset(N_FILES_MAX_PER_SAMPLE, use_xcache=False, af_name=AF_NAME) # local files on /data for ssl-dev\n", "\n", "print(f\"processes in fileset: {list(fileset.keys())}\")\n", "print(f\"\\nexample of information in fileset:\\n{{\\n 'files': [{fileset['ttbar__nominal']['files'][0]}, ...],\")\n", @@ -454,18 +501,37 @@ "outputs": [], "source": [ "def get_query(source: ObjectStream) -> ObjectStream:\n", - " \"\"\"Query for event / column selection: no filter, select relevant lepton and jet columns\n", + " \"\"\"Query for event / column selection: >=4j >=1b, ==1 lep with pT>25 GeV, return relevant columns\n", " \"\"\"\n", - " return source.Select(lambda e: {\n", - " \"electron_pt\": e.electron_pt,\n", - " \"muon_pt\": e.muon_pt,\n", - " \"jet_pt\": e.jet_pt,\n", - " \"jet_eta\": e.jet_eta,\n", - " \"jet_phi\": e.jet_phi,\n", - " \"jet_mass\": e.jet_mass,\n", - " \"jet_btag\": e.jet_btag,\n", - " }\n", - " )" + " return source.Where(lambda e:\n", + " # == 1 lep\n", + " e.electron_pt.Where(lambda pT: pT > 25).Count() + e.muon_pt.Where(lambda pT: pT > 25).Count()== 1\n", + " )\\\n", + " .Where(lambda e:\\\n", + " # >= 4 jets\n", + " e.jet_pt.Where(lambda pT: pT > 25).Count() >= 4\n", + " )\\\n", + " .Where(lambda e:\\\n", + " # >= 1 jet with pT > 25 GeV and b-tag >= 0.5\n", + " {\"pT\": e.jet_pt, \"btag\": e.jet_btag}.Zip().Where(lambda jet: jet.btag >= 0.5 and jet.pT > 25).Count() >= 1\n", + " )\\\n", + " .Select(lambda e:\\\n", + " # return columns\n", + " {\n", + " \"electron_e\": e.electron_e,\n", + " \"electron_pt\": e.electron_pt,\n", + " \"muon_e\": e.muon_e,\n", + " \"muon_pt\": e.muon_pt,\n", + " \"jet_e\": e.jet_e,\n", + " \"jet_pt\": e.jet_pt,\n", + " \"jet_eta\": e.jet_eta,\n", + " \"jet_phi\": e.jet_phi,\n", + " \"jet_btag\": e.jet_btag,\n", + " \"numbermuon\": e.numbermuon,\n", + " \"numberelectron\": e.numberelectron,\n", + " \"numberjet\": e.numberjet,\n", + " }\n", + " )" ] }, { @@ -492,17 +558,10 @@ " from servicex_databinder import DataBinder\n", " t0 = time.time()\n", "\n", - " # query for events with at least 4 jets with 25 GeV, at least one b-tag, and exactly one electron or muon with pT > 25 GeV\n", - " # returning columns required for subsequent processing\n", - " query_string = \"\"\"Where(\n", - " lambda event: event.electron_pt.Where(lambda pT: pT > 25).Count() + event.muon_pt.Where(lambda pT: pT > 25).Count() == 1\n", - " ).Where(lambda event: event.jet_pt.Where(lambda pT: pT > 25).Count() >= 4\n", - " ).Where(lambda event: event.jet_btag.Where(lambda btag: btag > 0.5).Count() >= 1\n", - " ).Select(\n", - " lambda e: {\"electron_pt\": e.electron_pt, \"muon_pt\": e.muon_pt,\n", - " \"jet_pt\": e.jet_pt, \"jet_eta\": e.jet_eta, \"jet_phi\": e.jet_phi, \"jet_mass\": e.jet_mass, \"jet_btag\": e.jet_btag}\n", - " )\"\"\"\n", - "\n", + " import inspect\n", + " \n", + " query_string = inspect.getsource(get_query).split(\"return source.\")[-1] # extract query from function defined previously\n", + " \n", " sample_names = [\"ttbar__nominal\", \"ttbar__scaledown\", \"ttbar__scaleup\", \"ttbar__ME_var\", \"ttbar__PS_var\",\n", " \"single_top_s_chan__nominal\", \"single_top_t_chan__nominal\", \"single_top_tW__nominal\", \"wjets__nominal\"]\n", " sample_names = [\"single_top_s_chan__nominal\"] # for quick tests: small dataset with only 50 files\n", @@ -523,13 +582,21 @@ " }\n", "\n", " sx_db = DataBinder(databinder_config)\n", - " out = sx_db.deliver()\n", + " # out = sx_db.deliver(timer=True)\n", + " parquet_paths = sx_db._sx.get_servicex_data() # only run transform, do not download as well\n", " print(f\"execution took {time.time() - t0:.2f} seconds\")\n", - "\n", + " \n", + " # point to ROOT files from databinder\n", " # update list of fileset files, pointing to ServiceX output for subsequent processing\n", " # for process in fileset.keys():\n", " # if out.get(process):\n", - " # fileset[process][\"files\"] = out[process]" + " # fileset[process][\"files\"] = out[process]\n", + " \n", + " # point directly to parquet files from databinder\n", + " # update paths to point to ServiceX outputs\n", + " for sample_name, sample_paths in zip([sample['Name'] for sample in databinder_config['Sample']], parquet_paths):\n", + " print(f\"updating paths for {sample_name} with {len(sample_paths)} parquet files (e.g. {sample_paths[0]}\")\n", + " fileset[sample_name][\"files\"] = sample_paths" ] }, { @@ -555,42 +622,85 @@ "name": "stdout", "output_type": "stream", "text": [ - "[########################################] | 100% Completed | 1min 0.1s\n", - "execution took 74.81 seconds\n" + "[########################################] | 100% Completed | 1min 16.3s\n", + "execution took 76.32 seconds\n" ] } ], "source": [ - "t0 = time.time()\n", - "\n", "if PIPELINE == \"coffea\":\n", " if USE_DASK:\n", " executor = processor.DaskExecutor(client=utils.get_client(AF))\n", " else:\n", - " executor = processor.IterativeExecutor()\n", + " executor = processor.FuturesExecutor(workers=NUM_CORES)\n", + "\n", + " run = processor.Runner(executor=executor, schema=AGCSchema, savemetrics=True, metadata_cache={}, chunksize=CHUNKSIZE)\n", "\n", - " from coffea.nanoevents.schemas.schema import auto_schema\n", - " schema = AGCSchema if PIPELINE == \"coffea\" else auto_schema\n", - " run = processor.Runner(executor=executor, schema=schema, savemetrics=True, metadata_cache={})\n", + " filemeta = run.preprocess(fileset, treename=\"events\") # pre-processing\n", "\n", - " all_histograms, metrics = run(fileset, \"events\", processor_instance=TtbarAnalysis())\n", + " t0 = time.monotonic()\n", + " all_histograms, metrics = run(fileset, \"events\", processor_instance=TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT)) # processing\n", + " exec_time = time.monotonic() - t0\n", " all_histograms = all_histograms[\"hist\"]\n", "\n", "elif PIPELINE == \"servicex_processor\":\n", " # in a notebook:\n", - " all_histograms = await utils.produce_all_histograms(fileset, get_query, TtbarAnalysis, use_dask=USE_DASK, ignore_cache=SERVICEX_IGNORE_CACHE)\n", + " t0 = time.monotonic()\n", + " all_histograms = await utils.produce_all_histograms(fileset, get_query, TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT),\n", + " use_dask=USE_DASK, ignore_cache=SERVICEX_IGNORE_CACHE, schema=AGCSchema)\n", + " exec_time = time.monotonic() - t0\n", "\n", " # as a script:\n", " # async def produce_all_the_histograms():\n", - " # return await utils.produce_all_histograms(fileset, get_query, TtbarAnalysis, use_dask=USE_DASK, ignore_cache=SERVICEX_IGNORE_CACHE)\n", + " # return await utils.produce_all_histograms(fileset, get_query, TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT),\n", + " # use_dask=USE_DASK, ignore_cache=SERVICEX_IGNORE_CACHE, schema=AGCSchema)\n", " #\n", " # all_histograms = asyncio.run(produce_all_the_histograms())\n", "\n", "elif PIPELINE == \"servicex_databinder\":\n", " # needs a slightly different schema, not currently implemented\n", " raise NotImplementedError(\"further processing of this method is not currently implemented\")\n", - " \n", - "print(f\"\\nexecution took {time.time() - t0:.2f} seconds\")" + "\n", + "print(f\"\\nexecution took {exec_time:.2f} seconds\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "55fb8ec1-6eb9-41b8-8275-e341a17b5fb2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "metrics saved as metrics/coffea_casa-20221102-200834.json\n", + "event rate per worker (pure processtime): 63.08 kHz\n", + "amount of data read: 3408.86 MB\n" + ] + } + ], + "source": [ + "# track metrics for pure coffea setups\n", + "if PIPELINE == \"coffea\":\n", + " # update metrics\n", + " dataset_source = \"/data\" if fileset[\"ttbar__nominal\"][\"files\"][0].startswith(\"/data\") else \"https://xrootd-local.unl.edu:1094\" # TODO: xcache support\n", + " metrics.update({\"walltime\": exec_time, \"num_workers\": NUM_CORES, \"af\": AF_NAME, \"dataset_source\": dataset_source, \"use_dask\": USE_DASK,\n", + " \"systematics\": SYSTEMATICS, \"n_files_max_per_sample\": N_FILES_MAX_PER_SAMPLE, \"pipeline\": PIPELINE,\n", + " \"cores_per_worker\": CORES_PER_WORKER, \"chunksize\": CHUNKSIZE, \"disable_processing\": DISABLE_PROCESSING, \"io_file_percent\": IO_FILE_PERCENT})\n", + "\n", + " # save metrics to disk\n", + " if not os.path.exists(\"metrics\"):\n", + " os.makedirs(\"metrics\")\n", + " timestamp = time.strftime('%Y%m%d-%H%M%S')\n", + " metric_file_name = f\"metrics/{AF_NAME}-{timestamp}.json\"\n", + " with open(metric_file_name, \"w\") as f:\n", + " f.write(json.dumps(metrics))\n", + "\n", + " print(f\"metrics saved as {metric_file_name}\")\n", + " #print(f\"event rate per worker (full execution time divided by NUM_CORES={NUM_CORES}): {metrics['entries'] / NUM_CORES / exec_time / 1_000:.2f} kHz\")\n", + " print(f\"event rate per worker (pure processtime): {metrics['entries'] / metrics['processtime'] / 1_000:.2f} kHz\")\n", + " print(f\"amount of data read: {metrics['bytesread']/1000**2:.2f} MB\") # likely buggy: https://github.com/CoffeaTeam/coffea/issues/717" ] }, { @@ -606,20 +716,18 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "9f17abd8-74ed-40db-9ea8-73341c8bf627", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -634,20 +742,18 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "318654e9-444c-401b-8957-4477d4c103f1", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -674,20 +780,18 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "7843e5c0-e247-4abf-b406-263c92f797b6", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -705,20 +809,18 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "87773be6-cabe-48a9-a9ba-7d2e33fb1b01", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -745,7 +847,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "804ef793", "metadata": {}, "outputs": [], @@ -766,10 +868,19 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "486ad228", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/lib/python3.8/site-packages/requests/__init__.py:102: RequestsDependencyWarning: urllib3 (1.26.7) or chardet (5.0.0)/charset_normalizer (2.0.9) doesn't match a supported version!\n", + " warnings.warn(\"urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported \"\n" + ] + } + ], "source": [ "config = cabinetry.configuration.load(\"cabinetry_config.yml\")\n", "cabinetry.templates.collect(config)\n", @@ -788,7 +899,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "03559e2c-b8f3-4660-b23c-b7ab30545fd1", "metadata": {}, "outputs": [ @@ -796,6 +907,8 @@ "name": "stdout", "output_type": "stream", "text": [ + "/opt/conda/lib/python3.8/site-packages/requests/__init__.py:102: RequestsDependencyWarning: urllib3 (1.26.7) or chardet (5.0.0)/charset_normalizer (2.0.9) doesn't match a supported version!\n", + " warnings.warn(\"urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported \"\n", " Summary \n", " ------------------ \n", " channels 2\n", @@ -833,7 +946,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "ef0b4da0-79e2-47a1-8da3-3e2c3bf7947b", "metadata": {}, "outputs": [ @@ -841,17 +954,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "W MnPosDef Matrix forced pos-def by adding to diagonal 0.0088349\n" + "W MnPosDef Matrix forced pos-def by adding to diagonal 0.00929875\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -875,7 +988,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "280d3998-b3e1-4f0d-b44c-3e7fa84558eb", "metadata": {}, "outputs": [ @@ -884,7 +997,7 @@ "output_type": "stream", "text": [ "\n", - "fit result for ttbar_norm: 1.020 +/- 0.014\n" + "fit result for ttbar_norm: 1.019 +/- 0.014\n" ] } ], @@ -904,18 +1017,18 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "8cf47522-414f-41f0-b3c2-2fed390469ce", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -928,18 +1041,18 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "id": "926c416a-e8b7-40b3-8471-9de91d217744", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "execution_count": 19, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -958,18 +1071,18 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "id": "5bcce96d-32f3-4cb1-9dd0-81ebe63275ed", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "execution_count": 20, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -982,18 +1095,18 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "id": "3522f45b-d8b8-4bc8-8ee7-91e6a849b06d", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAGoCAYAAAATsnHAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABREklEQVR4nO3de5yc4/3/8dcSkpDEKUEFif1UBK2oUrRVVFX0W3UIbZxTtRqkfkRLKImEElpS50Pq2EZarB7UqbQIpXzTkvoGGz4RpzgkxCGRo8zvj+ua5M5kdndmd2bu2Z338/HYR2bv6z5c1+5mPnPd13Vfn7pMJoOIiEi1WSPtCoiIiOSjACUiIlVJAUpERKqSApSIiFQlBSgREalKXdKuQEdlZpr+KCJSIu5et9rGTCajrzZ81dfXZ9px7A3tvHabj2/vtffbb78Ftdbu9rQ57d+X2l3ZdnfUv/EqaHcm33bd4kvHPSke395rt4faXdljS3F8WtfuqO3W33gptSfq1fJXe3pQHfmrvZ+qO+JXLbZZ7U6/HrXUbvWgpCSGDBkyJ+06VFotthnU7lpTje2uy2Q01t8WZpbJO6jX+U0Fdk67EhVWi20GtbvWpNbu5t5PNYuvHczsBuAed0/z3q+ISIdkZgcABzRXrgDVDu5+Qtp1EBHpqOKH+3vMrCFfucagRESkKilAiYhIVarYLT4zGwEMA74ITHb3YXH7kcD1iV3XALoDO7v7v83sPODnwOLEPju4+8x4fH/gZmBX4HVghLs/nLjuEcBFQG/gIeA4d/8glnUFrgUOBT4FLnH3y0rZbhERaZtK9qBmAxcANyU3uvskd++R/QJOAmYC/0ns9ofkPtngFE0GngU2IgSyu8ysD4CZbU8IfkcDmxCC0DWJY88Dtgb6AXsDZ5jZ4FI1WERE2q5iAcrd73b3PwHvt7LrscBt7t7q/HczGwDsBIxx94Xu3gg8DwyJuxxJmGU3xd3nA+cCh5hZz1h+DHC+u89z9xeBiYReXkWZ2R5m1lTgvnuZ2ZvlrpNIpZnZMDN7Iu16SPWoqll8ZtYP+AZwXE7RAWb2AfA2cJW7Xxu3bw/MdPdPEvtOi9uz5U9mC9zdzWwJMMDMZgKbxf2Txx5UoubkZWZbE4LoXe5+VKzX48A2sbwroZf3LWBD4BXgbHe/v43X2x6YAOwC1AEOnOvu95nZXsA/CD3LDKGXO97db25zA6WqfPTWPu190LHF49fr+/eCnwU0s1nA8e7+cLw1/yqwlrsva1cNpdOqqgBF6NE87u6vJrbdAdwAvEsYZ2o0sw/dfTLQA/go5xwfAX3j6+bKe8YycsqzZQUZPHjwguzrIUOGzGloaJjb2jE77bTT1kuWLFm66aab7k94MG4V06ZNW+Pyyy/f9PDDD5/br1+/Offdd996Z5111l9nzpw5vb6+fsnEiRN7jho1auN8x+az6aabfnHIkCHvnXzyyTMBnnnmmXUymcxlwLh4rmXPPPPMS8uXL+f+++9f79RTT73pxRdfHLntttsubuaU2xZ67U6kFttcqIJ/LhtvvPHnxo0bdzXwyUMPPbT2vvvuy0svvfSvbPno0aM3amxs7F3MOZuzdOlS1lprrbYeXqu/74q2e+LEib0bGxv7tLRPxVeSMLMLgM2zkyRyyl4GLmzpE7yZjQJ2cfchZnYw8At33y5RfiWAu//EzP4M/NPdL0mUfwLsRRjn+gDYxN3fi2VDgPPc/YsFtKPolSTMbChwCPAC8PlsDyr2ZH7n7ps3c9x/gbHu3pjdl9DLGgnMB37u7pPyHNcbmANs4O4f5ilf7bpm9h5wsrvf2UwzavEp+w7b5hL0oFpUaA/KzH5LuOW+GPiMlZOhsh/y9iXcRWggjD8fQ7hjcrK7/z2e44fAGcDmhL/ri939+li2F+H/xZXAacBD7n50G5vVYX/f7VR1K0lUzTRzM/sa4ZbbXa3smiHcqgKYDtQnxpQABsXt2fJBiWvUA12BGe4+j/AfYFAzx5aUmfUCxgGnF3ncJsCAnHptSpiV2JcwZneDmW2T5/D3CbcIf2dmB8VzNXedNczse/G8rxRTR5HWxGDxOnBAnAyV/VC5fpz49FT8flfCh8fewBjgbjPbMJa9B3wX6AX8EJhgZjslLrMp4bZ4P0AP0XcClZxm3iVeb01gTTPrBixL3H8+FmjMGU/CzA4EpgAfEsZRTgHOBnD3GWb2HDDGzM4B9gd2YOUkiUnAU2a2B+FT2Tjg7sQ1bgPOMbOphFl+DYQ//HI4H7jR3d8ws4IOMLO1CG241d1fyik+190XA4+Z2b3A9+M1VnD3jJntDYwCLgW2ioPQP3L3l+Num5nZh4RPs12Ake7+bJtaKNJ+7wG/jpOk/mBmpwP/A/zW3e9N7PeYmf0NyP7fBlhOmDDV3O1p6WAq2YM6B1hIeLM8Kr4+ByAGq+8Dt+Y5bijhE/0nhIBysbvfmlO+MzAPGA8c6u5zANx9OjCc8Cb/HmF86aTEsWMIkwZeAx4DfunuD5Sgraswsx0Jkx4mFHHMGsBvgSXAiJziee6+IPH9a4Te52rc/U13H+HuRvhkuYDwc8ya7e7rEz6VXgF8s9A6ipTBWzkzeFf8bZvZ/mb2LzP7IH6o+g6hp5U1x90XVa6qUm4V60G5+3mE547ylS0C1m+m7PBWzjuLMKbUXPntwO3NlC0mzBjMnTVYansB/YHXY++pB6EXuZ2775S7s5nVATcSenXfcfelObtsYGbrJoLUlsD/tVaJ2Hu7mvDsWG7ZYjM7E2gys4PiIwEipZRp5nVSXzOrSwSpLYG/xNmtjYSxqT+7+1Iz+xMrb/e3dE7poKptFl9ndQPw+8T3PyUErBOb2f9awoyab7n7wmb2GWtmZxPu2X+X0BtchZltAJxK6InNJNyfPw74V+6+AO6+xMwuBUYDf2qpQSJt8C5QH1/PIdySqwdmJPbZGDjFzK4hPPKxLXAfsDZh/HgOsMzM9ge+TQEfzKTjUoBqh0LTbbj7p4RnjbLHzQcWZW9F5pyzH/BjwmyndxLjVT9OzNR7h3BLc3Y87/A8Y1QQbg/2Bx4m3AqZDzwC/KSF6t4EnGdmByiNSMdXzHNKeZR6VtdFwJVmdglhVZlfAP+MY63ZFVyeJqzuMpcQ0A519/cBzOwUwmMnXQkpxv9SwrpJClpLt6GEhW1UyoSFZvZN4DfuXt/qzumrxSm4tdhmULtrjaaZS15fIDxVLyIikW7xpczMLge+R5hmLyIikQJUytz9/wH/L+16iIhUG93iExGRqqQAJSIiVUkBSkREqpLGoNqh0OegRERkda09B6UA1Q7uXtUrJsclk24iPJH/MmEl9d+4e76Vz0VEKip+uL/HzBrylStAdVBmdgvwpruf08JuXyfk2dk8sW7fiuCUzHBarnqKiLSVAlTn1g+YlbPyudSQf5/9+7KmfP/yhUPbmvL9QeDv2WSiZtYXeBM4M8+2z7n7O22sv3RgClAVEv9zXg8cDXyOsBjrie6+KHZvzyQs5voEYW292fEW3WWETKRdCakHjgC+GrdlzOxU4BF3PyDnej8CrgbWimv/XUpYh+937r55zHC6JaF7/RkwLpl5WKTMpgB7Atm/uW8AL+XZ9rKCU+3SLL7KOhLYDzBCltxz4jp8FxHyYX2OEISyK59/m/CfdAAhHckPgPfd/QZCjqtLYjbS1QYZ3f1GQi6sp+I+Y3LKV8lwquAk5ZTzgWg+4cPx12LeMwiJB38N7JyzbUql6yrVQwGqsq5y9zfc/QPCSs6HE4LWTe7+n5if6ixgdzPrDywlJFkcCNS5+4vu/nZKdRdpszwp38cT7goMirt8A3iIkJw0uU0BqoYpQLWDmd0Qp0kW6o3E62ym0M3iawDcfT7wPtDX3f8BXEW4VfduvF6vZupypJnNj1/3F9sWkUqKH8aeBr5hZhsC67v7TODxxLbtCJmupZMyswPi4zp5aQyqHdowzXyLxOstCfmcZhMmMwBgZusCGwFvxWtcAVxhZhsTcuH8DDiXnMHrmCtqEsVRrhVJ0xRCL2kWYeyV+O8P47Y33P21vEdKp6Bp5tXlZDP7KyHJ4NnAH4C/A783s9uBF4ELgafdfZaZ7ULo5f4HWAAsAj6L50pmJ22rUpxDpFC5H4imEMZJZxF6TgD/BH4Tt+n2Xo3TLb7Kuh34GyH9+kzgAnf/O6FH1Ai8TZhAMTTu3wuYSMie+xrh1t+vYtmNwHZm9qGZ/amN9bmIMFHjQzP7aRvPIVKo3A9ETxIm/xxFDFDuPo+Q1v0oFKBqnjLqtlGxGXU70UOxtZhttBbbDCVut5kdCFxJ+OB1gbv/ysyeArYFNnT35XG/a4ATgYHu3lSq6xdBv+8Ka+79VLf4RKQi3P3PwJ9ztu2eZ7+TgJMqVS+pXrrFJyIiVUk9qApx9/5p10FEpCNRgGoHpdsQEWk7pdsoo2pPtyEiUs1aew5KY1AiIlKVFKBERKQqVewWn5mNAIYBXwQmu/uwuL0/8CphpYSsi939/FheR1hY8vhYdiMhZ0wmcfzNwK6ExShHJJ81MrMjCA+k9iYsRnlcXKwVM+sKXAscSljd4RJ3v6y0LRcRkbaoZA9qNnABIQV5PuvHtA89ssEpOoGQsnwQsAPwXeDHifLJwLOE9et+DtxlZn0AzGx7VuZg2oQQhK5JHHsesDVhLby9gTPMbHDbmygiIqVSsQDl7ne7+58Iy/UU41jgUnd/093fIiTeGwZgZgOAnYAx7r7Q3RuB54Eh8dgjCbPspsRVws8FDjGznrH8GOB8d5/n7i8SlhUa1tY2ikjxzOxsM/tNic41y8y+VYpzVSszG2ZmT7S+Z2WZ2S1mdkEpz1lNs/heM7MM4Tbcz9x9bty+PTAtsd+0uC1bNtPdP2mh/Mlsgbu7mS0BBpjZTEKqi9xzH1Sa5oik74Vj68qa8n27WzMFL/fVHHe/sL3naC8z24uYbbpC18sAW7v7K5W4XkdVDQFqLrAL8BzhNt3VhLQR+8XyHsBHif0/AnrEsancsmx532aOzZb3jGWw+rl7UqDBgwevGDcbMmTInIaGhrkt7d9JbEtYs6uW1GKbC1VVP5eNN974c+PGjbsa+KTVnRMmTpzYc9SoURsT2lOR3/f999//R2BxsceNHj16o8bGxt6Uvo7tavd+++3Xf5NNNlkCFDRMMnHixN6NjY19Wton9QAVb71lfyjvxskUb5tZL3f/GJhPWFwyqxcw390zMXV0bgK/Xqz842ypfH7i+0V5jm3VAw88sG6h+3YitbiQZkduc7lXgy7452JmZwKnEP6fzQZOcve/m9l5wOfd/ajEpKlhwPnAOsAEd/9FPEd34Drge8A7hAlSp2R7Pu+9996s4cOHn+zuD8fU8WcADYRV0/8ODM9OkkrUa13CB+UuZjawW7du3RYtWvQ9wnDExcD34653ECZoLc72uAhj2iMJ7yc/j3nZWvs5TAHYf//96wm/nx+5+x/y7LcFcDmwB2E4ZrK7jxg3btww4Hgz+xfwI+DD+LO8Px73w9juzQkrw1/s7tfHsmy9JwBnEtL3nO3uNwNTzez/CBPW+hNydb0AHOHuHo8fSFjw98vx3Oe6+x0ADz744C3Am2PGjDmntZ8BQENDAw0NDdm25v07rcZp5tmKZm8dTGdlCmji6+mJsvrEmFK+8hXHmlk9Ic30jLis/9stnFtESsTMtgFGALu4e0/CHZJZLRzydWAbYB9gtJltG7ePIbx51gP7EtJyNOcUwi37PQm38+cR7tCswt0XAPsDs929x/Tp059199mESVe7ATsS3hu+AiTffDclzA7uSxgrvyG2s0Xu/o34clCcFJYvOK0J/JWQZqd/vMbvE7vsCjTF618C3BjvKgG8R5hM1ouQ/HGCme2UU+/14jl/BFxtZhskyg8HxgIbAK8A2Q8H6xKGYG4HNo77XRMno5VFJaeZd4nXWxNY08y6AcsIkfhD4GXCD+QK4FF3z956uw0YaWb3EYLX6YQIjrvPMLPngDFmdg7hj2wHVk6SmAQ8ZWZ7EJL+jQPuToxZ3UbIhzSVMMuvgfALFZHS+ozw4XA7M5vj7rNa2X+suy8EppnZNEKAeJHQmzkxfsCcZ2ZXEGbj5vNjwmMnbwLEntrrZna0uy8roM5HAj9x9/fi8WMJs4LPTexzbkxf/5iZ3Rvrd/5qZyreVwhB9WeJuiYnRrzm7hNjvW4l9OQ2Ad5x93sT+z1mZn8j9ML+E7ctBcbF894X70QlA+vd7v5MPPckIPvozXeBWbG3BfAfM2skPKZTlg/2lbzFdw7h00/WUYQo3UTIIrsx8DEhQh+e2O96wqel5+P3v4nbsoYCtxA+Hb0OHOrucwDcfbqZDScEqo2Ah1k1AI0hPAf1GrCQ0BV+oJ3tFJEc7v6KmZ1KCCbbm9mDwMjYU8nnncTrT1k5ZrwZ8EaiLPk6Vz/gj2a2PLHtM8Ib+VsFVHszwntD1mtxW9a82PtqrrxgZnY/IYhACKxLCUGouUC64ufj7p+aGcSfkZntT3hvG0C4S7YOK98/Ad7POW/y57vKuXPK+gG7mtmHifIuwG9baV6bVSxAuft5NP9JZ3ILx2UI91PPaKZ8FrBXC8ffTuiS5itbDBwXv0SkjLL/F82sF+FD5sWEZxSL8TZhbOWF+P0WLez7BuHB/H8WcN58YyCzCW/K2d7BlnFb1gZmtm4iSG0J/F8B11qNu++f/N7Mdge2NLMuBfb2ssd1JWTnPgb4s7svjRm32z3bkvDzfMzd9y3BuQpSjWNQItLJmNk2ZvbN+Aa6iHDH4rM2nOoO4Cwz28DM+hLGtZpzHfALM+sX69AnZvXN511gIzNbL7FtMmEIoI+Z9QZGEyYYJI01s7XjMMJ3gTvjtYbFLNrNeZdwZ6g5zxCC8XgzW9fMupnZ11rYP2ttwq3UOcCy2Jv6dgHHFeKvhEd0jjazteLXLonxwZJLfRZfR6Z0G1Lt2vmcUilnL3YlLFm2LeH21ZOEVWKKNY4QeF4lvIFPovlx48sJPYe/mdlmhMkDfyAnqy+Au79kZpOBmTvssMN6CxYs2Iyw8k0v4L9xtzvjtqx3CEMLswm3woa7+0uxbAugpZ7becCtcVbiCdmZcIn6fBZTUVxBGLrIEO4EtdgbdPdPzOwUQiDvCtwD/KWlYwoVz/1twpjUZYQOzjTCLMY2aS3dRl0mU+5ZqJ2TmWXcvRTd5o6mI0+5bqtabDN0gHab2YnAUHffs4SnbbXdrT3YGycm/L+4Qk1Hkdrvu7n3U/WgRKTDMLPPEW6NPUVYR/N04KpUK5WHu5fqtlpNU4ASkY5kbcIEi60Ij6f8nlUXgJZORAFKRDoMd38N+EIV1ONRwmxCKSPN4hMRkaqkACUiIlVJAUpERKqSxqDaQc9BiYi0XWvPQSlAtYO7t+VBQxERAeKH+3vMrCFfuW7xiUiqlPK9bczsUTM7Pu165DKzjJl9vhTnUg9KpBOru/mnZU35nvnhr5TyXcpGPSgREalK6kGJSEVUIuV7zvWKSfl+P9DVzOZ369at+6JFizajfCnf6wiLrR5JWND1NUJa9bypOuIK7GMJSzzNAU5O5K3rZ2b/JCRqfSqeZ2487k5CjqnuhEVdT3T36bHsFnJSuz/wwANdt9566+w1M8CJhKWkehMWqh0R0x9hZscBPyNk532GsOBtMndWSagHJSJlp5Tvq/g2ISgMIATOHxCC4WrM7CuEzN8/i/t+g1V/bkcQVnPfmLAM1E8TZfcT1ivcmJBNNzd4rpLa/eKLL+6bU/5dYBdC279P+J1hZgcBZwOHAH2Ax2khp197KEC1g5ndEKdJikjLkinf13L3We7uLew/1t0Xuvs0wqf/QXH794EL3X1eTOV+RQvn+DGhV/NmTE56HnComRV65+hIQmr092KW7rGsnmDxXHdf7O6PAdmU761ZCvQEBgJ17v6iu7/dzL4/Am5y94fcfbm7v5VI6QFws7vPcPeFhB7ejtkCd7/J3T9JtH1QTr6ru939mZgQcdLLL7/cPefa4939Q3d/HXgkce4fAxfFei8jZETfMZt3qxhmdkB8XCcv3eJrB00zFymMUr6v5O7/MLOrCL25Lc3sj4Sez/qszBSMu/cg5JW6r4XT5f05mdmawC+Awwi9nOzPoDfwUb5jFy5cuGYh5yb8XC83s0sT5XWEnmRRt/lam2auACUiFaGU7yu5+xXAFWa2MaHn8zN3P5eVQSDZBivknDmOAA4EvkW4Jbge4RZnqVK//6KQ8bb20i0+ESk7pXxfKaZJ39XM1iJMVFhE8z+LG4Efmtk+ZraGmfU1s4EttDmrJ7CYMLa1DuE2XKlcR/gdbA9gZuuZ2WElPP8K6kGJdGLtfE5JKd/Lk/K9FzCBMNFjEfAg8Kt8O7r7M2b2w7j/VoRAejLwUr79E24jTGp4C/gAOJcwK6/d3P2PZtYD+H0M/h8BDxGDcykp5XsbKeV7TanFNkMHaLdSvpeUUr6LiLSVUr7XFgUoEelIlPK9hihAtYPSbYhUllK+dy5Kt1FGeg5KRKTtlG5DREQ6JAUoERGpShW7xWdmIwgrFH8RmOzuw+L23QirFn+Z8LDao4TVid+O5ecRFm1cnDjdDu4+M5b3J6xovCvwOmHF3YcT1z0CuIiwxMdDhCfLP4hlXYFrgUMJzzFc4u6XlbrtIiJSvEr2oGYTHnK7KWf7BsANhBWK+wGfEAJO0h/cvUfia2aibDLwLLARIZDdZWZ9AOKTztcTllPZhBCEkjN+ziNMVe0H7A2cYWaD29dMEREphYr1oNz9bgAz25nE7Bd3vz+5X1xE8bFCzmlmA4CdgG/H1Xwb44KUQwhPmx9JmGU3Je5/LvCimfV090+AY4Afuvs8YJ6ZTST08h5Y7WIiUnXMbD6JOyrSuVTjLL5vsHJxxqwDzOwDwtImV7n7tXH79sDMGGyypsXt2fInswXu7ma2BBhgZjMJKw9Pyzn2oFI1RCRtdaffU96U75ceUNBqKmZ2FrCHu38nse1l4OU82851998Xct644nch198LpXTvcKoqQJnZDoQFGZMLOt5BuAX4LmGcqdHMPnT3yYSVfz/KOc1HhGXfaaG8JytXDf4oT1lBBg8evGKp/SFDhsxpaGiYW+ixHdi2hCVRakkttrlQBf1cbrnllnVPOumkrZctWza1S5cuzJ49u8vGG2+85ZIlS/ontwGff+yxx84ikXjvpJNO6r/rrrt+cuyxx+ZN6leIiRMn9hw1atTGBda3Vn/fFW33xIkTezc2NvZpaZ+qCVBm9nlCBsj/5+6PZ7e7+wuJ3Z40s8sJkxomE9Is98o5VS/COBatlM9PfL8oz7GteuCBB9YtdN+01dXVHUFY0XhLwmSSszOZzO1tOFXVr89WBh25zeVebLOgn8uwYcPWBj7cZpttfuzu/95jjz2+T8hiW7/NNtuMTGy7cPPNNx+UPPbBBx+85cEHH3z02GOPvSX3vDE1+dYx31RXQg6k7xMWp/0jcBphrH0u0CWxEvgAwlDDNfH1QmCSu4+kY/++26Oi7W5oaKChITz+FH+Pq6mKaeZxRdyHgfPd/bet7J5hZU6T6UC9mSV7PYNYeYtwOiszcWJm9YQ/3Blx3OntZHnOsZ1GDE4TCZNB6uK/E+N2kbJz9yXA04Rb+MR/HweeyNk2pR2XuZgQbHYEPk+4kzI6N6V7/JpNWO38cnfvRci5dEc7ri1lULEAZWZdzKwbsCawppl1i9v6Av8Arnb36/Icd2DM/VJnZl8BTiEul+/uM4DngDHxfAcDOwCN8fBJhPGrPcxsXcJS/XcnxqxuI+R72SB+smoAbinPT6B0xo4du1dz28eOHTsnT/mFhJwwSavliGnh+BavK1Kgx1gZjPYgBKjHc7YVNEEql5nVEf7/nubuH8T/4xcCQ1s4bCnweTPr7e7z3f1fbbm2lE8lb/GdA4xJfH8UMJbQI6onBJkV5YnBz6GEqeldgTeBi9391sR5hhKCyjzCratD3X1OPMd0MxtOCFQbEXppydwxYwjPQb1G6OJf7O5VP4Mvs+i2R0aNvKWlXVorz+o3auRW+brWzR5/9tmL37rwwlLmPpMaMgU42cw2APq4+8tm9i5wa9z2hbgPZvZfwu1oCB+mvm9mv47f3+7uJ+Wcu0/c799mKxLQ1hE+EDfnR4QPrS+Z2avAWHf/a3saKKVVyWnm5xGeO8pnbAvHHd7KeWcBe7VQfjuQd6zF3RcDx8WvDmPR4uWcdXp9wfvffsfbvPHW4tW2b9G3a1HnARh76aKquC0sHdJThNTjJxCT+bn7x2Y2O26b7e6vxu07ZA8ys1uAR939lhbOPZfwIXN7d38rT/lqH8Tc/WXgcDNbAziE8AzlRu7ehqZJOejNpgaMHmV0777qr7p79zUYPcqaOUKk9OKzilOBkYRbe1lPxG1tHn9y9+WEcdYJZrYxQEyPvl/cZbWU7mZ2lJn1icd+GDe3JQ29lEnVzOLriDpKuo3DDt4UgHHjnTdnL2bzzboyepSt2C6dV6HPKTWjHLO6HgN2JwSlrMeBEbRvggTAmYTHVP5lZr0J6c6vBR5MpnQ3szWB7YDBwGVmtg7hNv9Qd1/UzLmlDFpLt6GU722UZsr3USO3yhR7a65Uxl466O3LLrtss1Qunh5NO65C8dbcZ0A/d3+9hKeu6naXUdWlfNctPhHpqL5AeIbxnbQrIuWhACUiHY6ZDQEeAc6Mz1hJJ6QxKBHpcNy9kZXPO0onpR6UiIhUJQUoERGpSgpQIiJSlTQG1Q4d5TkoEZFq1NpzUApQ7eDuJ6RdBxGRjip+uL/HzBrylesWn4hIK8zsbDP7Tdr1qDXqQYnUkJgy5U7gsDFjxjzaSnnRx7ckmVwwse084PPuflQx52ovM3uUkAK+oKDj7gUv4Z9WmzojBSiRGlFkcCq6vCOIeaNSWaJMiqcAJVIDOkJwMrO9gN8BEwgLv34GnO3uN8fy7sAFwKHA+sDzwL7uvtDMdgMuIywC+xrw/9z90Xjco4T0HnsBOwF3E5Ij7hZzTN3i7iPM7HLgkO7du2+2cOHCfwOnuvvj8RznEXtFZtYfeBUYBpxPyEM1wd1/YWaDgbOBOjM7CPBY51Hu/uVEW08H9nD3g0r04+uUNAYl0sl1hOCUsCkhZ1RfQkLBq2MyQ4BfAV8GvgpsCJwBLI9Zue8lBIINgZ8CjWbWJ3Heowk5p3oSAsvjwIiY/n1E3Od/gR2fffbZZwk55O6MWcCb83VgG2AfYLSZbRsTnl4I/CGeexDwF2ArM9s2cexRwG+L+9HUHvWg2kHTzKXadbDgBCEN+zh3XwbcZ2bzgW3M7BlCYtHdEgkJn4SQ1wm4z93vi9sfMrOpwHeAbPbtW9x9evYiiay7K7j77xKvLzWzcwgBaFozdR0bc1xNM7NpwCDgxTznXWxmfyAEpZ+b2fZAf6Dms/e2Ns1cPah2cPcTFJykyrU5+MyYMaNnAccX4zNgrZxtaxGCUtb7MThlfQr0AHoD3Qi3zHL1Aw4zsw+zX4TezecS+7zRWuXM7HQze/GLX/zijvEc68XrNie5inq2ns25FTgijoEdDdwRM3rXNHe/p6XHddSDEunc2txz6tatWz2wbyvH98kta8HrhJ5DspexFTCjgGPnElJrGKv3aN4AfuvueZ+liXIT363yvZntQRj32ue55567ec0119zZzObRtgkV+dLL/8vMlhDGvo6IX9IKBSiRTqw9t/UOPvjgmQMGDGjx+CKr8wfgHDN7HpgNfJNwe2f31g509+VmdhMhA+7RhBTuXwH+Q5hY8b8xvfvDhF7ZbsAr7v5mM6d8F0hm/ewJLAPmLFu2rG7AgAGjgV5Fti957n3NbI2YTj7rNuAqYJm7P5H/UElSgBKpMTEoNdvzSZRPbcvxLRgXv54ANiDcrjvS3f+vwON/ClxEmMzQg9CT2s/d3zCzA4FLgMmEW4nPACe2cK7LgVvN7ETCZIXTgPuBGV/72te6EYJpq7cFm3EnYbzpfTN71d13itt/S5j1d34bz1tzlPK9jZTyvaYoBXhtKUu74zT594Cd3P3lUp+/BJTyXUSkRp0I/G+VBqeqpFt8IiJlZmazCBMuDkq3Jh2LAlQ76DkoESmEu/dPuw7VSOk2ykjpNkRE2k7pNkREpEMquAdlZiOBf7j7c3FhxjsIzw0c6e5PlauCIiJSm4q5xXcacGN8fRFh5eBPgF8Du7Z2sJmNICzS+EVgsrsPS5TtA1wNbAk8DQxz99diWR0wHjg+7n4jcKa7Z2J5f+DmWIfXCQtAPpw49xGxvr2Bh4Dj3P2DWNYVuJawOvKnwCXuflnBPxERESmbYm7xrefuH5lZT8KiiFe6+42ExRQLMZuw2vBNyY1m1puw/P25hJWIpxIekss6gTDzZRCwA/Bd4MeJ8snAs8BGwM+Bu7KrGMdFGa8nrH21CSEIXZM49jxga8JaXnsDZ8Tl8kVqTl1d3aN1dXWPpl0PkaxiAtQbZvZVYCgwxd0/M7NehKe2W+Xud7v7n4D3c4oOAaa7+53uvogQNAaZ2cBYfixwqbu/GVcxvpTQE8PMBhDyu4xx94Xu3kjIETMkHnskYZbdFHefTwiCh8QgC3AMcL67z3P3F4GJ2XOLiEi6irnF9zPgLmAJKwPAdwlLirTH9iQWf3T3BWbmcftLueXx9faJY2e6+yctlD+ZOLfHBRsHmNlMYLM85z6one0RkTzis0CbEMauPwNeIKxPd0POmnX5ju1PSBK4Vs5q59KJFRygYq6V3CVu7iRMlmiPHsCcnG0fERZvzJZ/lFPWI45N5ZZly/s2c2zy3D0S3+e7bqsGDx68IPt6yJAhcxoaGuYWemxHte666/ammTXaOrFt6eRtvu666zZce+21+y9ZsqRus802Wzx69Oi3hg8fvgklbPfGG2/8uXHjxs3ad999P5k3b96aU6ZM6XPxxRdf/qUvfekCYFZLxz700ENr77vvvrz00kv/KlV9WtDpf9/NqGi7J06c2LuxsbHFNR2LmcX3gbtvmNzm7kvN7D1g4zbWEWA+q68a3IswASNfeS9gvrtnYjKzYo5Nls9PfL8oz7GteuCBB9YtdN8SS20BxQULFsyl9tZn69Rr0tXV1R1BuL1dB/D222+vfeKJJ24CvDt8+PCStfu9996bNXz48JPd/eENNtiAAw88kJEjR37lgQce+FdM996PME5thA+LN7r7eQD77rvv6wADBw7M3vrfl7Cu3UTC+HQGeBA42d0/bGdVO/XvuwUVbXdDQwMNDeHxJzPL+55WzBhUbqIxzGwtYM021W6l6YQ/sOw51yX8gU7PVx5fJ8vqE2NK+cqT564HugIz3H0e8HYL5xapFRcC6+RsW2fcuHF98+1cSu7+DPAmIU/SAsK48PrA/wAnmtlBcddvxH/Xj6nUnyIE1IsId3a2BbYgjGFLJ9FqD8rMHid8OulmZlNyijcnMcbTynm6xOutCaxpZt0I96L/CPzSzIYA9wKjgf+6+0vx0NuAkWZ2X6zH6cCVAO4+w8yeA8bE9Mz7E2b6ZcfIJgFPxWRk/yEs9X93YszqNkJ+mqmEe+MNwA8LaY9IJ7Jlvo3vvPPO2hW6/mxgQ3d/NLHtv2Y2GdgT+FO+g9z9FeCV+O0cM7sMGFPGekqFFXKL7zeETyq7sPI5KAjB4l3gHwVe6xxW/eM5Chjr7ufF4HQVIfHY04SZglnXExKLPZ+oz/WJ8qHALcA8wnNQh7r7HAB3n25mwwmBaiNCMrNkABpDeA7qNWAhcLG7P1Bge0Q6i9cJt9dWsemmmy6p0PX7Ah+Y2a6EZx6/AKxNuNtxZ3MHmdnGwBWE3ldPwh2heWWvrVRMqwHK3W8FMLN/JXo1RYv3ks9rpuxhYGAzZRngjPiVr3wWsFcL170duL2ZssXAcfFLpFadTRjLSd7m+3T06NHvlvvCZrYLIUA9QegpXQXs7+6LzOzXhAfsIf+460Vx+w7u/n68HXhVuesslVPMLL6XzOzbwI6snAGXLRtd4nqJSIVkMpnb6+rqIDxE35VwR+Hs4cOHjyzXNeMzlN8gZLb9nbs/H8eSP4jB6SvAEcDf4iFzgOWEuykz4raehMkUH5pZX8KjMNKJFDOL7yrg+8AjhBUZsmo2Ja/SbUhnEYPUCfH1XnFzOQLUPWa2jBBsXiAsmXZdLDsJuDS+1zxGeIRlfQB3/9TMfgH8M07OGgyMJYwjf0QYi8qmbpcOopTpNg4HdnT3N9pdq05C6TZECtdaTiR3v4uwGEBz5aMJk6iSvpzz/aVtqpykorV0G8UEqPeBD0tRKRGpPomek0hVKCZAXQpMMrOLCLP3VnD3mSWtlYiI1LxiAtS18d/v5mzP0P6HdUVERFZRzCw+Zd8VEZGKKTromNkWMaOuiIhI2RQzzXxLQnLAHQm39XqY2aHAYHc/vqVjRUREilVMD+p6wlp5PYGlcdtDhFWFa5KZ3RDn8Rekrq7uiLq6ull1dXXL479HlLN+IiLVzMwOiM+T5lVMgPoKMD4mFssAuPtHwHrtq2LH5e4nFPqQbiKlQT/C2ob9gIkKUiJSq9z9npaeJy0mQL0LfD65wcy2Iyw0Ka3Lm9IgbhcRkRzFTDP/FfDX+BxUFzM7nLDI5Piy1KwD2Pdbe2S23mouvXouWq3s40+68fKrvWmuPKHfqJFbrbZcVEvHd+uqCZUi0vkVM838JjP7ADgBeIOQWOxcd/9TmepW9e66dW1CrrSWhPLb73ibN95avFrpFn27ctbp9a0eLyJSa4qZxbdmDEZ/KlttOrHRo4xTzniJhQuXr9jWvfsajB5lKdZKRKR6FXOv6B0zu8bMvla22nRihx28KVdcMpAt+nalri70nK64ZCCHHbxp2lUTEalKxYxBfZuwovlkM1tOeCbqdnd/vuXDJOuwgzdVQBIRiVpLt1FwD8rdn3X3M9x9S+BYYAPg72b23/ZXU0REak0pp5knNQEvEiZL9G/jOURERJpVzCSJ9YEhhDTMuwMPAhcDfylLzUREpKYVMwY1G3gSmAQcEleREBERKYtibvEZcAnwdeB3AGa2s5l9sxwVExGR2lZMgBoCXAPMAL4Rty0ELih1pURERIoJUKcB33L38UD2adOXgG1KXisREal5xYxB9STM2oO4mjmwFrCkpDUSEZGaULLnoIApwKicbacAj7ShXiIiUuNaew6qmB7UT4B7zKwB6GlmTcDHtBD9RERE2qqY1czfNrNdgF0IyfbeAJ6JCQxFRERKqpgeFO6eAZ6JXyVjZvNzNnUHrnH3n5hZf+BVYEGi/GJ3Pz8eW0fISXV8LLsRODPWlXj8zcCuhOSKI9z94cS1jwAuAnoTUtgf5+4flLJ9tS5mDb4Q2JLwOzg7k8ncnm6tRKTaFRWgysXde2Rfm9m6hOy9d+bstr67L8tz+AnAQcAgwuSNh4CZwHWxfDLwFPCd+HWXmW3t7nPMbHvgeuB/gP8ANxCm0g8tTcskkeo+m004m+oeBSkRaUlVBKgchwLvAY8XuP+xwKXu/iaAmV0KNADXmdkAYCfg2+6+EGg0s1MJz3RdBxwJ3OPuU+Kx5wIvmllPd/+khG3qND7++OO1x44dOwc4bMyYMY/mlo8dO3YvwoeLbHneVPddunS5DFgtQOU5XkRqVDUGqGOB27K36BJeM7NsD+ln7j43bt8emJbYb1rcli2bmRNscsufzBa4u5vZEmAA8O9SNKaz2bzPIxst/Gg5wCOjRt7S0q4tli9btmyTfKnuWzr+4gmzzspkMuMLrauIdGxVFaDMbEtgT+BHic1zCRMzngM2Aq4mrAe4XyzvASTXBfwI6BHHpnLLsuV9mzk2W96zPe3ozE4b0b+o/due6n51Szj4FEIPu9K2BaamcN20qd21paLtnjhxYu/GxsY+Le1TVQEKOAZ4wt1fzW5w9/ms/KG9a2YjgLfNrJe7fwzMB3olztELmO/umTj5IlmWLc/2qForl3YqZar7CRMm3HDZZZedV8LqFWoqsHMK102b2l1bKtruhoYGGhoaAIh3x1bT1nxQ5XIMcGsr+2QbUhf/nU6YIJE1KG7LltWbWc8Wylcca2b1QFfCeoNSAkp1LyJtVTU9KDP7KuHW250523cFPgReJmTxvQJ4NJHu4zZgpJndRwhepwNXArj7DDN7DhhjZucA+wM7ECZJQLhV+JSZ7UGYxTcOuFsTJEpLqe5FpC2qqQd1LPmDQz3wAOG22/8Bi4HDE+XXA/cAz8fye+O2rKGEbus8wvNSh7r7HAB3nw4MJwSq9whjTyeVtFUiItImdZlMSxOppDlmlvnPlP5pV6OmrL/5P8ZmMpnzUri0xiRqi9pdYWaWcfe63O3V1IMSERFZoWrGoEREpLaUMt2GiIhIybSWbkMBSkREqpIClIiIVCUFKBERqUoKUCIiUpUUoEREpCopQImISFXSc1AiIpIKPQclIiJVSc9BiYhIh6QAJSIiVUkBSkREqpIClIiIVCUFKBERqUqaZi4iIqnQNHMREalKmmYuIiIdkgKUiIhUJQUoERGpSgpQIiJSlRSgRESkKilAiYhIVdJzUCIikgo9ByUiIlVJz0GJiEiHpAAlIiJVqWrGoMzsUWA3YFnc9Ja7bxPL9gGuBrYEngaGuftrsawOGA8cH4+7ETjT3TOxvD9wM7Ar8Dowwt0fTlz3COAioDfwEHCcu39QrnaKiEhhqq0HNcLde8SvbHDqDdwNnAtsCEwF/pA45gTgIGAQsAPwXeDHifLJwLPARsDPgbvMrE889/bA9cDRwCbAp8A15WqciIgUrtoCVD6HANPd/U53XwScBwwys4Gx/FjgUnd/093fAi4FhgGY2QBgJ2CMuy9090bgeWBIPPZI4B53n+Lu8wlB8BAz61mhtomISDOqLUBdZGZzzeyfZrZX3LY9MC27g7svADxuX608vk6WzXT3T1ooT57bgSXAgJK0RlJXV1d3RF1d3ay6urrl8d8j0q6TiBSmasaggDOBFwgBYihwj5ntCPQA5uTs+xGQ7eX0iN8ny3rEsancsmx532aOzT23VJHTTjvtBMIt3IJcd911G3br1q3fokWLsh/E+nXr1u2311133QXDhw8vZpxxW8Kt5VqjdteWirZ74sSJvRsbG/u0tE/VBCh3fzrx7a1mdjjwHWA+0Ctn915AtleUW94LmO/uGTMr9tjccqkiEyZMuOGyyy47r9D9TzzxxFnk3CVYtGjRGieeeOIaw4cP37mIS08Fitm/s1C7a0tF293Q0EBDQwMAZpbJt0/VBKg8MkAdMJ0wzgSAma0LWNxO/HcQ8Ez8flBOWb2Z9Uzc5hsE3J5zbPbc9UBXYEapGyPtN2ZU/ZhRI7caU4JT9Rs1cqu8/yHyWaPb4W9deOGFJbisiBSjKgKUma1PmAb+GGGa+Q+AbwCnAh8AvzSzIcC9wGjgv+7+Ujz8NmCkmd1HCGqnA1cCuPsMM3sOGGNm5wD7E2b6ZSdJTAKeMrM9gP8A44C7c8aspEqcNqJ/UfvffsfbvPHW4tW2b9G3K2edXl/wecZeuqjaxmpFakK1/MdbC7iAMNY0F/gJcJC7N7n7HEJA+QUwjxDIhiaOvR64hzA77/8IQez6RPlQQrd1HuF5qUPjOXH36cBwQqB6jzD2dFJ5miiVNnqU0b37qn/i3buvwehRllKNRKQYVdGDigFjlxbKHwYGNlOWAc6IX/nKZwF7tXDu21l5y086kcMO3hSAceOdN2cvZvPNujJ6lK3YLiLVrSoClEi5HHbwpgpIIh2UApSIiKRC6TZERKQqKd2GiIh0SApQIiJSlRSgRESkKilAiYhIVVKAEhGRqqQAJSIiVUnPQYmISCr0HJSIiFQlPQclIiIdkgKUiIhUJQUoERGpSgpQIiJSlRSgRESkKmmauYiIpELTzEVSUldXd0RdXd2surq65fHfI9Kuk0g1aW2auXpQImUQg9FEYJ24qR8wsa6ujkwmc3t6NRPpOBSgRAo0duzYvYA7gcPGjBnzaEvlwIWsDE5Z6/Tq1eu3Y8eOnd3a8fnKRWpNXSaTSbsOHZKZZf4zpX/a1ZAKmHDVLBYtXl7UMRdPmNVs2Zmn9S/mPGdlMpnxRV28dKYCO6d07TSp3RVmZhl3r8vdrh6USCtOG9G/6GNuv+Nt3nhr8Wrbt+jblbNOry/4PBdPmNWt6IuLdBKaJCFSBqNHGd27r/rfq3v3NRg9ylKqkUjHowAlUgaHHbwpV1wykC36dqWuLvScrrhkIIcdvGnaVRPpMHSLT6RMDjt4UwUkkRboOSgREalKSrchIiIdkgKUSCekVSykM6iKMSgz6wpcA3wL2BB4BTjb3e83s/7Aq8CCxCEXu/v58dg6YDxwfCy7ETjT3TOxvD9wM7Ar8Dowwt0fTlz7COAioDfwEHCcu39QnpaKlJ9WsZDOoioCFKEebwB7EoLId4A7zOyLiX3Wd/dleY49ATgIGARkCEFmJnBdLJ8MPBXP+R3gLjPb2t3nmNn2wPXA/wD/AW4gBMqhJW2dSDsUs4JFLM+7ikWXLl0uA1YLUFrBQqpV1a4kYWb/BcYC/yb0oNbKF6DM7EngFne/IX7/I6DB3XczswHA80Bvd/8klj8OTHL368zsQqC/ux8Rywx4Edgou38L9dNKElJ2aa5isUa3w9+68MILNy/q4p2DVpKosA61koSZbQIMAKYnNr9mZtke0s/cfW7cvj0wLbHftLgtWzYzJ9jklj+ZLXB3N7Ml8dr/LlFzRNoszVUsxl66SGPUkqqqC1BmthYwCbjV3V8ysx7ALsBzwEbA1bF8v3hID+CjxCk+AnrEsancsmx532aOzZb3LEljRFIwepRxyhkvsXDhyp5XW1axWHfddXsTPlXXmm1Ru8tu4sSJvRsbG/u0tE9VBSgzWwP4LbAEGAHg7vNZ+UN718xGAG+bWS93/xiYD/RKnKYXMN/dM2aWW5Ytz/aoWisX6XCyDwePG++8OXsxm2/WldGjrOiHhhcsWDAX3eqqJRVtd0NDAw0NDUC4xZdvn6oJULHHcyOwCfAdd1/azK7ZhmTvV04nTJB4Jn4/iJW3BqcD9WbWM3GbbxArB4qzx2brUA90BWa0rzUi6dIqFtIZVE2AAq4ldDG/5e4LsxvNbFfgQ+BlYAPgCuBRd8/emrsNGGlm9xGC1+nAlQDuPsPMngPGmNk5wP7ADsCQeOwk4Ckz24Mwi28ccHdrEyRERKT8qiJAmVk/4MfAYuCdMJkO4rblhGmzGwMfEyZJHJ44/HqgnjBbD+A3cVvWUOAWYB5hCvuh7j4HwN2nm9lwQqDaCHgY+GFpWyciIm1RFQHK3V9j5S27fCa3cGwGOCN+5SufBezVwvG3k+fZEBERSZemkYqISFVSgBKRktI6gFIoMzvAzG5orlwBSkRKJrEOYD/CbfvsOoAKUrIapdsQkUrKuw5g3C5SlKqYJCEi1adX1z9/btTIP5Zqsc5+o0ZuVfC5Lp4w66xMJjO+RNeWDkoBSkTySnMdwIsnzOpW9MWl09EtPhEpmdGjjO7dV31bacs6gG2lCRqdiwKUiJTMYQdvyhWXDGSLvl2pqws9pysuGViRZZc0QaPz0S0+ESmpFNcBbGmChh7G74AUoESk6owZVT/mpIZtx7z8am+23mouvXouWm2fjz/pRkvlCXknaDR3fEzUWIpmSCvM7ADggObKFaBEpOqsOkFjs1b2DuVtn6Cx6vmVqLFy3P0e4B4za8hXrl+EiHQKaU/QkNJTD6oDOueojVm8rLl0WeW12defbdP0Y5FyK1WixraIEzEuBLYkZE04O5PJaNyrnRSgOqDFy5by4z0OTeXady76dyrXFSlEGhM0ErMHsxM0srMHUZBqH93iExFpHy3vVCbqQYmIJJRwiaeilneCti3x1JlvLypAtcPPhm6QynW7dlkrleuK1IJix1hLtbwTFL/EU0e/vahp5mWU1jhQmhY8uxs/G6oJGiJZo0cZp5zxEgsXLl+xrYKzB1N9OLm9vbfWppkrQElRhu1+YGrX1gQNqUalnD04ZlT9mFEjtxpTgmoVfXux2AeUK9F7U4ASEWmnUs0eTPP2YhseUC57700BqgPa+Z5RsOSzVK69+9INuXLoWalcW0RWVcrbi2lODmluQrkCVEf0+kLY7pupXPq1F/+eynUhvfEvjX1JtSrl7cU0e293/nlW3u0KUO1w072Hp3TljeGr6WQQmO33s3Pjz1K5dlq9N419STVLa/X4SkwOUYBqh2ve3z6dC2+wdjrXBdjmQFi2JJVLp9l7S4uWtZJqVYmlpRSg2uMHF6Vdg8r7SnpT65e/8HAq101zan3XLuk9zqCeo7Sm3L03BSjpMN5ZYy12vuqUil93yy5rcvfwCRW/LsDO147kqn+n03PcYM15RY8liJSSApR0HMddn8plX7/px6kERgDW7AINN6Zy6c8mHpzKdUWyFKBEWpNSYEzb8iVdU1vOK00ae6seClAiklePruukNv6187Uj4bNlqVx7g/+bpwBVJWo+QJnZhsCNwLeBucBZ7l71iyyKlFtaY35Aqrc2l149tCZ7jumalXdrzQco4GpgCbAJsCNwr5lNc/fpqdZKJG01emtzfvf1mDhtStrVqCn1fXrm3V7TAcrM1gWGAF9w9/nAE2b2F+BoYFSqlRORdNRoYE7Vn07Nu7mmAxQwAPjM3Wcktk0D9izk4PpmfqgiIlICmUymZr/q6+v3qK+vfydnW0N9ff2jBRybacd1b2hnvdt8fHuvvd9++y2otXa3p81p/77U7sq2u6P+jVdBuzP5the7vHpnMx/olbOtF/BJma97T4rHt/fa7aF2V/bYUhyf1rU7arv1N15CtR6gZgBdzGzrxLZBQFknSMQskqkc395rt4faXdljS3F8WtfuqO3W33hp1fQYlLsvMLO7gXFmdjxhFt+BwFcLOd7MbgDuSfMPo9KGDBkyJ+06VFotthnU7lqTRrvN7ADggObK6zKZUuSn6rjic1A3AfsC7wOjCnkOyswy7l5X7vpVoanAzmlXosJqsc2gdtea1Nrd3PtpTfegANz9A+CgtOshIiKrqvUxKBERqVIKUCIiUpVq/hZfe9TiJAkRkVJpbZJExQKUmR1XyH7uflO561Iq7n5C2nUQEemo4of7e8ysIV95JXtQRxewT4Ywo05ERGpcxQKUu+9dqWuJiEjHl9oYlJltBHwH2NTdf2lmmwFruPubadVJRESqRyqz+MxsT6AJOBIYHTdvDVybRn3aysxuiIN8IiJSJDM7IE42yyutaea/Bn7g7oOBbF7np4GvpFSfNnH3EzSDT0Skbdz9npYmm6UVoPq7+9/j6+xaS0vQtHcREYnSClAvmNl+Odu+BTyfRmVERKT6pNVjOR34q5ndC3Q3s+sJD2sdmFJ92kQP6oqItF1rD+qm0oNy93+xMu/STcCrwFfc/X/TqE9baQxKRKTtWhuDSm3Mx93fAi5py7FmNgIYBnwRmOzuw5rZ71jgFMIMwY+B24Gz3X1ZLH8U2I2VEzXecvdt2lInEREprUoudfRbVk6IaJa7H1PA6WYDFwD7Ad1b2G8d4FTCDME+wF+AnwLjE/uMcPffFHBNERGpoEr2oF5JvO4NHEvIY/8asCXhPuSthZzI3e8GMLOdgc1b2C/5XNVbZjYJ0IoWIiIdQCWXOhqbfW1mDwL/4+6PJ7Z9HTi3zNX4BmHcK+kiMxtPeHD45+7+aKEnGzx48ILs6yFDhsxpaGiYW5JaVrdtCZk3a0ktthnU7lpT0XZPnDixd2NjY5+W9klrDGo34F85254Gdi/XBc3sh4R0xscnNp8JvEB4BmsoYVXdHd3dCznnAw88sG7JK1r9ajEddi22GdTuWlPRdjc0NNDQEBYxN7O8wz9pPQf1LHChmXUHiP/+AniuHBczs4MI4077u/uKXo67P+3un7j7Yne/FfgnYX1AERFJWVoBahjwNeAjM3sX+Aj4OlDIBImimNlgYCJwgLu39iBwBqgrdR1ERKR4qdzic/dZwFfNbAtgM+Btd3+90OPNrAuh7msCa5pZN2BZdvp4Yr9vApOAg939mZyy9YFdgccI08x/QBijOrVtrRIRkVJKM93GBoQZdX0JM+zucfd5BR5+DjAm8f1RwFgzu4kwprRdDHjnAusB95lZdt/H3X1/YC3CVPWBwGfAS8BB7t5URBu0koSISBu1tpJEXSbT6qNJJWdmuwP3EoJCdpr5toSZfU9VvEJtYGYZd6/F24G1OIBci20GtbvWpNbu5t5P0+pB/Ro4yd1/n91gZj8ArgB2SalOIiJSRdKaJDEAuCNn213A51Ooi4iIVKG0AtTLhOeOkg4DCnr+qFooo66ISNu1llE3rVt8pxLSbZxCGIPqT1jQ9bsp1adNWlqFV0REWhYnmN1jZg35ytNKt/EkYMBVwL+BK4HPx+0iIiKpptuYB/wureuLiEh1SyVAmdmWhOeYvgT0SJa5+4A06iQiItUlrR7UnYRnoEYDC1OqQ7vpQV0RkbZr7UHdtALUQGB3d1+e0vVLQpMkRETarionSRASFe6Z0rVFRKQDSKsHdQrwpJk58G6ywN2PS6dKIiJSTdIKUDcTFmh9kQ48BiUiIuWTVoD6JrCZu3+S0vVLQpMkRETarrVJEmmNQf0X2KgcJzazEWY21cwWm9ktrex7mpm9Y2YfmdlNZta1mGu5+wnFBKe6uroj6urqZtXV1S2P/x5RzPXaQ9fWtXXtznfdjn5td7+npclmafWg/gH8zcxuZvUxqJvaee7ZhDxP+wHdm9vJzPYDRhF6c7OBPwJj47aSi7+4icA6cVM/YGJdXR2ZTOb2clxT19a1de3yX7sW21ypa6eVD+qRZooy7v7NEl3jAmBzdx/WTPntwCx3Pzt+vw8wyd03LfD8ReWDqqurm0X4BeZ6LZPJ9C/0PG1R4msXlTOmk7S76Dw5ane7r120Ul17xowZTQMGDNgmd/vYsWP3IjzDediYMWMeLfa6zR3fnvJi2tza+WfMmNE0efLkDQu9fnPX7tKly7tLly5d7X20pes3+36ayWQ65Vd9ff0F9fX1t7RQPq2+vv4Hie9719fXZ+rr6zcq8PwZYMXXyJEj544YMWJpcttpp502O5PJTO3Tp8+S5PZ8X4888sgrxxxzzLLktl/+8pezMpnM1OS23XfffX4mk5m69957f5jc3tTU1HTwwQevcvykSZNefvXVV6e1du0+ffosaWpqatpnn30+S26fMmXKC1OmTHkhue0nP/nJ0tw2bbfddguampqadtlll+XJfQu5NpDZe++9P2xqamoaOHDgKsdnMpmpv/zlL2clt02YMOHN3PMOHTp0TlNTU9Nmm222Spvq6upavXb299TU1NTUs2fPFdu22267BZlMZurQoUPn5P6eJk2a9HLu76mpqampkGvV1dVlcts0adKklx955JFXctuUyWSmbrfddguy23r27JlpampqOu2002bn/p4mT548q5DrNzU1NeW26dVXX502YcKEN/P87S1Ibhs4cODypqampty/vUwmM/Wss856p7Vr77LLLsubmpqakm3q06fPkkwmM/VHP/rR3Nb+9vbZZ5/PmpqamnL/9jKZzNTvfe97H7Z2/YMPPnhZ7u9p7733/jCTyUzdfffd57f2t3fMMccsy/d7KvTvbMSIEUtzf0/Z94gNN9xwxf/d5v72zjrrrKW5v6eW/s5yf0/jx49fmvt7yvceke9vb8MNN1w2fvz4pbm/p+a+ct8jtt5660Xjx49fmvt72nPPPT/dcccdF9XX12fyvc+mHkhSDFBeX18/OPH9WjFA9S80QBVTH6C5N5BZ5f5ZlPjaU2uw3UW1We2urXZ3kjan2u7m3k/TmiRRDeYDvRLfZ1+Xa2bh2cCnOds+jdvLTdfWtXXtznfdTn/tWg5Q04FBie8HAe+6+/vluFgmDBo2EPJfZeK/DZkyD2Tq2rq2rl3ea9dimyt17YpOkjCzz7v7K2W+RhfC7MQxwOaEH+Ayd1+Ws99g4BbCLL63gUbgGXcvaBZfsZMkOpGiB847gVpsM6jdtSa1djf3flrpaeb3mlkdcB9wL/CYuy8p8TXOIQSnrKOAsWZ2E/ACsJ27v+7uD5jZJcAjhOnojTnHtUoP6oqItF1rD+pWfJq5mdUD/wN8hxCtnyQEq/vc/c2KVqYd1IOqKbXYZlC7a03N96Bw95mEFO9Xmll3YB9CsDrLzD4h9K5udvemStdNRESqR2op3wHcfSHw1/iFmW1PCFZfBBSgRERqWKoBKpe7TyfMrhMRkRpXVQGqo9EkCRGRtqvWlO+dglK+i4i0XbWmfBcREWlRaj0oM1sb2AboDayYXuju/0irTiIiUj1SCVBm9nXCsutdCWvgfQz0BN4A6tOoU1toDEpEpO2qNaPuBOASd98Q+CT+ez5wTUr1aZNiM+qKiMhKrWXUTStADQAuz9k2HjgthbqIiEgVSitAfcTK9BZvm9l2wAZAj5TqIyIiVSatAHU3YcUIgBsJC7b+mzAuJSIiks4kCXc/NfH6UjN7mjBJ4oE06tNWmiQhItJ2Vfmgrpld4e6nZL939yfi9l8DpxZw/IaEnte3gbnAWe6+WpIsM7uOkG4jay1gibv3jOWPArsB2VxRb7n7NoW2Qw/qioi0XWsP6qb1HNQw4JQ824+mgAAFXA0sATYBdiTkmZoW1/Jbwd2HA8Oz35vZLcDynHONcPffFFhvERGpkIoGKDM7LnvdxOusekJvqLVzrAsMAb7g7vOBJ8zsL4Tg1mw23MRx321L3UVEpLIq3YM6Ov67duI1hHz27wLHFnCOAcBn7j4jsW0asGcrxw0B5gBTcrZfZGbjCek9fu7ujxZQBxERKbOKBih33xvAzC5w93PaeJoehGnqSR8RJlm05FjgNndPphA+k5AGfgkwlHAvdEd390IqMnjw4AXZ10OGDJnT0NDQag+wE9iWkHmzltRim0HtrjUVbffEiRN7NzY29mlpn4qnfM9lZnWsuhZf7hhR7v5fAv7p7usktp0O7OXueWeDmNkWwKvAgJjRt7lzPwDc6+5XFlBvpXyvHbXYZlC7a03VpXxP5TkoM9vMzP5oZu8TZtAtTXy1ZgZhDGvrxLZBtJzo8BjgyZaCU5QhESxFRCQ9ac3iux74FNgHeAz4BnAecF9rB7r7AjO7GxhnZscTZvEdCHy1hcOOAS5ObjCz9YFd4/WXAT+I9Ti1mIaIiEh5pLWSxFeB49z9OSDj7tOAHwGnF3j8SUB34D1gMnCiu083sy3NbL6ZbZnd0cx2BzZn9VUq1gIuIEycmAv8BDjI3ZsKbYSZ3RAfNBMRkSKZ2QFxwYO8UhmDMrP3gC3cfbGZzQJ2IaTcmJt9iLbaaQyqptRim0HtrjUag4qeZuVafA8CfyCsz1eLM2dERCSPtMagjmZlcDwV+Clh+vivU6qPiIhUmbQWi/0w8XohIVmhiIjIChULUGY2rpD93H10uetSKlrNXESk7appNfMtEq+7EZYe+l/gNWBL4CtAYwXr025azVxEpO2qZjVzd/9h9rWZ/R443N0bE9sOAQ6rVH1ERKS6pTWLb3/gTznb/szKmX0iIlLj0gpQrwAn52w7CShokdZqoQd1RUTarrUHddOaZn488EczOwN4C+hLWG7okJTq0yYagxIRabuqGYNKcvdn42KvuwGbAW8DT7l7IYvFiohIDUirB0UMRo+ndX0REaluaY1BiYiItCi1HlRnoAd1RUTarpoe1O10NElCRKTtWpsk0Slv8ZnZhjFj7wIze83Mjmhmv2Fm9lnMIZX92qvC1e1QJk6c2DvtOlRaLbYZ1O5aU43t7pQBCrgaWAJsAhwJXGtm2zez71Pu3iPx9Wi5K9feZ6fac3x7r93Y2NgnrWun1e72tLm9107zZ6Z2V/a67T2+I//fbk6nC1Bmti5hnb9z3X2+uz8B/IWQ4qNatPeX2Z7j03ywWO2u7LGlOD6ta3fUdutvvIRSyahbTmb2JeBJd++e2PZTYE93PyBn32GE3tZC4APgt8BF7r6sgOt0rh+ciEiK8mXU7YyTJHoAH+Vs+wjIl0p+CvAFworq2xMy+y4DLmrtIjWa7l1EpGI6Y4CaD/TK2dYL+CR3R3efmfj2+Ziz6mcUEKBERKS8Ot0YFDAD6BKXUsoaBEwv4NgMoJ6RiEgV6HQByt0XAHcD48xsXTP7GnAgYXxpFWa2v5ltEl8PBM4lpP0QEZGUdcZbfBBSd9wEvAe8D5zo7tPNbEvgBWA7d38d2Ae4xcx6AO8CvwMuTKnOIiKS0Olm8YmISOfQ6W7xiYhI56AAJSIiVUkBSkREqlJnnSRRNma2IXAj8G1gLnCWu9+ebq3Ky8y6AtcA3wI2BF4Bznb3+1OtWIXERxaeB+5y96PSrk8lmNlQYAywJfAOMMzdO3WCUTPrT/g73x1YDNwFnFrIyjIdhZmNAIYBXwQmu/uwRNk+hJV1tgSeJvzOX0uhmiuoB1W8Yhai7Sy6AG8AewLrEabj3xH/Q9eCq4H/TbsSlWJm+wIXAz8krMDyDWBmiwd1DtcQZv5+DtiR8Pd+UpoVKoPZwAWEWc4rmFlvwuM55xI+hE4lrKyTKvWgipBYiPYL7j4feMLMsgvRjkq1cmUUny07L7Hpr2b2KvBlYFYadaqU2JP4EHgS+Hy6tamYscA4d/9X/P6tNCtTQVsBV7n7IuAdM3uAsARap+HudwOY2c7A5omiQ4Dp7n5nLD8PmGtmA939pYpXNFIPqjgDgM/cfUZi2zQ62R9xa+LDzQMobHWODsvMegHjgNPTrkulmNmawM5AHzN7xczeNLOrzKx7a8d2ApcDQ81sHTPrC+wPPJBynSple8J7GbDiQ6mT8nubAlRxilmItlMys7WAScCtaX6yqpDzgRvd/Y20K1JBmwBrAYcCexBudX0JOCfFOlXKY4Q35I+BNwm3uf6UZoUqqCrf2xSgilPwQrSdkZmtQVgyagkwIuXqlJWZ7UiYFDIh5apU2sL475Xu/ra7zwUuA76TYp3KLv5tP0gYh1kX6A1sQBiLqwVV+d6mAFWc9ixE26GZWR1h9uImwBB3X5pylcptL6A/8LqZvQP8FBhiZv9Js1Ll5u7zCL2HWltiZkNgC8IY1GJ3fx+4mU4emBOmE97LgBXj7UbK722aJFEEd19gZtmFaI8n3P44EPhqqhWrjGuBbYFvufvC1nbuBG4Afp/4/qeEgHViKrWprJuBn8RJAkuBU4G/plqjMnP3uXHiz4lm9ivCLa9jSYzLdAZm1oXwvr8msKaZdSPkwPsj8EszGwLcC4wG/pv2bXz1oIp3EtCdMB11MnEh2nSrVF5m1g/4MSEgv2Nm8+PXkenWrHzc/VN3fyf7RbgFssjd56Rdtwo4nzCtfgbwIvAs8ItUa1QZhwCDgTmEZ/2WAaelWqPSO4dwG3cUcFR8fU78ux5C+D3PA3YFhqZVySwtFisiIlVJPSgREalKClAiIlKVFKBERKQqKUCJiEhVUoASEZGqpAAlIiJVSQFKpAMzs1lm9q082/cws6Y06iRSKlpJQqQTiskFt0m7HiLtoR6UiIhUJfWgRDq+XczsCkIm2D8R1gvcDfidu28O4VYgcBVwDNCPkOfo2JicT6QqqQcl0vEdCexHWH16AM3nbvo+Ya25rYAdgGGVqJxIWylAiXR8V7n7G+7+AWGxz8Ob2e8Kd58d97uHsPivSNVSgBLp+JIZf18DNmtmv3cSrz8lpJQQqVoKUCId3xaJ11sCs9OqiEgpaZKESMd3spn9ldArOhv4Q8r1ESkJ9aBEOr7bgb8BM+PXBelWR6Q0lLBQRESqknpQIiJSlRSgRESkKilAiYhIVVKAEhGRqqQAJSIiVUkBSkREqpIClIiIVCUFKBERqUr/HxSmQmvZEExSAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "execution_count": 21, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1018,6 +1131,14 @@ "\n", "Our mailing list is analysis-grand-challenge@iris-hep.org, sign up via the [Google group](https://groups.google.com/a/iris-hep.org/g/analysis-grand-challenge)." ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "569a78bf-af91-46bb-ba3f-9b6fef52411d", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/analyses/cms-open-data-ttbar/utils/__init__.py b/analyses/cms-open-data-ttbar/utils/__init__.py index 2cbfe1da..1633b082 100644 --- a/analyses/cms-open-data-ttbar/utils/__init__.py +++ b/analyses/cms-open-data-ttbar/utils/__init__.py @@ -51,7 +51,7 @@ def set_style(): plt.rcParams['text.color'] = "222222" -def construct_fileset(n_files_max_per_sample, use_xcache=False): +def construct_fileset(n_files_max_per_sample, use_xcache=False, af_name=""): # using https://atlas-groupdata.web.cern.ch/atlas-groupdata/dev/AnalysisTop/TopDataPreparation/XSection-MC15-13TeV.data # for reference # x-secs are in pb @@ -65,7 +65,7 @@ def construct_fileset(n_files_max_per_sample, use_xcache=False): } # list of files - with open("ntuples.json") as f: + with open("ntuples_merged.json") as f: file_info = json.load(f) # process into "fileset" summarizing all info @@ -82,6 +82,9 @@ def construct_fileset(n_files_max_per_sample, use_xcache=False): file_paths = [f["path"] for f in file_list] if use_xcache: file_paths = [f.replace("https://xrootd-local.unl.edu:1094", "root://red-xcache1.unl.edu") for f in file_paths] + if af_name == "ssl-dev": + # point to local files on /data + file_paths = [f.replace("https://xrootd-local.unl.edu:1094//store/user/", "/data/alheld/") for f in file_paths] nevts_total = sum([f["nevts"] for f in file_list]) metadata = {"process": process, "variation": variation, "nevts": nevts_total, "xsec": xsec_info[process]} fileset.update({f"{process}__{variation}": {"files": file_paths, "metadata": metadata}}) @@ -133,7 +136,7 @@ def make_datasource(fileset:dict, name: str, query: ObjectStream, ignore_cache: ) -async def produce_all_histograms(fileset, query, procesor_class, use_dask=False, ignore_cache=False): +async def produce_all_histograms(fileset, query, analysis_processor, use_dask=False, ignore_cache=False, schema=None): """Runs the histogram production, processing input files with ServiceX and producing histograms with coffea. """ @@ -153,9 +156,6 @@ async def produce_all_histograms(fileset, query, procesor_class, use_dask=False, for ds_name in fileset.keys() ] - # create the analysis processor - analysis_processor = procesor_class() - async def run_updates_stream(accumulator_stream, name): """Run to get the last item in the stream""" coffea_info = None @@ -169,7 +169,7 @@ async def run_updates_stream(accumulator_stream, name): all_histogram_dicts = await asyncio.gather( *[ run_updates_stream( - executor.execute(analysis_processor, source, title=f"{source.metadata['process']}__{source.metadata['variation']}"), + executor.execute(analysis_processor, source, title=f"{source.metadata['process']}__{source.metadata['variation']}", schema=schema), f"{source.metadata['process']}__{source.metadata['variation']}", ) for source in datasources