cms-tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "af98567a",
   "metadata": {},
   "source": [
    "# CMS Open Data Tutorial\n",
    "\n",
    "## First COMETA workshop on artificial intelligence for multi-boson physics\n",
    "## NIKHEF 2-3 Oct 2024\n",
    "\n",
    "What we cover here:\n",
    "\n",
    "* What's available from CMS on the open data portal and how to find it\n",
    "* The `cernopendata-client` and how to use it\n",
    "* What's in the CMS NANOAOD format and how to use it\n",
    "* What's in CMS MINIAOD, how it differs from NANOAOD, and how to enrich NANOAOD\n",
    "* Then, we'll go to the next notebook and run a ML example using open data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94ff5ae4",
   "metadata": {},
   "source": [
    "## CMS Open Data and the CERN Open Data Portal\n",
    "\n",
    "Before we do anything let's go to the [CERN Open Data Portal](https://opendata.cern.ch/) and discover what open data and resources are available."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39a4db46",
   "metadata": {},
   "source": [
    "## Accessing data: the `cernopendata-client`\n",
    "\n",
    "The [cernopendata-client](https://cernopendata-client.readthedocs.io/en/latest/) is a useful command line tool for accessing data in the CERN Open Data Portal. \n",
    "\n",
    "\n",
    "In a terminal in your virtual environment you can install it with the following command:\n",
    "```\n",
    "pip install cernopendata-client\n",
    "```\n",
    "\n",
    "We'll use it here in the notebook using the command line prompt `!`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dfd39a3",
   "metadata": {},
   "source": [
    "Let's run the command with the help option:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "236f43a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "!cernopendata-client --help"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98ef9140",
   "metadata": {},
   "source": [
    "Recall that each CMS dataset is associated to a record on the CODP. Let's select a QCD NANOAODSIM dataset:\n",
    "\n",
    "[Simulated dataset QCD_Pt-15to7000_TuneCP5_Flat2018_13TeV_pythia8 in NANOAODSIM format for 2016 collision data](https://opendata.cern.ch/record/63168)\n",
    "\n",
    "which is record number 63168.\n",
    "\n",
    "![qcd mc](imgs/qcd-mc.png]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b83438d9",
   "metadata": {},
   "source": [
    "With the CLI we can list the metadata for this dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cc666aa",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!cernopendata-client get-metadata --recid 63168"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45db0b96",
   "metadata": {},
   "source": [
    "Let's list the files available in this record:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7285c851",
   "metadata": {},
   "outputs": [],
   "source": [
    "!cernopendata-client get-file-locations --recid 63168 --verbose"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1820c14a",
   "metadata": {},
   "source": [
    "By default the files are given with the HTTP protocol. If you wish to use XRootD: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31cfb6cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "!cernopendata-client get-file-locations --recid 63168 --protocol xrootd --verbose"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae93c2e6-edf2-4e62-ac10-e09de8bdeee0",
   "metadata": {},
   "source": [
    "For reference, here's a a bit of code to fetch the available file from a record and output it to a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "481889c3-dc36-4914-bfc6-2a122b77c471",
   "metadata": {},
   "outputs": [],
   "source": [
    "import subprocess\n",
    "\n",
    "recid = 63168\n",
    "\n",
    "command = ['cernopendata-client', 'get-file-locations', '--recid', '63168', '--protocol', 'xrootd']\n",
    "result = subprocess.run(command, capture_output=True, text=True)\n",
    "root_files = result.stdout.splitlines()\n",
    "                    \n",
    "print(root_files)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c209ff57",
   "metadata": {},
   "source": [
    "Now let's download a file, one of the smaller ones. Note that the `cernopendata-client` has a download files option (see below) but since we know which file we want well use `curl` instead. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d84e526",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!cernopendata-client download-files --help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c6093c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "!curl -O http://opendata.cern.ch/eos/opendata/cms/mc/RunIISummer20UL16NanoAODv9/QCD_Pt-15to7000_TuneCP5_Flat2018_13TeV_pythia8/NANOAODSIM/106X_mcRun2_asymptotic_v17-v1/270000/397D1673-167A-CF46-9E79-D7069D9AC359.root"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84db97a6",
   "metadata": {},
   "source": [
    "## Exploring the data: the CMS NANOAOD format\n",
    "\n",
    "The NANOAOD files can of course be opened and explored using ROOT, in particular [PyROOT](https://root.cern/manual/python/). Here we'll instead use the SciKit-HEP tools [uproot](https://github.com/scikit-hep/uproot5) (\"ROOT I/O in pure Python and NumPy\") and [awkward](https://github.com/scikit-hep/awkward) (\"Manipulate JSON-like data with NumPy-like idioms\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10864e2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pylab as plt\n",
    "\n",
    "import uproot\n",
    "import awkward as ak"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2adda23",
   "metadata": {},
   "source": [
    "Let's first open the file we've downloaded and see what's in it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02131940",
   "metadata": {},
   "outputs": [],
   "source": [
    "infile_name = '397D1673-167A-CF46-9E79-D7069D9AC359.root'\n",
    "infile = uproot.open(infile_name)\n",
    "\n",
    "keys = infile.keys()\n",
    "print(keys)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "711f3be8-479e-4cac-99c2-51738bbddcd9",
   "metadata": {},
   "source": [
    "If you were using ROOT and opened up the file with a `TBrowser` you would see something like this:\n",
    "\n",
    "![nanoaod in the tbrowser](imgs/nano-root.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ad2915d-a0b7-4cf0-af3e-f8878fd6ee63",
   "metadata": {},
   "source": [
    "Since we're using `uproot/awkward` let's see what we have:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3efb796",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "events = infile['Events']\n",
    "events.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "938e1a3c-8b3b-48a3-b7e6-20f40c6308d9",
   "metadata": {},
   "source": [
    "Let's examine the key-value combinations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2049d204",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "events.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfb0d085",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "events.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64627fd4",
   "metadata": {},
   "source": [
    "What does all this mean? Recall that thankfully in the [dataset record](https://opendata.cern.ch/record/63168) there is a list of file variables (with explanations) under `Dataset semantics`. The link is [here](https://opendata.cern.ch/eos/opendata/cms/dataset-semantics/NanoAODSIM/63168/QCD_Pt-15to7000_TuneCP5_Flat2018_13TeV_pythia8_doc.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35993884-afb0-405d-9972-1fb7f1e5a8e1",
   "metadata": {},
   "source": [
    "![nanoaod dataset semantics](imgs/nano-jet.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "525843bb",
   "metadata": {},
   "source": [
    "Let's extract and plot some variables:\n",
    "\n",
    "* jet multiplicity\n",
    "\n",
    "* jet pt\n",
    "\n",
    "* jet eta\n",
    "\n",
    "We'll read them out as `awkward` arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ddc0167",
   "metadata": {},
   "outputs": [],
   "source": [
    "jet_mult = events['Jet_nConstituents'].array()\n",
    "jet_pt = events['Jet_pt'].array()\n",
    "jet_eta = events['Jet_eta'].array()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1c40aa3",
   "metadata": {},
   "source": [
    "Note the structure of the array, in which each element of array corresponds to an event and the size of each element\n",
    "depends on the number of jets in the event:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52d2e3b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "jet_mult"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a1880ad",
   "metadata": {},
   "source": [
    "Note that we have to use `ak.flatten` to flatten the array structure before we create a histogram:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7dd60b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "ak.flatten(jet_mult)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81b3c685",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(1, 3, figsize=(20,10))\n",
    "\n",
    "axes[0].hist(ak.flatten(jet_mult), bins=120, range=(0,120))\n",
    "axes[0].set_xlabel('jet_mult')\n",
    "\n",
    "axes[1].hist(ak.flatten(jet_pt), bins=80, range=(0,8000))\n",
    "axes[1].set_xlabel('jet_pt')\n",
    "axes[1].set_yscale('log')\n",
    "\n",
    "axes[2].hist(ak.flatten(jet_eta), bins=100, range=(-6,6))\n",
    "axes[2].set_xlabel('jet_eta')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56c129ea-f173-452a-9b77-593af593cdc6",
   "metadata": {},
   "source": [
    "It will be convenient to only analyze jet-related variables so let's make a crude selection of `Jet_` keys and collect the objects into a collection of arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd3a9520",
   "metadata": {},
   "outputs": [],
   "source": [
    "jet_keys = [jk for jk in events.keys() if 'Jet_' in jk]\n",
    "arrays = events.arrays(jet_keys, library=\"ak\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6cadb2b1-f574-40fa-8671-da218c679c1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5e48642-a780-4126-a2c3-a761c665d8ca",
   "metadata": {},
   "source": [
    "For reference, you can also easily convert your collection of arrays into a Pandas DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "151692e7-b4cc-4c0a-ac89-c70183c5c00f",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = events.arrays(jet_keys, library=\"pd\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c3372e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6446c997-26b8-41e6-b454-17e42514ce93",
   "metadata": {},
   "source": [
    "We'll stick with `awkward` and add selections on G and UDS jets to the arrays so that we can distinguish between them later:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce0f4294-aa4d-4d1f-a87e-014bd557dd9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "arrays['Jet_isG'] = ak.where(arrays['Jet_partonFlavour'] == 21, True, False)\n",
    "\n",
    "arrays['Jet_isUDS'] = ak.where(\n",
    "    (np.abs(arrays['Jet_partonFlavour']) == 1) | (np.abs(arrays['Jet_partonFlavour']) == 2) | (np.abs(arrays['Jet_partonFlavour']) == 3),\n",
    "    True, False\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a6b979e-6940-45ee-8b7f-a8d77bb9700f",
   "metadata": {},
   "source": [
    "One of the variables for in the `Jet` object is `Jet_qgl` which is the result of a relatively simple quark/gluon jet classifier which is based on three jet variables (which we describe in more detail in the next notebook). This discriminator assigns a probability of a jet coming from a light quark. Let's plot what it looks like for this NANOAOD sample:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da9746a1-4498-40b8-a9f8-000636b2bddc",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()\n",
    "binning = np.arange(0.0, 1.0, 0.04)\n",
    "\n",
    "plt.hist(\n",
    "    ak.flatten(arrays['Jet_qgl'][ak.where(arrays['Jet_isG'], True, False)]), \n",
    "    bins=binning, alpha=0.8, label='Gluon', density=1 )\n",
    "\n",
    "plt.hist(\n",
    "    ak.flatten(arrays['Jet_qgl'][ak.where(arrays['Jet_isUDS'], True, False)]), \n",
    "    bins=binning, alpha=0.8, label='Quark', density=1 )\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "plt.xlabel('Discriminator output')\n",
    "plt.title('Quark/gluon likelihood');"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ec880cf",
   "metadata": {},
   "source": [
    "We'll return to jet discriminators in the next notebook but before then let's quickly\n",
    "demonstrate how to make some simple selections:\n",
    "\n",
    "* nJets >= 3\n",
    "* jet_pt > 30 GeV\n",
    "* abs(jet_eta) < 2.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f347db5f-f759-4f9f-9204-05808970ad2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "njet_cut = ak.where(\n",
    "    ak.num(arrays['Jet_pt']) >= 3,\n",
    "    True, False\n",
    ") \n",
    "\n",
    "print(njet_cut)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dcdf3818-576d-4782-91ac-e228894facb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "arrays = arrays[njet_cut]\n",
    "\n",
    "pt_cut = ak.all(arrays['Jet_pt'] > 30, axis=1)\n",
    "eta_cut = ak.all(np.abs(arrays['Jet_eta']) < 2.5, axis=1)\n",
    "\n",
    "arrays = arrays[pt_cut & eta_cut]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efc726c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(1, 2, figsize=(20,10))\n",
    "\n",
    "axes[0].hist(ak.flatten(arrays['Jet_pt']), bins=80, range=(0,8000))\n",
    "axes[0].set_xlabel('jet_pt')\n",
    "axes[0].set_yscale('log')\n",
    "\n",
    "axes[1].hist(ak.flatten(arrays['Jet_eta']), bins=100, range=(-6,6))\n",
    "axes[1].set_xlabel('jet_eta')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cba1020f-3caa-4c75-8e0d-63d01f05a03b",
   "metadata": {},
   "source": [
    "## CMS MINIAOD vs NANOAOD\n",
    "\n",
    "Hopefully we've shown some of nice features of NANOAOD including:\n",
    "* it's relatively lightweight\n",
    "* it has a relatively simple structure\n",
    "* it doesn't require complex CMS software for analysis\n",
    "\n",
    "However, you may find that the NANOAOD doesn't have some information that you need for your study. Content-wise, one major difference between NANO and MINIAOD is that MINIAOD contains most of the constituents of a physics object (such as tracks and/or calorimeter clusters) whereas NANOAOD only contains some information about them. \n",
    "If you need this information, you may need either to process MINIAOD directly.\n",
    "\n",
    "Objects in MINIAOD are created as C++ classes in the CMS software framework CMSSW. Analysing MINIAOD requires CMSSW software. CMS provides Docker container images with the appropriate CMS software environment as well as example code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1b298ca-4622-4de1-ae22-62c846f86d0f",
   "metadata": {},
   "source": [
    "From the [NANOAOD dataset record](https://opendata.cern.ch/record/63168) we can find the [MINIAOD parent dataset](https://opendata.cern.ch/record/63167) from which the NANOAOD was derived.\n",
    "\n",
    "From this record we see which Docker container we can use to analyze this data:\n",
    "\n",
    "![docker miniaod](imgs/docker-miniaod.png)\n",
    "\n",
    "Analysis of MINIAOD is beyond the scope of this notebook-based tutorial but would be worth checking out [this guide](https://opendata.cern.ch/docs/cms-getting-started-miniaod) to getting started with MINIAOD.\n",
    "\n",
    "If one does open one a MINIAOD root file in the CMSSW Docker container one can inspect the structure of the format like so:\n",
    "\n",
    "```\n",
    "(/code/CMSSW_10_6_30/src) edmDumpEventContent root://eospublic.cern.ch//eos/opendata/cms/mc/RunIISummer20UL16MiniAODv2/QCD_Pt-15to7000_TuneCP5_Flat2018_13TeV_pythia8/MINIAODSIM/106X_mcRun2_asymptotic_v17-v1/130000/1092DDD2-A0E6-DE47-8E72-807987BC5F99.root\n",
    "Type                                  Module                      Label             Process\n",
    "----------------------------------------------------------------------------------------------\n",
    "edm::TriggerResults                   \"TriggerResults\"            \"\"                \"HLT\"\n",
    "BXVector<GlobalAlgBlk>                \"gtStage2Digis\"             \"\"                \"RECO\"\n",
    "BXVector<GlobalExtBlk>                \"gtStage2Digis\"             \"\"                \"RECO\"\n",
    "BXVector<l1t::EGamma>                 \"caloStage2Digis\"           \"EGamma\"          \"RECO\"\n",
    "BXVector<l1t::EtSum>                  \"caloStage2Digis\"           \"EtSum\"           \"RECO\"\n",
    "BXVector<l1t::Jet>                    \"caloStage2Digis\"           \"Jet\"             \"RECO\"\n",
    "BXVector<l1t::Muon>                   \"gmtStage2Digis\"            \"Muon\"            \"RECO\"\n",
    "BXVector<l1t::Tau>                    \"caloStage2Digis\"           \"Tau\"             \"RECO\"\n",
    "HcalNoiseSummary                      \"hcalnoise\"                 \"\"                \"RECO\"\n",
    "L1GlobalTriggerReadoutRecord          \"gtDigis\"                   \"\"                \"RECO\"\n",
    "double                                \"fixedGridRhoAll\"           \"\"                \"RECO\"\n",
    "double                                \"fixedGridRhoFastjetAll\"    \"\"                \"RECO\"\n",
    "double                                \"fixedGridRhoFastjetAllCalo\"   \"\"                \"RECO\"\n",
    "double                                \"fixedGridRhoFastjetAllTmp\"   \"\"                \"RECO\"\n",
    "double                                \"fixedGridRhoFastjetCentral\"   \"\"                \"RECO\"\n",
    "double                                \"fixedGridRhoFastjetCentralCalo\"   \"\"                \"RECO\"\n",
    "double                                \"fixedGridRhoFastjetCentralChargedPileUp\"   \"\"                \"RECO\"\n",
    "double                                \"fixedGridRhoFastjetCentralNeutral\"   \"\"                \"RECO\"\n",
    "edm::TriggerResults                   \"TriggerResults\"            \"\"                \"RECO\"\n",
    "reco::BeamHaloSummary                 \"BeamHaloSummary\"           \"\"                \"RECO\"\n",
    "reco::BeamSpot                        \"offlineBeamSpot\"           \"\"                \"RECO\"\n",
    "reco::CSCHaloData                     \"CSCHaloData\"               \"\"                \"RECO\"\n",
    "vector<CTPPSLocalTrackLite>           \"ctppsLocalTrackLiteProducer\"   \"\"                \"RECO\"\n",
    "vector<LumiScalers>                   \"scalersRawToDigi\"          \"\"                \"RECO\"\n",
    "vector<l1extra::L1EmParticle>         \"l1extraParticles\"          \"Isolated\"        \"RECO\"\n",
    "vector<l1extra::L1EmParticle>         \"l1extraParticles\"          \"NonIsolated\"     \"RECO\"\n",
    "vector<l1extra::L1EtMissParticle>     \"l1extraParticles\"          \"MET\"             \"RECO\"\n",
    "vector<l1extra::L1EtMissParticle>     \"l1extraParticles\"          \"MHT\"             \"RECO\"\n",
    "vector<l1extra::L1HFRings>            \"l1extraParticles\"          \"\"                \"RECO\"\n",
    "vector<l1extra::L1JetParticle>        \"l1extraParticles\"          \"Central\"         \"RECO\"\n",
    "vector<l1extra::L1JetParticle>        \"l1extraParticles\"          \"Forward\"         \"RECO\"\n",
    "vector<l1extra::L1JetParticle>        \"l1extraParticles\"          \"IsoTau\"          \"RECO\"\n",
    "vector<l1extra::L1JetParticle>        \"l1extraParticles\"          \"Tau\"             \"RECO\"\n",
    "vector<l1extra::L1MuonParticle>       \"l1extraParticles\"          \"\"                \"RECO\"\n",
    "vector<reco::Conversion>              \"gsfTracksOpenConversions\"   \"gsfTracksOpenConversions\"   \"RECO\"\n",
    "vector<reco::ForwardProton>           \"ctppsProtons\"              \"multiRP\"         \"RECO\"\n",
    "vector<reco::ForwardProton>           \"ctppsProtons\"              \"singleRP\"        \"RECO\"\n",
    "vector<reco::Track>                   \"displacedStandAloneMuons\"   \"\"                \"RECO\"\n",
    "BXVector<GlobalExtBlk>                \"simGtExtUnprefireable\"     \"\"                \"PAT\"\n",
    "double                                \"prefiringweight\"           \"nonPrefiringProb\"   \"PAT\"\n",
    "double                                \"prefiringweight\"           \"nonPrefiringProbDown\"   \"PAT\"\n",
    "double                                \"prefiringweight\"           \"nonPrefiringProbUp\"   \"PAT\"\n",
    "edm::Association<vector<reco::DeDxHitInfo> >    \"isolatedTracks\"            \"\"                \"PAT\"\n",
    "edm::OwnVector<TrackingRecHit,edm::ClonePolicy<TrackingRecHit> >    \"slimmedMuonTrackExtras\"    \"\"                \"PAT\"\n",
    "edm::OwnVector<reco::BaseTagInfo,edm::ClonePolicy<reco::BaseTagInfo> >    \"slimmedJetsPuppi\"          \"tagInfos\"        \"PAT\"\n",
    "edm::RangeMap<CSCDetId,edm::OwnVector<CSCSegment,edm::ClonePolicy<CSCSegment> >,edm::ClonePolicy<CSCSegment> >    \"slimmedMuons\"              \"\"                \"PAT\"\n",
    "edm::RangeMap<DTChamberId,edm::OwnVector<DTRecSegment4D,edm::ClonePolicy<DTRecSegment4D> >,edm::ClonePolicy<DTRecSegment4D> >    \"slimmedMuons\"              \"\"\n",
    "\"PAT\"\n",
    "edm::SortedCollection<EcalRecHit,edm::StrictWeakOrdering<EcalRecHit> >    \"reducedEgamma\"             \"reducedEBRecHits\"   \"PAT\"\n",
    "edm::SortedCollection<EcalRecHit,edm::StrictWeakOrdering<EcalRecHit> >    \"reducedEgamma\"             \"reducedEERecHits\"   \"PAT\"\n",
    "edm::SortedCollection<EcalRecHit,edm::StrictWeakOrdering<EcalRecHit> >    \"reducedEgamma\"             \"reducedESRecHits\"   \"PAT\"\n",
    "edm::SortedCollection<HBHERecHit,edm::StrictWeakOrdering<HBHERecHit> >    \"reducedEgamma\"             \"reducedHBHEHits\"   \"PAT\"\n",
    "edm::SortedCollection<HBHERecHit,edm::StrictWeakOrdering<HBHERecHit> >    \"slimmedHcalRecHits\"        \"reducedHcalRecHits\"   \"PAT\"\n",
    "edm::SortedCollection<HFRecHit,edm::StrictWeakOrdering<HFRecHit> >    \"slimmedHcalRecHits\"        \"reducedHcalRecHits\"   \"PAT\"\n",
    "edm::SortedCollection<HORecHit,edm::StrictWeakOrdering<HORecHit> >    \"slimmedHcalRecHits\"        \"reducedHcalRecHits\"   \"PAT\"\n",
    "edm::TriggerResults                   \"TriggerResults\"            \"\"                \"PAT\"\n",
    "edm::ValueMap<float>                  \"offlineSlimmedPrimaryVertices\"   \"\"                \"PAT\"\n",
    "pat::PackedTriggerPrescales           \"patTrigger\"                \"\"                \"PAT\"\n",
    "pat::PackedTriggerPrescales           \"patTrigger\"                \"l1max\"           \"PAT\"\n",
    "pat::PackedTriggerPrescales           \"patTrigger\"                \"l1min\"           \"PAT\"\n",
    "vector<CTPPSLocalTrackLite>           \"ctppsLocalTrackLiteProducer\"   \"\"                \"PAT\"\n",
    "vector<pat::CompositeCandidate>       \"oniaPhotonCandidates\"      \"conversions\"     \"PAT\"\n",
    "vector<pat::Electron>                 \"slimmedElectrons\"          \"\"                \"PAT\"\n",
    "vector<pat::Electron>                 \"slimmedLowPtElectrons\"     \"\"                \"PAT\"\n",
    "vector<pat::IsolatedTrack>            \"isolatedTracks\"            \"\"                \"PAT\"\n",
    "vector<pat::Jet>                      \"slimmedJets\"               \"\"                \"PAT\"\n",
    "vector<pat::Jet>                      \"slimmedJetsAK8\"            \"\"                \"PAT\"\n",
    "vector<pat::Jet>                      \"slimmedJetsPuppi\"          \"\"                \"PAT\"\n",
    "vector<pat::Jet>                      \"slimmedJetsAK8PFPuppiSoftDropPacked\"   \"SubJets\"         \"PAT\"\n",
    "vector<pat::MET>                      \"slimmedMETs\"               \"\"                \"PAT\"\n",
    "vector<pat::MET>                      \"slimmedMETsNoHF\"           \"\"                \"PAT\"\n",
    "vector<pat::MET>                      \"slimmedMETsPuppi\"          \"\"                \"PAT\"\n",
    "vector<pat::Muon>                     \"slimmedMuons\"              \"\"                \"PAT\"\n",
    "vector<pat::PackedCandidate>          \"lostTracks\"                \"\"                \"PAT\"\n",
    "vector<pat::PackedCandidate>          \"packedPFCandidates\"        \"\"                \"PAT\"\n",
    "vector<pat::PackedCandidate>          \"lostTracks\"                \"eleTracks\"       \"PAT\"\n",
    "vector<pat::Photon>                   \"slimmedOOTPhotons\"         \"\"                \"PAT\"\n",
    "vector<pat::Photon>                   \"slimmedPhotons\"            \"\"                \"PAT\"\n",
    "vector<pat::Tau>                      \"slimmedTaus\"               \"\"                \"PAT\"\n",
    "vector<pat::Tau>                      \"slimmedTausBoosted\"        \"\"                \"PAT\"\n",
    "vector<pat::TriggerObjectStandAlone>    \"slimmedPatTrigger\"         \"\"                \"PAT\"\n",
    "vector<reco::CaloCluster>             \"reducedEgamma\"             \"reducedEBEEClusters\"   \"PAT\"\n",
    "vector<reco::CaloCluster>             \"reducedEgamma\"             \"reducedESClusters\"   \"PAT\"\n",
    "vector<reco::CaloCluster>             \"reducedEgamma\"             \"reducedOOTEBEEClusters\"   \"PAT\"\n",
    "vector<reco::CaloCluster>             \"reducedEgamma\"             \"reducedOOTESClusters\"   \"PAT\"\n",
    "vector<reco::CaloJet>                 \"slimmedCaloJets\"           \"\"                \"PAT\"\n",
    "vector<reco::Conversion>              \"reducedEgamma\"             \"reducedConversions\"   \"PAT\"\n",
    "vector<reco::Conversion>              \"reducedEgamma\"             \"reducedSingleLegConversions\"   \"PAT\"\n",
    "vector<reco::DeDxHitInfo>             \"isolatedTracks\"            \"\"                \"PAT\"\n",
    "vector<reco::ForwardProton>           \"ctppsProtons\"              \"multiRP\"         \"PAT\"\n",
    "vector<reco::ForwardProton>           \"ctppsProtons\"              \"singleRP\"        \"PAT\"\n",
    "vector<reco::GsfElectronCore>         \"reducedEgamma\"             \"reducedGedGsfElectronCores\"   \"PAT\"\n",
    "vector<reco::GsfTrack>                \"reducedEgamma\"             \"reducedGsfTracks\"   \"PAT\"\n",
    "vector<reco::PhotonCore>              \"reducedEgamma\"             \"reducedGedPhotonCores\"   \"PAT\"\n",
    "vector<reco::PhotonCore>              \"reducedEgamma\"             \"reducedOOTPhotonCores\"   \"PAT\"\n",
    "vector<reco::SuperCluster>            \"reducedEgamma\"             \"reducedOOTSuperClusters\"   \"PAT\"\n",
    "vector<reco::SuperCluster>            \"reducedEgamma\"             \"reducedSuperClusters\"   \"PAT\"\n",
    "vector<reco::TrackExtra>              \"slimmedMuonTrackExtras\"    \"\"                \"PAT\"\n",
    "vector<reco::Vertex>                  \"offlineSlimmedPrimaryVertices\"   \"\"                \"PAT\"\n",
    "vector<reco::VertexCompositePtrCandidate>    \"slimmedKshortVertices\"     \"\"                \"PAT\"\n",
    "vector<reco::VertexCompositePtrCandidate>    \"slimmedLambdaVertices\"     \"\"                \"PAT\"\n",
    "vector<reco::VertexCompositePtrCandidate>    \"slimmedSecondaryVertices\"   \"\"                \"PAT\"\n",
    "vector<string>                        \"slimmedPatTrigger\"         \"filterLabels\"    \"PAT\"\n",
    "unsigned int                          \"bunchSpacingProducer\"      \"\"                \"PAT\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a304a995-a610-414d-9372-0fb2cc1b973c",
   "metadata": {},
   "source": [
    "It is worth mentioning that some NANOAOD samples have been produced from MINAOD that have been enriched with Particle Flow (what's that? See [here](https://cms-opendata-workshop.github.io/workshop2024-lesson-physics-objects/instructor/01-introduction.html) to learn more) information. It would be a useful exercise for the reader to try the workflow described [here](https://opendata.cern.ch/record/12504) to produce your own enhanced NANOAOD and to learn how to make your own customizations."
   ]
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}