Spark_Physics/HEP_benchmark/ADL_HEP_Query_Benchmark_Q7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "38491234",
   "metadata": {},
   "source": [
    "# HEP Benchmark Query Q7\n",
    "\n",
    "This follows the [IRIS-HEP benchmark](https://github.com/iris-hep/adl-benchmarks-index)\n",
    "and the article [Evaluating Query Languages and Systems for High-Energy Physics Data](https://arxiv.org/abs/2104.12615)\n",
    "and provides implementations of the benchmark tasks using Apache Spark.\n",
    "\n",
    "The workload and data:\n",
    "  - Benchmark jobs are implemented according to the [IRIS-HEP benchmark](https://github.com/iris-hep/adl-benchmarks-index)\n",
    "  - The input data is a series of events from CMS opendata\n",
    "  - The job output is typically a histogram \n",
    "  - See also https://github.com/LucaCanali/Miscellaneous/tree/master/Spark_Physics\n",
    "\n",
    "Author and contact: Luca.Canali@cern.ch  \n",
    "February, 2022\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51f4d3b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Download the data if not yet available locally\n",
    "\n",
    "# Download the reduced data set (2 GB)\n",
    "! wget -r -np -R \"index.html*\" -e robots=off https://sparkdltrigger.web.cern.ch/sparkdltrigger/Run2012B_SingleMu_sample.parquet/\n",
    "\n",
    "# This downloads the full dataset (16 GB)\n",
    "# ! wget -r -np -R \"index.html*\" -e robots=off https://sparkdltrigger.web.cern.ch/sparkdltrigger/Run2012B_SingleMu.parquet/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "46147e9d-0c36-4bbb-a4a6-15b87a5b763d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install sparkhistogram\n",
    "! pip install sparkhistogram\n",
    "\n",
    "from sparkhistogram import computeHistogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5a25fca",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start the Spark Session\n",
    "# This uses local mode for simplicity\n",
    "\n",
    "# The use of findspark is optional\n",
    "# import findspark\n",
    "# findspark.init(\"/home/luca/Spark/spark-3.5.1-bin-hadoop3\")\n",
    "\n",
    "from pyspark.sql import SparkSession\n",
    "spark = (SparkSession.builder\n",
    "         .appName(\"HEP benchmark\")\n",
    "         .master(\"local[4]\")\n",
    "         .config(\"spark.driver.memory\", \"4g\")\n",
    "         .getOrCreate()\n",
    "        )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e00f87ee",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- run: integer (nullable = true)\n",
      " |-- luminosityBlock: long (nullable = true)\n",
      " |-- event: long (nullable = true)\n",
      " |-- HLT_IsoMu24_eta2p1: boolean (nullable = true)\n",
      " |-- HLT_IsoMu24: boolean (nullable = true)\n",
      " |-- HLT_IsoMu17_eta2p1_LooseIsoPFTau20: boolean (nullable = true)\n",
      " |-- PV_npvs: integer (nullable = true)\n",
      " |-- PV_x: float (nullable = true)\n",
      " |-- PV_y: float (nullable = true)\n",
      " |-- PV_z: float (nullable = true)\n",
      " |-- nMuon: long (nullable = true)\n",
      " |-- Muon_pt: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Muon_eta: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Muon_phi: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Muon_mass: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Muon_charge: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- Muon_pfRelIso03_all: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Muon_pfRelIso04_all: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Muon_tightId: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Muon_softId: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Muon_dxy: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Muon_dxyErr: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Muon_dz: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Muon_dzErr: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Muon_jetIdx: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- Muon_genPartIdx: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- nElectron: long (nullable = true)\n",
      " |-- Electron_pt: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Electron_eta: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Electron_phi: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Electron_mass: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Electron_charge: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- Electron_pfRelIso03_all: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Electron_dxy: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Electron_dxyErr: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Electron_dz: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Electron_dzErr: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Electron_cutBasedId: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Electron_pfId: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Electron_jetIdx: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- Electron_genPartIdx: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- nTau: long (nullable = true)\n",
      " |-- Tau_pt: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Tau_eta: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Tau_phi: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Tau_mass: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Tau_charge: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- Tau_decayMode: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- Tau_relIso_all: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Tau_jetIdx: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- Tau_genPartIdx: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- Tau_idDecayMode: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Tau_idIsoRaw: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Tau_idIsoVLoose: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Tau_idIsoLoose: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Tau_idIsoMedium: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Tau_idIsoTight: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Tau_idAntiEleLoose: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Tau_idAntiEleMedium: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Tau_idAntiEleTight: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Tau_idAntiMuLoose: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Tau_idAntiMuMedium: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Tau_idAntiMuTight: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- nPhoton: long (nullable = true)\n",
      " |-- Photon_pt: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Photon_eta: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Photon_phi: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Photon_mass: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Photon_charge: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- Photon_pfRelIso03_all: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Photon_jetIdx: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- Photon_genPartIdx: array (nullable = true)\n",
      " |    |-- element: integer (containsNull = true)\n",
      " |-- MET_pt: float (nullable = true)\n",
      " |-- MET_phi: float (nullable = true)\n",
      " |-- MET_sumet: float (nullable = true)\n",
      " |-- MET_significance: float (nullable = true)\n",
      " |-- MET_CovXX: float (nullable = true)\n",
      " |-- MET_CovXY: float (nullable = true)\n",
      " |-- MET_CovYY: float (nullable = true)\n",
      " |-- nJet: long (nullable = true)\n",
      " |-- Jet_pt: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Jet_eta: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Jet_phi: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Jet_mass: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      " |-- Jet_puId: array (nullable = true)\n",
      " |    |-- element: boolean (containsNull = true)\n",
      " |-- Jet_btag: array (nullable = true)\n",
      " |    |-- element: float (containsNull = true)\n",
      "\n",
      "Number of events: 6846198\n"
     ]
    }
   ],
   "source": [
    "# Read data for the benchmark tasks\n",
    "# download data as detailed at https://github.com/LucaCanali/Miscellaneous/tree/master/Spark_Physics\n",
    "\n",
    "path = \"sparkdltrigger.web.cern.ch/sparkdltrigger/\"\n",
    "input_data = \"Run2012B_SingleMu_sample.parquet\"\n",
    "\n",
    "# use this if you downloaded the full dataset\n",
    "# input_data = \"Run2012B_SingleMu.parquet\"\n",
    "\n",
    "df_events = spark.read.parquet(path + input_data)\n",
    "\n",
    "df_events.printSchema()\n",
    "\n",
    "print(f\"Number of events: {df_events.count()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2ec6bb2",
   "metadata": {},
   "source": [
    "# Q7 - Solution 1/2: Use the explode function\n",
    "Plot the scalar sum in each event of the 𝑝𝑇 of the jets with\n",
    "$𝑝_𝑇$ > 30 GeV that are not within 0.4 in Δ𝑅 of any light\n",
    "lepton (i.e., electron or muon) with $𝑝_𝑇$ > 10 GeV.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "09ce3174",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.141592653589793'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "pi = str(math.pi)\n",
    "pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f5621780",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- event: long (nullable = true)\n",
      " |-- Jet: array (nullable = true)\n",
      " |    |-- element: struct (containsNull = false)\n",
      " |    |    |-- Jet_pt: float (nullable = true)\n",
      " |    |    |-- Jet_eta: float (nullable = true)\n",
      " |    |    |-- Jet_phi: float (nullable = true)\n",
      " |-- Electron: array (nullable = true)\n",
      " |    |-- element: struct (containsNull = false)\n",
      " |    |    |-- Electron_pt: float (nullable = true)\n",
      " |    |    |-- Electron_eta: float (nullable = true)\n",
      " |    |    |-- Electron_phi: float (nullable = true)\n",
      " |-- Muon: array (nullable = true)\n",
      " |    |-- element: struct (containsNull = false)\n",
      " |    |    |-- Muon_pt: float (nullable = true)\n",
      " |    |    |-- Muon_eta: float (nullable = true)\n",
      " |    |    |-- Muon_phi: float (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Select and packs the components for\n",
    "# Jet_pt, which contains arrays of jet measurements\n",
    "# Electrons and Muons\n",
    "\n",
    "df_events_q7 = df_events.selectExpr(\"event\",\n",
    "                                    \"arrays_zip(Jet_pt, Jet_eta, Jet_phi) as Jet\",\n",
    "                                    \"arrays_zip(Electron_pt, Electron_eta, Electron_phi) as Electron\",\n",
    "                                    \"arrays_zip(Muon_pt, Muon_eta, Muon_phi) as Muon\")\n",
    "df_events_q7.printSchema()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7ba338af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+------------------------------------+--------+--------------------------------------+\n",
      "|event    |j                                   |Electron|Muon                                  |\n",
      "+---------+------------------------------------+--------+--------------------------------------+\n",
      "|174546626|{28.03698, -2.573142, -0.0039507723}|[]      |[{41.292233, -0.61345077, 0.91725355}]|\n",
      "|174546626|{20.425129, -0.6191127, 2.44285}    |[]      |[{41.292233, -0.61345077, 0.91725355}]|\n",
      "|174546626|{18.646175, 2.5256636, 1.2553711}   |[]      |[{41.292233, -0.61345077, 0.91725355}]|\n",
      "|174546626|{17.995762, -3.8685246, 1.146259}   |[]      |[{41.292233, -0.61345077, 0.91725355}]|\n",
      "|174546626|{17.04349, -3.4595842, 2.2116172}   |[]      |[{41.292233, -0.61345077, 0.91725355}]|\n",
      "+---------+------------------------------------+--------+--------------------------------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Explode the Jet values (from array elements ot table rows)\n",
    "\n",
    "df_events_q7_w1 = df_events_q7.selectExpr(\"event\", \"explode(Jet) as j\", \"Electron\", \"Muon\")\n",
    "\n",
    "df_events_q7_w1.show(5, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "dc70c614",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is not a real UDF, but just a string function that implements\n",
    "# the dimuon mass formula\n",
    "\n",
    "def DeltaR_macro(p0_eta: str, p0_phi: str, p1_eta: str, p1_phi: str) -> str:\n",
    "    result = f\"sqrt( pow( ({p0_eta} - {p1_eta}), 2) + pow( ({p0_phi} - {p1_phi} + {pi}) % (2 * {pi}) - {pi}, 2) )\"\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8256f43b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sqrt( pow( (j.Jet_eta - j.Jet_phi), 2) + pow( (e.Electron_eta - e.Electron_phi + 3.141592653589793) % (2 * 3.141592653589793) - 3.141592653589793, 2) )'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# example of use:\n",
    "\n",
    "f\"{DeltaR_macro('j.Jet_eta', 'e.Electron_eta', 'j.Jet_phi', 'e.Electron_phi')}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "44729569",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filter the events\n",
    "# - only Jets with pt > 30 GeV\n",
    "#  not in .4 in Δ𝑅 of any light lepton (i.e., electron or muon)\n",
    "# additional filter on leptons: 𝑝𝑇 > 10 GeV\n",
    "\n",
    "df_events_q7_w2 = df_events_q7_w1.filter(f\"\"\"\n",
    "j.Jet_pt > 30\n",
    "and not exists( Electron, e -> e.Electron_pt > 10\n",
    "                and {DeltaR_macro('j.Jet_eta', 'e.Electron_eta', 'j.Jet_phi', 'e.Electron_phi')} < 0.4\n",
    "              )                    \n",
    "and not exists( Muon, mu -> mu.Muon_pt > 10\n",
    "                and {DeltaR_macro('j.Jet_eta', 'mu.Muon_eta', 'j.Jet_phi', 'mu.Muon_phi')} < 0.4\n",
    "              )\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f75cf033",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute the sum of Jet_pt per event\n",
    "\n",
    "from pyspark.sql.functions import sum\n",
    "\n",
    "q7 = df_events_q7_w2.groupBy(\"event\").agg(sum(\"j.Jet_pt\").alias(\"summed_jet_pt\"))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "47a4de6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute the histogram of Jet_pt\n",
    "# The Spark function \"width_bucket\" is used to generate the histogram bucket number\n",
    "# a groupBy operation with count is used to fill the histogram\n",
    "# The result is a histogram with bins value and counts foreach bin (N_events)\n",
    "\n",
    "min_val = 15\n",
    "max_val = 200\n",
    "num_bins = 100\n",
    "step = (max_val - min_val) / num_bins\n",
    "\n",
    "# Use the helper function computeHistogram in the package sparkhistogram\n",
    "# The result is a histogram with (summed_jet_pt) bin values and event counts foreach bin\n",
    "histogram_data = computeHistogram(q7, \"summed_jet_pt\", min_val, max_val, num_bins) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a6d6d8ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 355 ms, sys: 42.3 ms, total: 397 ms\n",
      "Wall time: 11.3 s\n"
     ]
    }
   ],
   "source": [
    "# The action toPandas() here triggers the computation.\n",
    "# Histogram data is fetched into the driver as a Pandas Dataframe.\n",
    "\n",
    "%time histogram_data_pandas=histogram_data.toPandas()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2764f680",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "plt.style.use('seaborn-v0_8-darkgrid')\n",
    "plt.rcParams.update({'font.size': 20, 'figure.figsize': [14,10]})\n",
    "\n",
    "# cut the first and last bin\n",
    "x = histogram_data_pandas.iloc[1:-1][\"value\"]\n",
    "y = histogram_data_pandas.iloc[1:-1][\"count\"]\n",
    "\n",
    "# line plot\n",
    "f, ax = plt.subplots()\n",
    "ax.plot(x, y, '-')\n",
    "\n",
    "ax.set_xlabel('Jet_$p_T$ (GeV)')\n",
    "ax.set_ylabel('Number of Events')\n",
    "ax.set_title(\"Distribution of Sum Jet_$p_T$ \")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d450bf2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e48048b8",
   "metadata": {},
   "source": [
    "# Q7 - Solution 2: Use Spark higher order functions for array processing\n",
    "Plot the scalar sum in each event of the 𝑝𝑇 of the jets with\n",
    "$𝑝_𝑇$ > 30 GeV that are not within 0.4 in Δ𝑅 of any light\n",
    "lepton (i.e., electron or muon) with $𝑝_𝑇$ > 10 GeV.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "99ba3190",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- event: long (nullable = true)\n",
      " |-- Jet: array (nullable = true)\n",
      " |    |-- element: struct (containsNull = false)\n",
      " |    |    |-- Jet_pt: float (nullable = true)\n",
      " |    |    |-- Jet_eta: float (nullable = true)\n",
      " |    |    |-- Jet_phi: float (nullable = true)\n",
      " |-- Electron: array (nullable = true)\n",
      " |    |-- element: struct (containsNull = false)\n",
      " |    |    |-- Electron_pt: float (nullable = true)\n",
      " |    |    |-- Electron_eta: float (nullable = true)\n",
      " |    |    |-- Electron_phi: float (nullable = true)\n",
      " |-- Muon: array (nullable = true)\n",
      " |    |-- element: struct (containsNull = false)\n",
      " |    |    |-- Muon_pt: float (nullable = true)\n",
      " |    |    |-- Muon_eta: float (nullable = true)\n",
      " |    |    |-- Muon_phi: float (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Select and packs the components for\n",
    "# Jet_pt, which contains arrays of jet measurements\n",
    "# Electrons and Muons\n",
    "\n",
    "df_events_q7 = df_events.selectExpr(\"event\",\n",
    "                                    \"arrays_zip(Jet_pt, Jet_eta, Jet_phi) as Jet\",\n",
    "                                    \"arrays_zip(Electron_pt, Electron_eta, Electron_phi) as Electron\",\n",
    "                                    \"arrays_zip(Muon_pt, Muon_eta, Muon_phi) as Muon\")\n",
    "df_events_q7.printSchema()\n",
    "#df_events_q7.show(10, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a2328504",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is not a real UDF, but just a string function that implements\n",
    "# the dimuon mass formula\n",
    "\n",
    "def DeltaR_macro(p0_eta: str, p0_phi: str, p1_eta: str, p1_phi: str) -> str:\n",
    "    result = f\"sqrt( pow( ({p0_eta} - {p1_eta}), 2) + pow( ({p0_phi} - {p1_phi} + {pi}) % (2 * {pi}) - {pi}, 2) )\"\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "219ea36f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filter the events\n",
    "# - only Jets with pt > 30 GeV\n",
    "#  not in .4 in Δ𝑅 of any light lepton (i.e., electron or muon)\n",
    "# additional filter on leptons: 𝑝𝑇 > 10 GeV\n",
    "\n",
    "q7_filtered = df_events_q7.selectExpr(\"event\", f\"\"\"\n",
    "filter(Jet, j -> j.Jet_pt > 30\n",
    "       and not exists( Electron, e -> e.Electron_pt > 10\n",
    "                       and {DeltaR_macro('j.Jet_eta', 'e.Electron_eta', 'j.Jet_phi', 'e.Electron_phi')} < 0.4\n",
    "                     )\n",
    "       and not exists( Muon, mu -> mu.Muon_pt > 10\n",
    "                       and {DeltaR_macro('j.Jet_eta', 'mu.Muon_eta', 'j.Jet_phi', 'mu.Muon_phi')} < 0.4\n",
    "                     )\n",
    ") Jet_Filtered\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "bd0dc24c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- event: long (nullable = true)\n",
      " |-- summed_jet_pt: float (nullable = true)\n",
      "\n",
      "+---------+-------------+\n",
      "|event    |summed_jet_pt|\n",
      "+---------+-------------+\n",
      "|174634270|44.719715    |\n",
      "|174663998|69.16882     |\n",
      "|174711732|218.39832    |\n",
      "|174768173|30.949333    |\n",
      "|174913239|205.90196    |\n",
      "+---------+-------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Compute the sum of Jet_pt \n",
    "# This uses Spark's higher order function for array processing\n",
    "# The sum is pushed as a reduce operation into Jet_pt arrays\n",
    "\n",
    "q7 = q7_filtered.selectExpr(\"event\", \"aggregate(Jet_Filtered.Jet_pt, 0.0f, (acc, j) -> acc + j) as summed_jet_pt\").filter(\"summed_jet_pt>0.0\")\n",
    "\n",
    "q7.printSchema()\n",
    "q7.show(5, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "530f625a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute the histogram of Jet_pt\n",
    "# The Spark function \"width_bucket\" is used to generate the histogram bucket number\n",
    "# a groupBy operation with count is used to fill the histogram\n",
    "# The result is a histogram with bins value and counts foreach bin (N_events)\n",
    "\n",
    "min_val = 15\n",
    "max_val = 200\n",
    "num_bins = 100\n",
    "step = (max_val - min_val) / num_bins\n",
    "\n",
    "# Use the helper function computeHistogram in the package sparkhistogram\n",
    "# The result is a histogram with (summed_jet_pt) bin values and event counts foreach bin\n",
    "histogram_data = computeHistogram(q7, \"summed_jet_pt\", min_val, max_val, num_bins) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "f268ba7c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 20.9 ms, sys: 6.13 ms, total: 27 ms\n",
      "Wall time: 17.8 s\n"
     ]
    }
   ],
   "source": [
    "# The action toPandas() here triggers the computation.\n",
    "# Histogram data is fetched into the driver as a Pandas Dataframe.\n",
    "\n",
    "%time histogram_data_pandas=histogram_data.toPandas()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3d8750cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "plt.style.use('seaborn-v0_8-darkgrid')\n",
    "plt.rcParams.update({'font.size': 20, 'figure.figsize': [14,10]})\n",
    "\n",
    "# cut the first and last bin\n",
    "x = histogram_data_pandas.iloc[1:-1][\"value\"]\n",
    "y = histogram_data_pandas.iloc[1:-1][\"count\"]\n",
    "\n",
    "# line plot\n",
    "f, ax = plt.subplots()\n",
    "ax.plot(x, y, '-')\n",
    "\n",
    "ax.set_xlabel('Jet_$p_T$ (GeV)')\n",
    "ax.set_ylabel('Number of Events')\n",
    "ax.set_title(\"Distribution of Sum Jet_$p_T$ \")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "d04bbda1",
   "metadata": {},
   "outputs": [],
   "source": [
    "spark.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5a44a39",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}