diff --git a/.gitignore b/.gitignore index 690365c..615fe4c 100644 --- a/.gitignore +++ b/.gitignore @@ -212,6 +212,3 @@ __marimo__/ # NEVER CHANGE # CMS Internal files are not supposed to be published DONT_EXPOSE_CMS_INTERNAL/ - -# ATLAS setup -atlas/ntuple_production/production_status.json diff --git a/atlas/.gitignore b/atlas/.gitignore index f294de9..5bc5f59 100644 --- a/atlas/.gitignore +++ b/atlas/.gitignore @@ -208,3 +208,7 @@ __marimo__/ .asetup.save *.out *.err +# bigpanda status +ntuple_production/production_status.json +# preprocess json +preprocess_output.json diff --git a/atlas/analysis.ipynb b/atlas/analysis.ipynb new file mode 100644 index 0000000..af4440f --- /dev/null +++ b/atlas/analysis.ipynb @@ -0,0 +1,356 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "3f9f15ac-903b-4f33-b775-e7c14a3647a8", + "metadata": {}, + "outputs": [], + "source": [ + "# ! pip install --upgrade atlas_schema\n", + "# ! pip install --upgrade git+https://github.com/scikit-hep/mplhep.git\n", + "\n", + "# import importlib\n", + "# importlib.reload(utils)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94b8b953-dc21-4d5c-899d-b1f0b03c70b2", + "metadata": {}, + "outputs": [], + "source": [ + "import gzip\n", + "import json\n", + "import re\n", + "import time\n", + "\n", + "import awkward as ak\n", + "import dask\n", + "import vector\n", + "import hist\n", + "import matplotlib.pyplot as plt\n", + "import mplhep\n", + "import numpy as np\n", + "import uproot\n", + "\n", + "from atlas_schema.schema import NtupleSchema\n", + "from coffea import processor\n", + "from coffea.nanoevents import NanoEventsFactory\n", + "from dask.distributed import Client, PipInstall\n", + "\n", + "\n", + "import utils\n", + "\n", + "vector.register_awkward()\n", + "mplhep.style.use(mplhep.style.ATLAS1)\n", + "\n", + "client = Client(\"tls://localhost:8786\")\n", + "\n", + "plugin = PipInstall(packages=[\"atlas_schema\"], pip_options=[\"--upgrade\"])\n", + "client.register_plugin(plugin)" + ] + }, + { + "cell_type": "markdown", + "id": "91bbd464-1423-4353-81cc-f43806f04a7e", + "metadata": {}, + "source": [ + "### fileset preparation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3dcf6216-0eca-4ea0-921b-eae3eda04af1", + "metadata": {}, + "outputs": [], + "source": [ + "# load metadata from file\n", + "fname = \"ntuple_production/file_metadata.json.gz\"\n", + "with gzip.open(fname) as f:\n", + " dataset_info = json.loads(f.read().decode())\n", + "\n", + "# construct fileset\n", + "fileset = {}\n", + "for containers_for_category in dataset_info.values():\n", + " for container, metadata in containers_for_category.items():\n", + " if metadata[\"files_output\"] is None:\n", + " # print(f\"skipping missing {container}\")\n", + " continue\n", + "\n", + " dsid, _, campaign = utils.dsid_rtag_campaign(container)\n", + "\n", + " # debugging shortcuts\n", + " # if campaign not in [\"mc20a\", \"data15\", \"data16\"]: continue\n", + " # if \"601352\" not in dsid: continue\n", + "\n", + " weight_xs = utils.sample_xs(campaign, dsid)\n", + " lumi = utils.integrated_luminosity(campaign)\n", + " fileset[container] = {\"files\": dict((path, \"reco\") for path in metadata[\"files_output\"]), \"metadata\": {\"dsid\": dsid, \"campaign\": campaign, \"weight_xs\": weight_xs, \"lumi\": lumi}}\n", + "\n", + "# minimal fileset for debugging\n", + "# fileset = {\"mc20_13TeV.601352.PhPy8EG_tW_dyn_DR_incl_antitop.deriv.DAOD_PHYSLITE.e8547_s4231_r13144_p6697\": fileset[\"mc20_13TeV.601352.PhPy8EG_tW_dyn_DR_incl_antitop.deriv.DAOD_PHYSLITE.e8547_s4231_r13144_p6697\"]}\n", + "# fileset" + ] + }, + { + "cell_type": "markdown", + "id": "f4a081b9-c4ec-41c8-830c-a727e56ff472", + "metadata": {}, + "source": [ + "### simple non-distributed reading" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6b6c685f-7e9c-4c5b-8f80-19f1543de32f", + "metadata": {}, + "outputs": [], + "source": [ + "events = NanoEventsFactory.from_root(\n", + " {list(fileset[list(fileset.keys())[0]][\"files\"])[0]: \"reco\"},\n", + " mode=\"virtual\",\n", + " schemaclass=NtupleSchema,\n", + " entry_stop=1000\n", + ").events()\n", + "\n", + "h = hist.new.Regular(30, 0, 300, label=\"leading electron $p_T$\").StrCat([], name=\"variation\", growth=True).Weight()\n", + "\n", + "for variation in events.systematic_names:\n", + " if variation != \"NOSYS\" and \"EG_SCALE_ALL\" not in variation:\n", + " continue\n", + "\n", + " cut = events[variation][\"pass\"][\"ejets\"] == 1\n", + " h.fill(events[variation][cut==1].el.pt[:, 0] / 1_000, variation=variation)\n", + "\n", + "fig, ax = plt.subplots()\n", + "for variation in h.axes[1]:\n", + " h[:, variation].plot(histtype=\"step\", label=variation, ax=ax)\n", + "_ = ax.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "a31f4dd8-07aa-4dd0-b50f-013349abe59a", + "metadata": {}, + "source": [ + "### pre-processing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1abaeac0-ca4c-4a36-8426-10438c4e034e", + "metadata": {}, + "outputs": [], + "source": [ + "run = processor.Runner(\n", + " executor = processor.DaskExecutor(client=client),\n", + " # executor = processor.IterativeExecutor(),\n", + " schema=NtupleSchema,\n", + " savemetrics=True,\n", + " chunksize=100_000,\n", + " skipbadfiles=True,\n", + " # maxchunks=1\n", + ")\n", + "\n", + "preprocess_output = run.preprocess(fileset)\n", + "\n", + "# write to disk\n", + "with open(\"preprocess_output.json\", \"w\") as f:\n", + " json.dump(utils.preprocess_to_json(preprocess_output), f)\n", + "\n", + "# load from disk\n", + "with open(\"preprocess_output.json\") as f:\n", + " preprocess_output = utils.json_to_preprocess(json.load(f))\n", + "\n", + "len(preprocess_output), preprocess_output[:3]" + ] + }, + { + "cell_type": "markdown", + "id": "4667b1bf-0ff3-4ccf-93e9-4f4a8e0aa3c7", + "metadata": {}, + "source": [ + "### processing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dc78d57d-4fe3-4e11-ab4c-0f0afe60ca32", + "metadata": {}, + "outputs": [], + "source": [ + "class Analysis(processor.ProcessorABC):\n", + " def __init__(self):\n", + " self.h = hist.new.Regular(30, 0, 300, label=\"leading electron $p_T$\").\\\n", + " StrCat([], name=\"dsid_and_campaign\", growth=True).\\\n", + " StrCat([], name=\"variation\", growth=True).\\\n", + " Weight()\n", + "\n", + " def process(self, events):\n", + " f = uproot.open(events.metadata[\"filename\"])\n", + "\n", + " # this should match existing pre-determined metadata\n", + " # sim_type, mc_campaign, dsid, etag = f[\"metadata\"].axes[0]\n", + " # assert mc_campaign == events.metadata[\"campaign\"]\n", + " # assert dsid == events.metadata[\"dsid\"]\n", + "\n", + " # ensure systematics in schema and in histogram match\n", + " # systematics_from_hist = list(f[\"listOfSystematics\"].axes[0])\n", + " # assert sorted(systematics_from_hist) == sorted(events.systematic_names)\n", + "\n", + " # categorize events by DSID and campaign with a single histogram axis\n", + " dsid_and_campaign = f\"{events.metadata[\"dsid\"]}_{events.metadata[\"campaign\"]}\"\n", + "\n", + " if events.metadata[\"dsid\"] != \"data\":\n", + " sumw = float(f[f.keys(filter_name=\"CutBookkeeper*NOSYS\")[0]].values()[1]) # initial sum of weights\n", + " else:\n", + " sumw = None # no normalization for data\n", + "\n", + " for variation in events.systematic_names:\n", + " if variation != \"NOSYS\" and \"EG_SCALE_ALL\" not in variation:\n", + " continue\n", + "\n", + " cut = events[variation][\"pass\"][\"ejets\"] == 1\n", + " weight = (events[variation][cut==1].weight.mc if events.metadata[\"dsid\"] != \"data\" else 1.0) * events.metadata[\"weight_xs\"] * events.metadata[\"lumi\"]\n", + " self.h.fill(events[variation][cut==1].el.pt[:, 0] / 1_000, dsid_and_campaign=dsid_and_campaign, variation=variation, weight=weight)\n", + "\n", + " return {\n", + " \"hist\": self.h,\n", + " \"meta\": {\n", + " \"sumw\": {(events.metadata[\"dsid\"], events.metadata[\"campaign\"]): {(events.metadata[\"fileuuid\"], sumw)}}} # sumw in a set to avoid summing multiple times per file\n", + " }\n", + "\n", + " def postprocess(self, accumulator):\n", + " # normalize histograms\n", + " # https://topcptoolkit.docs.cern.ch/latest/starting/running_local/#sum-of-weights\n", + " for dsid_and_campaign in accumulator[\"hist\"].axes[1]:\n", + " dsid, campaign = dsid_and_campaign.split(\"_\")\n", + " if dsid == \"data\":\n", + " continue # no normalization for data by total number of weighted events\n", + " norm = 1 / sum([sumw for uuid, sumw in accumulator[\"meta\"][\"sumw\"][(dsid, campaign)]])\n", + " count_normalized = accumulator[\"hist\"][:, dsid_and_campaign, :].values()*norm\n", + " variance_normalized = accumulator[\"hist\"][:, dsid_and_campaign, :].variances()*norm**2\n", + " accumulator[\"hist\"][:, dsid_and_campaign, :] = np.stack([count_normalized, variance_normalized], axis=-1)\n", + "\n", + "\n", + "t0 = time.perf_counter()\n", + "out, report = run(preprocess_output, processor_instance=Analysis())\n", + "t1 = time.perf_counter()\n", + "report" + ] + }, + { + "cell_type": "markdown", + "id": "8663e9ff-f8bb-43a0-8978-f2d430d2bbbd", + "metadata": {}, + "source": [ + "track XCache egress: [link](https://grafana.mwt2.org/d/EKefjM-Sz/af-network-200gbps-challenge?var-cnode=c111_af_uchicago_edu&var-cnode=c112_af_uchicago_edu&var-cnode=c113_af_uchicago_edu&var-cnode=c114_af_uchicago_edu&var-cnode=c115_af_uchicago_edu&viewPanel=195&kiosk=true&orgId=1&from=now-1h&to=now&timezone=browser&refresh=5s)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9575019b-d1a5-4a8e-9d5a-32d0d8bd0919", + "metadata": {}, + "outputs": [], + "source": [ + "print(f\"data read: {report[\"bytesread\"] / 1000**3:.2f} GB in {report[\"chunks\"]} chunks\")\n", + "\n", + "print(f\"core-average event rate using \\'processtime\\': {report[\"entries\"] / 1000 / report[\"processtime\"]:.2f} kHz\")\n", + "print(f\"core-average data rate using \\'processtime\\': {report[\"bytesread\"] / 1000**3 * 8 / report[\"processtime\"]:.2f} Gbps\")\n", + "\n", + "print(f\"average event rate using walltime: {report[\"entries\"] / 1000 / (t1 - t0):.2f} kHz\")\n", + "print(f\"average data rate using walltime: {report[\"bytesread\"] / 1000**3 * 8 / (t1 - t0):.2f} Gbps\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "982cce52-7f5c-4126-a5cc-6a4dfee70732", + "metadata": {}, + "outputs": [], + "source": [ + "mc_stack = []\n", + "labels = []\n", + "for key in dataset_info:\n", + " dsids = []\n", + " for container in dataset_info[key]:\n", + " dsids.append(container.split(\".\")[1])\n", + "\n", + " dsids = sorted(set(dsids))\n", + " dsids_in_hist = [dc for dc in out[\"hist\"].axes[1] if dc.split(\"_\")[0] in dsids]\n", + " print(f\"{key}:\\n - expect {dsids}\\n - have {dsids_in_hist}\")\n", + "\n", + " if key in [\"data\", \"ttbar_H7\", \"ttbar_hdamp\", \"ttbar_pthard\", \"Wt_DS\", \"Wt_H7\", \"Wt_pthard\"] or len(dsids_in_hist) == 0:\n", + " continue # data drawn separately, skip MC modeling variations and skip empty categories\n", + "\n", + " mc_stack.append(out[\"hist\"][:, :, \"NOSYS\"].integrate(\"dsid_and_campaign\", dsids_in_hist))\n", + " labels.append(key)\n", + "\n", + "fig, ax1, ax2 = mplhep.data_model(\n", + " data_hist=out[\"hist\"].integrate(\"dsid_and_campaign\", [dc for dc in out[\"hist\"].axes[1] if \"data\" in dc])[:, \"NOSYS\"],\n", + " stacked_components=mc_stack,\n", + " stacked_labels=labels,\n", + " # https://scikit-hep.org/mplhep/gallery/model_with_stacked_and_unstacked_histograms_components/\n", + " # unstacked_components=[],\n", + " # unstacked_labels=[],\n", + " xlabel=out[\"hist\"].axes[0].label,\n", + " ylabel=\"Entries\",\n", + ")\n", + "\n", + "mplhep.atlas.label(\"Internal\", ax=ax1, data=True, lumi=f\"{utils.integrated_luminosity(\"\", total=True) / 1000:.0f}\", com=\"13/ \\\\ 13.6 \\\\ TeV\")\n", + "mplhep.mpl_magic(ax=ax1)\n", + "ax2.set_ylim([0.5, 1.5])\n", + "\n", + "# compare to e.g. https://atlas.web.cern.ch/Atlas/GROUPS/PHYSICS/PAPERS/HDBS-2020-11/fig_02a.png\n", + "fig.savefig(\"el_pt.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2e3efe0-f724-4206-b233-202a51729014", + "metadata": {}, + "outputs": [], + "source": [ + "# save to disk\n", + "import uhi.io.json\n", + "\n", + "with gzip.open(\"hist.json.gz\", \"w\") as f:\n", + " f.write(json.dumps(out[\"hist\"], default=uhi.io.json.default).encode(\"utf-8\"))\n", + "\n", + "with gzip.open(\"hist.json.gz\") as f:\n", + " h = hist.Hist(json.loads(f.read(), object_hook=uhi.io.json.object_hook))\n", + "\n", + "h[:, \"data_data15\", \"NOSYS\"]" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/atlas/ntuple_production/README.md b/atlas/ntuple_production/README.md index 9065dbc..459547d 100644 --- a/atlas/ntuple_production/README.md +++ b/atlas/ntuple_production/README.md @@ -41,7 +41,7 @@ voms-proxy-init -voms atlas ``` -- After ntuple production: `write_ntuple_metadata.py` saves relevant metadata of input and output containers plus xrootd ntuple file paths to disk. +- After ntuple production: `collect_file_metadata.py` saves relevant metadata of input and output containers plus xrootd ntuple file paths to disk. ## Notes for first and potential second production diff --git a/atlas/ntuple_production/cache_everything.ipynb b/atlas/ntuple_production/cache_everything.ipynb new file mode 100644 index 0000000..2c6afc2 --- /dev/null +++ b/atlas/ntuple_production/cache_everything.ipynb @@ -0,0 +1,85 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "ff6ca0fb-e358-4dbe-9951-e5167758d030", + "metadata": {}, + "outputs": [], + "source": [ + "import datetime\n", + "import gzip\n", + "import json\n", + "import time\n", + "import os\n", + "\n", + "import dask\n", + "from dask.distributed import Client\n", + "\n", + "client = Client(\"tls://localhost:8786\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d55ec891-e0c2-4f43-ba35-2077ecafcc07", + "metadata": {}, + "outputs": [], + "source": [ + "fname = \"../ntuple_production/file_metadata.json.gz\"\n", + "with gzip.open(fname) as f:\n", + " dataset_info = json.loads(f.read().decode())\n", + "\n", + "all_files = []\n", + "for containers_for_category in dataset_info.values():\n", + " for container, metadata in containers_for_category.items():\n", + " if metadata[\"files_output\"] is None:\n", + " continue\n", + "\n", + " all_files += metadata[\"files_output\"]\n", + "\n", + "len(all_files)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c5cb8c1-ebf6-41f7-a12d-feff9a0456b8", + "metadata": {}, + "outputs": [], + "source": [ + "def run_xrdcp(fname):\n", + " t0 = time.perf_counter()\n", + " os.system(f\"xrdcp {fname} /dev/null -f\")\n", + " t1 = time.perf_counter()\n", + " time_finished = datetime.datetime.now()\n", + " return {\"runtime\": t1-t0, \"time_finished\": time_finished}\n", + "\n", + "\n", + "tasks = [dask.delayed(run_xrdcp)(fname) for fname in all_files]\n", + "_ = dask.compute(*tasks)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/atlas/ntuple_production/write_ntuple_metadata.py b/atlas/ntuple_production/collect_file_metadata.py similarity index 97% rename from atlas/ntuple_production/write_ntuple_metadata.py rename to atlas/ntuple_production/collect_file_metadata.py index abe4847..923d83d 100644 --- a/atlas/ntuple_production/write_ntuple_metadata.py +++ b/atlas/ntuple_production/collect_file_metadata.py @@ -1,6 +1,7 @@ import collections import gzip import json +import os import re import subprocess import urllib.request @@ -138,6 +139,9 @@ def save_full_metadata(production_map, fname): if __name__ == "__main__": + # run at UChicago, pick up the correct xcache + os.environ["SITE_NAME"] = "AF_200" + username = "alheld" production_tag = "IC-v1" @@ -145,5 +149,5 @@ def save_full_metadata(production_map, fname): get_job_json(username, production_tag, fname_bigpanda) production_map = parse_job_json(fname_bigpanda) - fname_full = "ntuple_metadata.json.gz" + fname_full = "file_metadata.json.gz" metadata = save_full_metadata(production_map, fname_full) diff --git a/atlas/ntuple_production/file_metadata.json.gz b/atlas/ntuple_production/file_metadata.json.gz new file mode 100644 index 0000000..613477a Binary files /dev/null and b/atlas/ntuple_production/file_metadata.json.gz differ diff --git a/atlas/ntuple_production/input_containers.py b/atlas/ntuple_production/input_containers.py index 8763b21..374aedf 100644 --- a/atlas/ntuple_production/input_containers.py +++ b/atlas/ntuple_production/input_containers.py @@ -506,119 +506,110 @@ "mc23_13p6TeV.701125.Sh_2214_WlvWqq.deriv.DAOD_PHYSLITE.e8543_s4369_r16083_p6697", ], - #Signal ttbar->WH+->nlcs - # rucio list-dids mc20_13TeV:*ttbar_Hplus_cs_mhc*PHYSLITE* + # + # signal ttbar -> W(lnu)bH+(cs)b, e.g. https://atlas.web.cern.ch/Atlas/GROUPS/PHYSICS/PAPERS/HDBS-2020-11/ + # "Hplus_cs": [ - #Run2 - #20 GeV H+ - "mc20_13TeV:mc20_13TeV.561488.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc20.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561488.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc20.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561488.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc20.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - #30 GeV H+ - "mc20_13TeV:mc20_13TeV.561490.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc30.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561490.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc30.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561490.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc30.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - #45 GeV H+ - "mc20_13TeV:mc20_13TeV.561494.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561494.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561494.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - #60 GeV H+ - "mc20_13TeV:mc20_13TeV.561494.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561494.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561494.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - #80 GeV H+ - "mc20_13TeV:mc20_13TeV.561496.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc80.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561496.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc80.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561496.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc80.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - #100 GeV H+ - "mc20_13TeV:mc20_13TeV.561498.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc100.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561498.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc100.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561498.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc100.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - #120 GeV H+ - "mc20_13TeV:mc20_13TeV.561500.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc120.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561500.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc120.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561500.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc120.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - #130 GeV H+ - "mc20_13TeV:mc20_13TeV.561502.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc130.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561502.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc130.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561502.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc130.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # rucio list-dids mc20_13TeV:*ttbar_Hplus_cs_mhc*PHYSLITE* + # 20 GeV H+ + "mc20_13TeV.561488.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc20.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561488.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc20.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561488.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc20.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 30 GeV H+ + "mc20_13TeV.561490.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc30.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561490.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc30.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561490.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc30.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 45 GeV H+ + "mc20_13TeV.561492.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc45.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561492.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc45.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561492.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc45.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 60 GeV H+ + "mc20_13TeV.561494.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561494.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561494.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 80 GeV H+ + "mc20_13TeV.561496.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc80.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561496.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc80.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561496.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc80.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 100 GeV H+ + "mc20_13TeV.561498.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc100.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561498.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc100.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561498.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc100.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 120 GeV H+ + "mc20_13TeV.561500.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc120.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561500.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc120.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561500.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc120.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 130 GeV H+ + "mc20_13TeV.561502.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc130.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561502.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc130.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561502.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cs_mhc130.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # mc23 not available ], - - "Hplus_cb": [ - ##Run 2 (mc20 a, d and e) - # 20 GeV H+ - "mc20_13TeV:mc20_13TeV.561444.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc20.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561444.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc20.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561444.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc20.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - - # 30 GeV H+ - "mc20_13TeV:mc20_13TeV.561446.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc30.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561446.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc30.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561446.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc30.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - - # 45 GeV H+ - "mc20_13TeV:mc20_13TeV.561448.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc45.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561448.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc45.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561448.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc45.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - - # 60 GeV H+ - "mc20_13TeV:mc20_13TeV.561450.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561450.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561450.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - - # 80 GeV H+ - "mc20_13TeV:mc20_13TeV.561452.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc80.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561452.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc80.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561452.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc80.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - - # 100 GeV H+ - "mc20_13TeV:mc20_13TeV.561454.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc100.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561454.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc100.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561454.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc100.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - - # 120 GeV H+ - "mc20_13TeV:mc20_13TeV.561456.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc120.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561456.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc120.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561456.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc120.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - - # 130 GeV H+ - "mc20_13TeV:mc20_13TeV.561458.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc130.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", - "mc20_13TeV:mc20_13TeV.561458.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc130.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", - "mc20_13TeV:mc20_13TeV.561458.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc130.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", - - ##Run 3 (mc23a and d) - # 20 GeV H+ - "mc23_13p6TeV:mc23_13p6TeV.561444.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc20.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", - "mc23_13p6TeV:mc23_13p6TeV.561444.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc20.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", - # 30 GeV H+ - "mc23_13p6TeV:mc23_13p6TeV.561446.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc30.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", - "mc23_13p6TeV:mc23_13p6TeV.561446.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc30.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", - - # 45 GeV H+ - "mc23_13p6TeV:mc23_13p6TeV.561448.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc45.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", - "mc23_13p6TeV:mc23_13p6TeV.561448.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc45.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", - - # 60 GeV H+ - "mc23_13p6TeV:mc23_13p6TeV.561450.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc60.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", - "mc23_13p6TeV:mc23_13p6TeV.561450.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc60.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", - - # 80 GeV H+ - "mc23_13p6TeV:mc23_13p6TeV.561452.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc80.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", - "mc23_13p6TeV:mc23_13p6TeV.561452.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc80.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", - - # 100 GeV H+ - "mc23_13p6TeV:mc23_13p6TeV.561454.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc100.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", - "mc23_13p6TeV:mc23_13p6TeV.561454.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc100.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", - - # 120 GeV H+ - "mc23_13p6TeV:mc23_13p6TeV.561456.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc120.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", - "mc23_13p6TeV:mc23_13p6TeV.561456.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc120.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", - - # 130 GeV H+ - "mc23_13p6TeV:mc23_13p6TeV.561458.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc130.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", - "mc23_13p6TeV:mc23_13p6TeV.561458.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc130.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", -] + # + # signal ttbar -> W(lnu)bH+(cb)b, e.g. https://atlas.web.cern.ch/Atlas/GROUPS/PHYSICS/PAPERS/HDBS-2019-24/ + # + "Hplus_cb": [ + # rucio list-dids mc20_13TeV:*ttbar_Hplus_cb_*PHYSLITE* + # 20 GeV H+ + "mc20_13TeV.561444.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc20.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561444.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc20.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561444.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc20.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 30 GeV H+ + "mc20_13TeV.561446.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc30.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561446.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc30.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561446.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc30.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 45 GeV H+ + "mc20_13TeV.561448.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc45.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561448.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc45.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561448.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc45.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 60 GeV H+ + "mc20_13TeV.561450.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561450.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561450.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc60.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 80 GeV H+ + "mc20_13TeV.561452.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc80.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561452.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc80.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561452.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc80.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 100 Gev H+ + "mc20_13TeV.561454.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc100.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561454.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc100.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561454.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc100.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 120 GeV H+ + "mc20_13TeV.561456.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc120.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561456.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc120.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561456.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc120.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # 130 GeV H+ + "mc20_13TeV.561458.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc130.deriv.DAOD_PHYSLITE.e8579_a907_r14859_p6697", + "mc20_13TeV.561458.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc130.deriv.DAOD_PHYSLITE.e8579_a907_r14860_p6697", + "mc20_13TeV.561458.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc130.deriv.DAOD_PHYSLITE.e8579_a907_r14861_p6697", + # rucio list-dids mc23_13p6TeV:*ttbar_Hplus_cb_*PHYSLITE* + # not available in mc23e + # 20 GeV H+ + "mc23_13p6TeV.561444.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc20.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", + "mc23_13p6TeV.561444.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc20.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", + # 30 GeV H+ + "mc23_13p6TeV.561446.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc30.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", + "mc23_13p6TeV.561446.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc30.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", + # 45 GeV H+ + "mc23_13p6TeV.561448.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc45.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", + "mc23_13p6TeV.561448.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc45.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", + # 60 GeV H+ + "mc23_13p6TeV.561450.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc60.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", + "mc23_13p6TeV.561450.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc60.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", + # 80 GeV H+ + "mc23_13p6TeV.561452.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc80.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", + "mc23_13p6TeV.561452.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc80.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", + # 100 GeV H+ + "mc23_13p6TeV.561454.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc100.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", + "mc23_13p6TeV.561454.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc100.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", + # 120 GeV H+ + "mc23_13p6TeV.561456.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc120.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", + "mc23_13p6TeV.561456.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc120.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", + # 130 GeV H+ + "mc23_13p6TeV.561458.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc130.deriv.DAOD_PHYSLITE.e8579_a910_r15540_p6697", + "mc23_13p6TeV.561458.aMCPy8EG_NNPDF30NLO_ttbar_Hplus_cb_mhc130.deriv.DAOD_PHYSLITE.e8579_a911_r15530_p6697", + ], } diff --git a/atlas/ntuple_production/ntuple_metadata.json.gz b/atlas/ntuple_production/ntuple_metadata.json.gz deleted file mode 100644 index d49d221..0000000 Binary files a/atlas/ntuple_production/ntuple_metadata.json.gz and /dev/null differ diff --git a/atlas/process_ntuples.ipynb b/atlas/process_ntuples.ipynb deleted file mode 100644 index 7f23992..0000000 --- a/atlas/process_ntuples.ipynb +++ /dev/null @@ -1,484 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "54781021-2a58-477f-8a8a-926e9acd322e", - "metadata": {}, - "outputs": [], - "source": [ - "import awkward as ak\n", - "import vector\n", - "import hist\n", - "import matplotlib.pyplot as plt\n", - "import mplhep\n", - "import numpy as np\n", - "import uproot\n", - "\n", - "from atlas_schema.schema import NtupleSchema\n", - "from coffea import dataset_tools\n", - "from coffea.nanoevents import NanoEventsFactory\n", - "\n", - "vector.register_awkward()\n", - "mplhep.style.use(mplhep.style.ATLAS1)" - ] - }, - { - "cell_type": "markdown", - "id": "a4f4058f-6c5c-4ce6-89f4-0e0c1b34040f", - "metadata": {}, - "source": [ - "# getting files" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "f170f5b4-5e0b-4748-9629-b755dc8559bc", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Active release set to: 2024r-pp. Metadata cache cleared.\n", - "Fetching and caching all metadata for release: 2024r-pp...\n", - "Successfully cached 374 datasets.\n" - ] - }, - { - "data": { - "text/plain": [ - "{'dataset_number': '410470',\n", - " 'physics_short': 'PhPy8EG_A14_ttbar_hdamp258p75_nonallhad',\n", - " 'e_tag': 'e6337',\n", - " 'cross_section_pb': 729.77,\n", - " 'genFiltEff': 0.5437965,\n", - " 'kFactor': 1.139756362,\n", - " 'nEvents': 32890000,\n", - " 'sumOfWeights': 24014984445.816772,\n", - " 'sumOfWeightsSquared': 17816963736313.004,\n", - " 'process': 'ttbar',\n", - " 'generator': 'Powheg+Pythia8(v8.230)+EvtGen(v1.6.0)',\n", - " 'keywords': ['SM', 'lepton', 'top', 'ttbar'],\n", - " 'description': \"POWHEG+Pythia8 ttbar production with Powheg hdamp equal 1.5*top mass, A14 tune, at least one lepton filter, ME NNPDF30 NLO, A14 NNPDF23 LO from DSID 410450 LHE files with Shower Weights added '\",\n", - " 'job_path': 'https://gitlab.cern.ch/atlas-physics/pmg/infrastructure/mc15joboptions/-/tree/master/share/DSID410xxx/MC15.410470.PhPy8EG_A14_ttbar_hdamp258p75_nonallhad.py',\n", - " 'CoMEnergy': None,\n", - " 'GenEvents': None,\n", - " 'GenTune': None,\n", - " 'PDF': None,\n", - " 'Release': None,\n", - " 'Filters': None,\n", - " 'release': {'name': '2024r-pp'}}" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# getting files\n", - "import atlasopenmagic\n", - "\n", - "atlasopenmagic.set_release(\"2024r-pp\")\n", - "\n", - "# atlasopenmagic.available_keywords()\n", - "# atlasopenmagic.get_metadata(\"Pythia8EvtGen_A14NNPDF23LO_zprime3000_tt\")\n", - "\n", - "atlasopenmagic.get_metadata(\"410470\")\n", - "# atlasopenmagic.get_urls(\"301333\")\n", - "\n", - "# for dsid in atlasopenmagic.available_datasets():\n", - "# metadata = atlasopenmagic.get_metadata(dsid)\n", - "# print(dsid, metadata[\"physics_short\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "fe152497-8aad-43bf-aeaf-510b83206050", - "metadata": {}, - "outputs": [], - "source": [ - "def get_xsec_norm(dsid):\n", - " # not including normalization by sum of weights (that one depends on the number of files processed)\n", - " lumi = 36646.74 # / pb\n", - " meta = atlasopenmagic.get_metadata(dsid)\n", - " return lumi * meta[\"cross_section_pb\"] * meta[\"kFactor\"] * meta[\"genFiltEff\"]\n", - "\n", - "\n", - "fileset = {\n", - " \"Zprimett\": {\n", - " \"files\": {\"301333.root\": \"reco\"}, # https://cernbox.cern.ch/s/8LgmhEZsKofVxSs\n", - " \"metadata\": {\"meta\": 0}\n", - " },\n", - " \"ttbar\": {\n", - " \"files\": {\"410470.root\": \"reco\"}, # https://cernbox.cern.ch/s/maw47evOZ8QylGr\n", - " \"metadata\": {\"meta\": 0}\n", - " }\n", - "}" - ] - }, - { - "cell_type": "markdown", - "id": "a21373a0-cb60-4d50-9e32-727d20806833", - "metadata": {}, - "source": [ - "# interactive exploration" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7b6f199c-37cc-4e89-8d63-42d656b222a7", - "metadata": {}, - "outputs": [], - "source": [ - "events = NanoEventsFactory.from_root(fileset[\"ttbar\"][\"files\"], mode=\"virtual\", schemaclass=NtupleSchema).events()\n", - "# _ = ak.materialize(events) # force read everything (similar to using eager mode, only use this for small inputs and testing)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "3209cead-1583-4af6-b926-538b3371fee5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "h = hist.new.Regular(12, 0, 300, label=\"leading electron $p_T$\").StrCat([], name=\"variation\", growth=True).Weight()\n", - "\n", - "for variation in [\"NOSYS\"] + events.systematic_names[0:2]:\n", - " # print(variation)\n", - " event_view = events if variation == \"NOSYS\" else events[variation]\n", - " h.fill(event_view.el.pt[:, 0] / 1_000, variation=variation)\n", - "\n", - "\n", - "fig, ax = plt.subplots()\n", - "for variation in h.axes[1]:\n", - " h[:, variation].plot(histtype=\"step\", label=variation, ax=ax)\n", - "ax.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "e25b571d-abca-43ef-95a2-08bbf51eab91", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# with uproot, manually\n", - "f = uproot.open(fileset[\"ttbar\"][\"files\"])\n", - "arr = f.arrays([\"jet_pt_NOSYS\", \"jet_eta\", \"jet_phi\", \"jet_e_NOSYS\", \"jet_pt_JET_JER_EffectiveNP_1__1up\", \"jet_e_JET_JER_EffectiveNP_1__1up\"])\n", - "jets = ak.zip({\"pt\": arr[\"jet_pt_NOSYS\"], \"eta\": arr[\"jet_eta\"], \"phi\": arr[\"jet_phi\"], \"energy\": arr[\"jet_e_NOSYS\"]}, with_name=\"PtEtaPhiECandidate\")\n", - "ak.array_equal(jets.pt, events.jet.pt, check_parameters=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "73057c54-9cd3-4929-b4f8-0e7c5bb19caf", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# compare systematic variation\n", - "jets_JER1 = ak.zip({\"pt\": arr[\"jet_pt_JET_JER_EffectiveNP_1__1up\"], \"eta\": arr[\"jet_eta\"], \"phi\": arr[\"jet_phi\"], \"energy\": arr[\"jet_e_JET_JER_EffectiveNP_1__1up\"]}, with_name=\"PtEtaPhiECandidate\")\n", - "ak.array_equal(jets_JER1.pt, events[\"JET_JER_EffectiveNP_1__1up\"].jet.pt, check_parameters=False)" - ] - }, - { - "cell_type": "markdown", - "id": "6d12c10f-28fa-46df-a107-5c4e7a709d8a", - "metadata": {}, - "source": [ - "# processor approach" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8260deb5-2111-4a1f-ba97-69ac29555c0b", - "metadata": {}, - "outputs": [], - "source": [ - "# coffea processor version\n", - "from coffea import processor\n", - "\n", - "\n", - "class Analysis(processor.ProcessorABC):\n", - " def __init__(self):\n", - " self.h = hist.new.Regular(12, 0, 300, label=\"leading jet $p_T$\").\\\n", - " StrCat([], name=\"dsid\", growth=True).StrCat([], name=\"variation\", growth=True).\\\n", - " Weight()\n", - "\n", - " def process(self, events):\n", - " f = uproot.open(events.metadata[\"filename\"])\n", - " sim_type, mc_campaign, dsid, etag = f[\"metadata\"].axes[0]\n", - " sumw = float(f[f\"CutBookkeeper_{dsid}_284500_NOSYS\"].values()[1]) # initial sum of weights\n", - " systematics_from_hist = list(f[\"listOfSystematics\"].axes[0])\n", - " list_of_variations = [\"NOSYS\"] + events.systematic_names\n", - " # ensure systematics in schema and in histogram match\n", - " assert sorted(systematics_from_hist) == sorted(list_of_variations) \n", - "\n", - " # run over subset of systematics\n", - " for variation in [\"NOSYS\"] + [sys for sys in events.systematic_names if sys.startswith(\"JET_JER_EffectiveNP_1_\")]:\n", - " print(variation)\n", - " event_view = events if variation == \"NOSYS\" else events[variation]\n", - " self.h.fill(event_view.jet.pt[:, 0] / 1_000, dsid=dsid, variation=variation, weight=event_view.weight.mc)\n", - " return {\n", - " \"hist\": self.h,\n", - " \"meta\": {\n", - " \"sumw\": {dsid: {(events.metadata[\"fileuuid\"], sumw)}}} # sumw in set to avoid summing\n", - " } \n", - "\n", - " def postprocess(self, accumulator):\n", - " # normalize histograms\n", - " # https://topcptoolkit.docs.cern.ch/latest/starting/running_local/#sum-of-weights\n", - " for dsid in accumulator[\"hist\"].axes[1]:\n", - " norm = get_xsec_norm(dsid) / sum([sumw for uuid, sumw in accumulator[\"meta\"][\"sumw\"][dsid]])\n", - " accumulator[\"hist\"][:, dsid, :] = np.stack([accumulator[\"hist\"][:, dsid, :].values()*norm, accumulator[\"hist\"][:, dsid, :].variances()*norm**2], axis=-1)\n", - "\n", - "\n", - "run = processor.Runner(\n", - " executor = processor.IterativeExecutor(),\n", - " schema=NtupleSchema,\n", - " savemetrics=True,\n", - " chunksize=500 # tiny to simulate multiple chunks\n", - ")\n", - "\n", - "samples = run.preprocess(fileset)\n", - "\n", - "out, report = run(samples, processor_instance=Analysis())\n", - "\n", - "out, report" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "cd64d5d4-977d-45de-a176-1178d7c04347", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
[[0, 0, 0, 0],\n",
-       " [0, 0, 0, 0, 0],\n",
-       " [0, 0, 0, 0],\n",
-       " [0, 0, 0, 0, 0, 0],\n",
-       " [0, 0, 0, 0],\n",
-       " [0, 0, 0, 0, 0],\n",
-       " [0, 0, 0, 0],\n",
-       " [0, 0, 0, 0],\n",
-       " [0, 0, 0, 0],\n",
-       " [0, 0, 0, 0, 0, 0],\n",
-       " ...,\n",
-       " [0, 0, 0, 0],\n",
-       " [0, 0, 0, 0],\n",
-       " [0, 0, 0, 0, 0, 0],\n",
-       " [0, 0, 0, 0, 0],\n",
-       " [0, 0, 0, 0],\n",
-       " [0, 0, 0, 0],\n",
-       " [0, 0, 0, 0, 0],\n",
-       " [0, 0, 0, 0],\n",
-       " [0, 0, 0, 0, 0, 0, 0]]\n",
-       "-----------------------\n",
-       "backend: cpu\n",
-       "nbytes: 23.1 kB\n",
-       "type: 857 * var * float32
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "f = uproot.open(\"410470.root\")\n", - "arr = f[\"reco\"].arrays([\"jet_pt_JET_JER_EffectiveNP_1__1up\", \"jet_pt_JET_JER_EffectiveNP_1__1down\", \"jet_pt_NOSYS\"])\n", - "arr[\"jet_pt_JET_JER_EffectiveNP_1__1down\"] - arr[\"jet_pt_NOSYS\"] # this is surprisingly the same\n", - "# arr[\"jet_pt_JET_JER_EffectiveNP_1__1up\"] - arr[\"jet_pt_NOSYS\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "91dc1db8-0786-407a-bf79-6c8b74c8b3c5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1 JET_JER_EffectiveNP_1_PseudoData__1down\n", - "2 JET_JER_EffectiveNP_1_PseudoData__1up\n", - "3 JET_JER_EffectiveNP_1__1down\n", - "4 JET_JER_EffectiveNP_1__1up\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1b/0v72djfs4h18xh9fxml_1c3w0000gn/T/ipykernel_15773/1956051113.py:18: RuntimeWarning: invalid value encountered in divide\n", - " ratio = (h[:, dsid, variation].values() / h[:, dsid, \"NOSYS\"].values())\n" - ] - }, - { - "data": { - "text/plain": [ - "(0.8, 1.2)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# note! JER systematics need to be redone to properly take into account pseudodata variations\n", - "\n", - "dsid = \"410470\"\n", - "h = out[\"hist\"]\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(nrows=2, height_ratios=(3, 1), constrained_layout=True, sharex=True)\n", - "h[:, dsid, :].plot(ax=ax1, linewidth=2)\n", - "ax1.legend()\n", - "ax1.set_ylabel(\"count\")\n", - "\n", - "edges = h[:, dsid, :].axes[0].edges\n", - "ax2.plot(edges, [1]*len(edges), color=\"black\", linestyle=\"dashed\", linewidth=1)\n", - "for ivar, variation in enumerate(h.axes[2]):\n", - " if variation == \"NOSYS\":\n", - " continue\n", - " print(ivar, variation)\n", - " # print(h[:, dsid, variation], \n", - " ratio = (h[:, dsid, variation].values() / h[:, dsid, \"NOSYS\"].values())\n", - " ax2.stairs(ratio, edges, color=f\"C{ivar}\", linewidth=2)\n", - "ax2.set_ylabel(\"var/nom\")\n", - "ax2.set_ylim([0.8, 1.2])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "69b3a743-ffec-45d3-83f0-c8a9b390905f", - "metadata": {}, - "outputs": [], - "source": [ - "# saving preprocessing output\n", - "import base64\n", - "import dataclasses\n", - "import json\n", - "\n", - "\n", - "def write_samples(samples, fname):\n", - " # encode bytes\n", - " serializable = []\n", - " for s in samples:\n", - " chunk = dataclasses.asdict(s)\n", - " chunk[\"fileuuid\"] = base64.b64encode(chunk[\"fileuuid\"]).decode(\"ascii\")\n", - " serializable.append(chunk)\n", - " \n", - " with open(fname, \"w\") as f:\n", - " json.dump(serializable, f)\n", - "\n", - "\n", - "def read_samples(fname):\n", - " with open(fname) as f:\n", - " samples = json.load(f)\n", - " \n", - " # decode bytes\n", - " for i in range(len(samples)):\n", - " samples[i][\"fileuuid\"] = base64.b64decode(samples[i][\"fileuuid\"])\n", - " samples[i] = coffea.processor.executor.WorkItem(**samples[i])\n", - "\n", - " return samples\n", - "\n", - "\n", - "samples = run.preprocess(fileset)\n", - "write_samples(samples, \"samples.json\")\n", - "samples = read_samples(\"samples.json\")\n", - "\n", - "samples" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/atlas/utils.py b/atlas/utils.py new file mode 100644 index 0000000..e570c5e --- /dev/null +++ b/atlas/utils.py @@ -0,0 +1,123 @@ +# saving preprocessing output +import base64 +import dataclasses +import re + +import coffea + + +################################################## +### fileset saving / loading +################################################## + +def preprocess_to_json(samples): + # encode bytes + serializable = [] + for s in samples: + chunk = dataclasses.asdict(s) + chunk["fileuuid"] = base64.b64encode(chunk["fileuuid"]).decode("ascii") + serializable.append(chunk) + + return serializable + + +def json_to_preprocess(samples): + # decode bytes + for i in range(len(samples)): + samples[i]["fileuuid"] = base64.b64decode(samples[i]["fileuuid"]) + samples[i] = coffea.processor.executor.WorkItem(**samples[i]) + + return samples + + +################################################## +### container and sample handling +################################################## + +def dsid_rtag_campaign(name: str) -> tuple[str, str, str]: + """extract information from container name""" + data_tag = re.findall(r":(data\d+)_", name) + if data_tag: + return "data", None, data_tag[0] + + dsid = re.findall(r".(\d{6}).", name)[0] + rtag = re.findall(r"_(r\d+)_", name)[0] + + if rtag in ["r13167", "r14859", "r13297", "r14862"]: + campaign = "mc20a" + elif rtag in ["r13144", "r14860", "r13298", "r14863"]: + campaign = "mc20d" + elif rtag in ["r13145", "r14861", "r13299", "r14864"]: + campaign = "mc20e" + elif rtag in ["r14622", "r15540"]: + campaign = "mc23a" + elif rtag in ["r15224", "r15530"]: + campaign = "mc23d" + elif rtag in ["r16083"]: + campaign = "mc23e" + else: + print("cannot classify", name) + campaign = None + + return dsid, rtag, campaign + + +def integrated_luminosity(campaign: str, total=False) -> float: + """get integrated luminosity in pb for each MC campaign""" + if "data" in campaign: + return 1.0 + + lumi_dict = { + "mc20a": 3244.54 + 33402.2, + "mc20d": 44630.6, + "mc20e": 58791.6, + "mc23a": 26328.8, + "mc23d": 25204.3, + "mc23e": 109376.0, + } + + if total: + return sum(lumi_dict.values()) + + return lumi_dict[campaign] + + +# cache for large x-sec information dicts +MC16_XSEC_DICT = None +MC23_XSEC_DICT = None + + +def sample_xs(campaign: str, dsid: str) -> float: + """get product of sample cross-section, filter efficiency and k-factor""" + global MC16_XSEC_DICT + global MC23_XSEC_DICT + + # extracting this information is expensive, so do it once and cache + if "mc20" in campaign: + if MC16_XSEC_DICT is None: + # in case of no cvmfs: https://atlas-groupdata.web.cern.ch/atlas-groupdata/dev/PMGTools/PMGxsecDB_mc16.txt + with open("/cvmfs/atlas.cern.ch/repo/sw/database/GroupData/dev/PMGTools/PMGxsecDB_mc16.txt") as f: + content = f.readlines() + + MC16_XSEC_DICT = dict([(line.split("\t\t")[0], (line.split("\t\t")[2:5])) for line in content[1:]]) + + xsec_dict = MC16_XSEC_DICT + + elif "mc23" in campaign: + if MC23_XSEC_DICT is None: + # in case of no cvmfs: https://atlas-groupdata.web.cern.ch/atlas-groupdata/dev/PMGTools/PMGxsecDB_mc23.txt + with open("/cvmfs/atlas.cern.ch/repo/sw/database/GroupData/dev/PMGTools/PMGxsecDB_mc23.txt") as f: + content = f.readlines() + + MC23_XSEC_DICT = dict([(line.split("\t\t")[0], (line.split("\t\t")[2:5])) for line in content[1:]]) + + xsec_dict = MC23_XSEC_DICT + + elif "data" in campaign: + return 1.0 + + else: + raise ValueError(f"cannot parse campaign {campaign}") + + # return x-sec [pb] * filter efficiency * k-factor + return float(xsec_dict[dsid][0]) * float(xsec_dict[dsid][1]) * float(xsec_dict[dsid][2])