{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "13f819cb",
   "metadata": {},
   "source": [
    "Side note: we are evaluating particle level information\n",
    "maybe we should also do the event level information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ba38b25a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/billyli/miniforge_x86_new/lib/python3.9/site-packages/coffea/util.py:154: FutureWarning: In coffea version v0.8.0 (target date: 31 Dec 2022), this will be an error.\n",
      "(Set coffea.deprecations_as_errors = True to get a stack trace now.)\n",
      "ImportError: coffea.hist is deprecated\n",
      "  warnings.warn(message, FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "import logging\n",
    "from pathlib import Path\n",
    "import numba as nb\n",
    "\n",
    "import awkward as ak\n",
    "import click\n",
    "import h5py as h5\n",
    "import numpy as np\n",
    "import vector\n",
    "\n",
    "from coffea.hist.plot import clopper_pearson_interval\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# from src.data.cms.convert_to_h5 import MIN_JETS, N_JETS, N_FJETS\n",
    "\n",
    "vector.register_awkward()\n",
    "\n",
    "logging.basicConfig(level=logging.INFO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "11586b69",
   "metadata": {},
   "outputs": [],
   "source": [
    "# read test target file\n",
    "test_file = \"//Users/billyli/UCSD/hhh/reports/bv2/hhh_test.h5\"\n",
    "test_h5 = h5.File(test_file)\n",
    "\n",
    "# read spanet prediction\n",
    "spanet_file = \"//Users/billyli/UCSD/hhh/reports/bv2/dp_on/pred_v53.h5\"\n",
    "s_h5 = h5.File(spanet_file)\n",
    "\n",
    "# read baseline prediction\n",
    "baseline_file = \"//Users/billyli/UCSD/hhh/reports/bv2/pred_baseline.h5\"\n",
    "b_h5 = h5.File(baseline_file)\n",
    "\n",
    "# read spanet prediction\n",
    "pb_off_file = \"//Users/billyli/UCSD/hhh/reports/bv2/bi_input_v0.h5\"\n",
    "pb_h5 = h5.File(pb_off_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed6167b0",
   "metadata": {},
   "source": [
    "### Reco Boosted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3dee6df4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sel_pred_bH_by_dp(dps, aps, bb_ps, dp_cut, ap_cut=1/13):\n",
    "    # parse predicted bb assignment by DP\n",
    "    dp_filter = dps>dp_cut\n",
    "    ap_filter = aps>ap_cut\n",
    "    ak8_filter = bb_ps>9\n",
    "    filter = dp_filter&ak8_filter\n",
    "    \n",
    "    bb_ps_passed = bb_ps.mask[filter]\n",
    "    bb_ps_passed = ak.drop_none(bb_ps_passed)\n",
    "    \n",
    "    return bb_ps_passed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "51a6c71b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sel_target_bH_by_mask(bb_ts, bh_pts, bh_masks):\n",
    "    bb_ts_selected = bb_ts.mask[bh_masks]\n",
    "    bb_ts_selected = ak.drop_none(bb_ts_selected)\n",
    "    \n",
    "    bh_selected_pts = bh_pts.mask[bh_masks]\n",
    "    bh_selected_pts = ak.drop_none(bh_selected_pts)\n",
    "    \n",
    "    return bb_ts_selected, bh_selected_pts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8e1c2469",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A pred look up table is in shape\n",
    "# [event,\n",
    "#    pred_H, \n",
    "#       [correct, pred_H_pt]]\n",
    "def gen_pred_bH_LUT(bb_ps_passed, bb_ts_selected, fj_pts):\n",
    "    LUT = []\n",
    "    # for each event\n",
    "    for bb_t_event, bb_p_event, fj_pt_event in zip(bb_ts_selected, bb_ps_passed, fj_pts):\n",
    "        # for each predicted bb assignment, check if any target H have a same bb assignment\n",
    "        LUT_event = []\n",
    "        for i, bb_p in enumerate(bb_p_event):\n",
    "            correct = 0\n",
    "            predH_pt = fj_pt_event[bb_p-10]\n",
    "            for bb_t in bb_t_event:\n",
    "                if bb_p == bb_t+10:\n",
    "                    correct = 1\n",
    "            LUT_event.append([correct, predH_pt])\n",
    "        LUT.append(LUT_event)\n",
    "    return LUT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f497215f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A target look up table is in shape\n",
    "# [event,\n",
    "#    target_H, \n",
    "#        target_bb_assign,\n",
    "#           [retrieved, targetH_pt]]\n",
    "def gen_target_bH_LUT(bb_ps_passed, bb_ts_selected, targetH_pts):\n",
    "    LUT = []\n",
    "    # for each event\n",
    "    for bb_t_event, bb_p_event, targetH_pts_event in zip(bb_ts_selected, bb_ps_passed, targetH_pts):\n",
    "        # for each target fatjet, check if the predictions have a p fatject same with the t fatjet\n",
    "        LUT_event = []\n",
    "        for i, bb_t in enumerate(bb_t_event):\n",
    "            retrieved = 0\n",
    "            targetH_pt = targetH_pts_event[i]\n",
    "            for bb_p in bb_p_event:\n",
    "                if bb_p == bb_t+10:\n",
    "                    retrieved = 1\n",
    "            LUT_event.append([retrieved, targetH_pt])\n",
    "        LUT.append(LUT_event)\n",
    "    return LUT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3d4c78fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate pred/target LUT\n",
    "# each entry corresponds to [recoH correct or not, reco H pt]\n",
    "# or \n",
    "# [targetH retrieved or not, target H pt]\n",
    "def parse_boosted_w_target(testfile, predfile, dp_cut=0.8):\n",
    "    # Collect H pt, mask, target and predicted jet and fjets for 3 Hs in each event\n",
    "    # h pt\n",
    "    bh1_pt = np.array(testfile['TARGETS']['bh1']['pt'])\n",
    "    bh2_pt = np.array(testfile['TARGETS']['bh2']['pt'])\n",
    "    bh3_pt = np.array(testfile['TARGETS']['bh3']['pt'])\n",
    "\n",
    "    # mask\n",
    "    bh1_mask = np.array(testfile['TARGETS']['bh1']['mask'])\n",
    "    bh2_mask = np.array(testfile['TARGETS']['bh2']['mask'])\n",
    "    bh3_mask = np.array(testfile['TARGETS']['bh3']['mask'])\n",
    "\n",
    "    # target assignment\n",
    "    bb_bh1_t = np.array(testfile[\"TARGETS\"][\"bh1\"]['bb'])\n",
    "    bb_bh2_t = np.array(testfile[\"TARGETS\"][\"bh2\"]['bb'])\n",
    "    bb_bh3_t = np.array(testfile[\"TARGETS\"][\"bh3\"]['bb'])\n",
    "\n",
    "    try:\n",
    "        # pred assignment\n",
    "        bb_bh1_p = np.array(predfile[\"TARGETS\"][\"bh1\"]['bb'])\n",
    "        bb_bh2_p = np.array(predfile[\"TARGETS\"][\"bh2\"]['bb'])\n",
    "        bb_bh3_p = np.array(predfile[\"TARGETS\"][\"bh3\"]['bb'])\n",
    "    \n",
    "        # boosted Higgs detection probability\n",
    "        dp_bh1 = np.array(predfile[\"TARGETS\"][\"bh1\"]['detection_probability'])\n",
    "        dp_bh2 = np.array(predfile[\"TARGETS\"][\"bh2\"]['detection_probability'])\n",
    "        dp_bh3 = np.array(predfile[\"TARGETS\"][\"bh3\"]['detection_probability'])\n",
    "\n",
    "        # fatjet assignment probability\n",
    "        ap_bh1 = np.array(predfile[\"TARGETS\"][\"bh1\"]['assignment_probability'])\n",
    "        ap_bh2 = np.array(predfile[\"TARGETS\"][\"bh2\"]['assignment_probability'])\n",
    "        ap_bh3 = np.array(predfile[\"TARGETS\"][\"bh3\"]['assignment_probability'])\n",
    "    except:\n",
    "        # pred assignment\n",
    "        bb_bh1_p = np.array(predfile[\"TARGETS\"][\"bh1\"]['bb'])+10\n",
    "        bb_bh2_p = np.array(predfile[\"TARGETS\"][\"bh2\"]['bb'])+10\n",
    "        bb_bh3_p = np.array(predfile[\"TARGETS\"][\"bh3\"]['bb'])+10\n",
    "    \n",
    "         # boosted Higgs detection probability\n",
    "        dp_bh1 = np.array(predfile[\"TARGETS\"][\"bh1\"]['mask']).astype('float')\n",
    "        dp_bh2 = np.array(predfile[\"TARGETS\"][\"bh2\"]['mask']).astype('float')\n",
    "        dp_bh3 = np.array(predfile[\"TARGETS\"][\"bh3\"]['mask']).astype('float')\n",
    "\n",
    "        # fatjet assignment probability\n",
    "        ap_bh1 = np.array(predfile[\"TARGETS\"][\"bh1\"]['mask']).astype('float')\n",
    "        ap_bh2 = np.array(predfile[\"TARGETS\"][\"bh2\"]['mask']).astype('float')\n",
    "        ap_bh3 = np.array(predfile[\"TARGETS\"][\"bh3\"]['mask']).astype('float')\n",
    "    \n",
    "    # collect fatjet pt\n",
    "    fj_pt = np.array(testfile['INPUTS']['BoostedJets']['fj_pt'])\n",
    "    \n",
    "    # convert some arrays to ak array\n",
    "    dps = np.concatenate((dp_bh1.reshape(-1, 1), dp_bh2.reshape(-1, 1), dp_bh3.reshape(-1, 1)), axis=1)\n",
    "    dps = ak.Array(dps)\n",
    "    aps = np.concatenate((ap_bh1.reshape(-1, 1), ap_bh2.reshape(-1, 1), ap_bh3.reshape(-1, 1)), axis=1)\n",
    "    aps = ak.Array(aps)\n",
    "    bb_ps = np.concatenate((bb_bh1_p.reshape(-1, 1), bb_bh2_p.reshape(-1, 1), bb_bh3_p.reshape(-1, 1)), axis=1)\n",
    "    bb_ps = ak.Array(bb_ps)\n",
    "    bb_ts = np.concatenate((bb_bh1_t.reshape(-1, 1), bb_bh2_t.reshape(-1, 1), bb_bh3_t.reshape(-1, 1)), axis=1)\n",
    "    bb_ts = ak.Array(bb_ts)\n",
    "    fj_pt = ak.Array(fj_pt)\n",
    "    bh_masks = np.concatenate((bh1_mask.reshape(-1, 1), bh2_mask.reshape(-1, 1), bh3_mask.reshape(-1, 1)), axis=1)\n",
    "    bh_masks = ak.Array(bh_masks)\n",
    "    bh_pts = np.concatenate((bh1_pt.reshape(-1, 1), bh2_pt.reshape(-1, 1), bh3_pt.reshape(-1, 1)), axis=1)\n",
    "    bh_pts = ak.Array(bh_pts)\n",
    "    \n",
    "    # select predictions and targets\n",
    "    bb_ts_selected, targetH_selected_pts = sel_target_bH_by_mask(bb_ts, bh_pts, bh_masks)\n",
    "    bb_ps_selected = sel_pred_bH_by_dp(dps, aps, bb_ps, dp_cut)\n",
    "    \n",
    "    # generate correct/retrieved LUT for pred/target respectively\n",
    "    LUT_pred = gen_pred_bH_LUT(bb_ps_selected, bb_ts_selected, fj_pt)\n",
    "    LUT_target = gen_target_bH_LUT(bb_ps_selected, bb_ts_selected, targetH_selected_pts)\n",
    "    \n",
    "    # reconstruct bH to remove overlapped ak4 jets\n",
    "    fj_eta = np.array(testfile['INPUTS']['BoostedJets']['fj_eta'])\n",
    "    fj_phi = np.array(testfile['INPUTS']['BoostedJets']['fj_phi'])\n",
    "    fj_mass = np.array(testfile['INPUTS']['BoostedJets']['fj_mass'])\n",
    "    \n",
    "    fjs = ak.zip(\n",
    "        {\n",
    "            \"pt\": fj_pt,\n",
    "            \"eta\": fj_eta,\n",
    "            \"phi\": fj_phi,\n",
    "            \"mass\": fj_mass,\n",
    "        },\n",
    "        with_name=\"Momentum4D\"\n",
    "    )\n",
    "    fj_reco = fjs[bb_ps_selected-10]\n",
    "    \n",
    "    return LUT_pred, LUT_target, fj_reco"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "52eadffa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_unoverlapped_jet_index(fjs, js, dR_min=0.8):\n",
    "    overlapped = ak.sum(js[:, np.newaxis].deltaR(fjs)<dR_min, axis=-2)>0\n",
    "    jet_index_passed = ak.local_index(js).mask[~overlapped]\n",
    "    jet_index_passed = ak.drop_none(jet_index_passed)\n",
    "    return jet_index_passed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e3896b0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sel_pred_h_by_dp(dps, aps, b1_ps, b2_ps, dp_cut=0.0, ap_cut=0):\n",
    "    # parse predicted bb assignment by DP\n",
    "    dp_filter = dps > dp_cut\n",
    "    ap_filter = aps > ap_cut\n",
    "    b1_ak4_filter = b1_ps<10\n",
    "    b2_ak4_filter = b2_ps<10\n",
    "    filter = dp_filter & ap_filter & b1_ak4_filter & b2_ak4_filter\n",
    "    \n",
    "    b1_ps_passed = b1_ps.mask[filter]\n",
    "    b1_ps_passed = ak.drop_none(b1_ps_passed)\n",
    "    \n",
    "    b2_ps_passed = b2_ps.mask[filter]\n",
    "    b2_ps_passed = ak.drop_none(b2_ps_passed)\n",
    "    \n",
    "    return b1_ps_passed, b2_ps_passed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4bcac1c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sel_target_h_by_mask(b1_ts, b2_ts, h_pts, bi_cat_H, h_masks):\n",
    "    b1_ts_selected = b1_ts.mask[h_masks]\n",
    "    b1_ts_selected = ak.drop_none(b1_ts_selected)\n",
    "    \n",
    "    b2_ts_selected = b2_ts.mask[h_masks]\n",
    "    b2_ts_selected = ak.drop_none(b2_ts_selected)\n",
    "    \n",
    "    h_selected_pts = h_pts.mask[h_masks]\n",
    "    h_selected_pts = ak.drop_none(h_selected_pts)\n",
    "    \n",
    "    bi_cat_H_passed = bi_cat_H.mask[h_masks]\n",
    "    bi_cat_H_passed = ak.drop_none(bi_cat_H_passed)\n",
    "    \n",
    "    return b1_ts_selected, b2_ts_selected, h_selected_pts, bi_cat_H_passed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6b54c1ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A pred look up table is in shape\n",
    "# [event,\n",
    "#    pred_H, \n",
    "#       [correct_or_not, pt, overlap_w_H_reco, has_boost_H_target, which_H_target]]\n",
    "@nb.njit\n",
    "def gen_pred_h_LUT(b1_ps_passed, b2_ps_passed, b1_ts_selected, b2_ts_selected, js, goodJetIdx, bi_cat_H_selected, builder):\n",
    "    # for each event\n",
    "    for b1_ps_e, b2_ps_e, b1_ts_e, b2_ts_e, jets_e, goodJetIdx_e, bi_cat_H_e in zip(b1_ps_passed, b2_ps_passed, b1_ts_selected, b2_ts_selected, js, goodJetIdx, bi_cat_H_selected):\n",
    "        # for each predicted bb assignment, check if any target H have a same bb assignment\n",
    "        builder.begin_list()\n",
    "        for b1_p, b2_p in zip(b1_ps_e, b2_ps_e):\n",
    "            if (b1_p in goodJetIdx_e) and (b2_p in goodJetIdx_e):\n",
    "                overlap = 0\n",
    "            else:\n",
    "                overlap = 1\n",
    "            correct = 0\n",
    "            has_t_bH = -1\n",
    "            bH = -1\n",
    "            \n",
    "            predH_pt = (jets_e[b1_p]+jets_e[b2_p]).pt\n",
    "            \n",
    "\n",
    "            \n",
    "            \n",
    "            \n",
    "            for i, (b1_t, b2_t, bi_cat_H) in enumerate(zip(b1_ts_e, b2_ts_e, bi_cat_H_e)):\n",
    "                if set((b1_p, b2_p)) == set((b1_t, b2_t)):\n",
    "                    correct = 1\n",
    "                    has_t_bH = bi_cat_H\n",
    "                    bH = i\n",
    "                    \n",
    "            builder.begin_list()\n",
    "            builder.append(correct)\n",
    "            builder.append(predH_pt)\n",
    "            builder.append(overlap)\n",
    "            builder.append(has_t_bH)\n",
    "            builder.append(bH)\n",
    "            builder.append(b1_p)\n",
    "            builder.append(b2_p)\n",
    "            builder.end_list()\n",
    "        \n",
    "        builder.end_list()\n",
    "    return builder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "38a62113",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A target look up table is in shape\n",
    "# [event,\n",
    "#    target_H, \n",
    "#        target_bb_assign,\n",
    "#           [retrieved, targetH_pt, can_boost_reco]]\n",
    "@nb.njit\n",
    "def gen_target_h_LUT(b1_ps_passed, b2_ps_passed, b1_ts_selected, b2_ts_selected, targetH_pts, bi_cat_H_selected, builder):\n",
    "    # for each event\n",
    "    for b1_ps_e, b2_ps_e, b1_ts_e, b2_ts_e, tH_pts_e, bi_cat_H_e in zip(b1_ps_passed, b2_ps_passed, b1_ts_selected, b2_ts_selected, targetH_pts, bi_cat_H_selected):\n",
    "        # for each target fatjet, check if the predictions have a p fatject same with the t fatjet\n",
    "        builder.begin_list()\n",
    "        for b1_t, b2_t, tH_pt, bi_cat_H in zip(b1_ts_e, b2_ts_e, tH_pts_e, bi_cat_H_e):\n",
    "            retrieved = 0\n",
    "            can_boost_reco = bi_cat_H\n",
    "            for b1_p, b2_p in zip(b1_ps_e, b2_ps_e):\n",
    "                if set((b1_p, b2_p)) == set((b1_t, b2_t)):\n",
    "                    retrieved = 1\n",
    "            builder.begin_list()\n",
    "            builder.append(retrieved)\n",
    "            builder.append(tH_pt)\n",
    "            builder.append(can_boost_reco)\n",
    "            builder.end_list()\n",
    "        \n",
    "        builder.end_list()\n",
    "    return builder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "135e1e4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_resolved_w_target(testfile, predfile, dp_cut=0.5, fjs_reco=None):\n",
    "    # h pt\n",
    "    h1_pt = np.array(testfile['TARGETS']['h1']['pt'])\n",
    "    h2_pt = np.array(testfile['TARGETS']['h2']['pt'])\n",
    "    h3_pt = np.array(testfile['TARGETS']['h3']['pt'])\n",
    "    \n",
    "    # resolved mask\n",
    "    h1_mask = np.array(testfile['TARGETS']['h1']['mask'])\n",
    "    h2_mask = np.array(testfile['TARGETS']['h2']['mask'])\n",
    "    h3_mask = np.array(testfile['TARGETS']['h3']['mask'])\n",
    "    \n",
    "    h_masks = np.concatenate((h1_mask.reshape(-1, 1), h2_mask.reshape(-1, 1), h3_mask.reshape(-1, 1)), axis=1)\n",
    "    # h_masks = h_masks.astype(float)\n",
    "    # h_masks = ak.Array(h_masks)\n",
    "    \n",
    "    # boosted mask\n",
    "    bh1_mask = np.array(testfile['TARGETS']['bh1']['mask'])\n",
    "    bh2_mask = np.array(testfile['TARGETS']['bh2']['mask'])\n",
    "    bh3_mask = np.array(testfile['TARGETS']['bh3']['mask'])\n",
    "    \n",
    "    bh_masks = np.concatenate((bh1_mask.reshape(-1, 1), bh2_mask.reshape(-1, 1), bh3_mask.reshape(-1, 1)), axis=1)\n",
    "    # bh_masks = bh_masks.astype(float)\n",
    "    # bh_masks = ak.Array(bh_masks)\n",
    "    \n",
    "    # findout which resolved higgs also have boosted reco\n",
    "    bi_cat_H = h_masks & bh_masks\n",
    "    bi_cat_H = bi_cat_H.astype(float)\n",
    "    bi_cat_H = ak.Array(bi_cat_H)\n",
    "    \n",
    "    \n",
    "    # target assignments\n",
    "    b1_h1_t = np.array(testfile[\"TARGETS\"][\"h1\"]['b1']).astype('int')\n",
    "    b1_h2_t = np.array(testfile[\"TARGETS\"][\"h2\"]['b1']).astype('int')\n",
    "    b1_h3_t = np.array(testfile[\"TARGETS\"][\"h3\"]['b1']).astype('int')\n",
    "\n",
    "    b2_h1_t = np.array(testfile[\"TARGETS\"][\"h1\"]['b2']).astype('int')\n",
    "    b2_h2_t = np.array(testfile[\"TARGETS\"][\"h2\"]['b2']).astype('int')\n",
    "    b2_h3_t = np.array(testfile[\"TARGETS\"][\"h3\"]['b2']).astype('int')\n",
    "    \n",
    "    # predict assignments\n",
    "    b1_h1_p = np.array(predfile[\"TARGETS\"][\"h1\"]['b1']).astype('int')\n",
    "    b1_h2_p = np.array(predfile[\"TARGETS\"][\"h2\"]['b1']).astype('int')\n",
    "    b1_h3_p = np.array(predfile[\"TARGETS\"][\"h3\"]['b1']).astype('int')\n",
    "\n",
    "    b2_h1_p = np.array(predfile[\"TARGETS\"][\"h1\"]['b2']).astype('int')\n",
    "    b2_h2_p = np.array(predfile[\"TARGETS\"][\"h2\"]['b2']).astype('int')\n",
    "    b2_h3_p = np.array(predfile[\"TARGETS\"][\"h3\"]['b2']).astype('int')\n",
    "    \n",
    "    # resolved Higgs detection probability\n",
    "    dp_h1 = np.array(predfile[\"TARGETS\"][\"h1\"]['detection_probability'])\n",
    "    dp_h2 = np.array(predfile[\"TARGETS\"][\"h2\"]['detection_probability'])\n",
    "    dp_h3 = np.array(predfile[\"TARGETS\"][\"h3\"]['detection_probability'])\n",
    "    \n",
    "    # ak4 jets assignment probability\n",
    "    ap_h1 = np.array(predfile[\"TARGETS\"][\"h1\"]['assignment_probability'])\n",
    "    ap_h2 = np.array(predfile[\"TARGETS\"][\"h2\"]['assignment_probability'])\n",
    "    ap_h3 = np.array(predfile[\"TARGETS\"][\"h3\"]['assignment_probability'])\n",
    "    \n",
    "    # reconstruct jet 4-momentum objects\n",
    "    j_pt = np.array(testfile['INPUTS']['Jets']['pt'])\n",
    "    j_eta = np.array(testfile['INPUTS']['Jets']['eta'])\n",
    "    j_phi = np.array(testfile['INPUTS']['Jets']['phi'])\n",
    "    j_mass = np.array(testfile['INPUTS']['Jets']['mass'])\n",
    "    js = ak.zip(\n",
    "        {\n",
    "            \"pt\": j_pt,\n",
    "            \"eta\": j_eta,\n",
    "            \"phi\": j_phi,\n",
    "            \"mass\": j_mass,\n",
    "        },\n",
    "        with_name=\"Momentum4D\"\n",
    "    )\n",
    "    \n",
    "    # convert some numpy arrays to ak arrays\n",
    "    dps = np.concatenate((dp_h1.reshape(-1, 1), dp_h2.reshape(-1, 1), dp_h3.reshape(-1, 1)), axis=1)\n",
    "    dps = ak.Array(dps)\n",
    "    aps = np.concatenate((ap_h1.reshape(-1, 1), ap_h2.reshape(-1, 1), ap_h3.reshape(-1, 1)), axis=1)\n",
    "    aps = ak.Array(aps)\n",
    "    \n",
    "    b1_ps = np.concatenate((b1_h1_p.reshape(-1, 1), b1_h2_p.reshape(-1, 1), b1_h3_p.reshape(-1, 1)), axis=1)\n",
    "    b1_ps = ak.Array(b1_ps)\n",
    "    b1_ts = np.concatenate((b1_h1_t.reshape(-1, 1), b1_h2_t.reshape(-1, 1), b1_h3_t.reshape(-1, 1)), axis=1)\n",
    "    b1_ts = ak.Array(b1_ts)\n",
    "    b2_ps = np.concatenate((b2_h1_p.reshape(-1, 1), b2_h2_p.reshape(-1, 1), b2_h3_p.reshape(-1, 1)), axis=1)\n",
    "    b2_ps = ak.Array(b2_ps)\n",
    "    b2_ts = np.concatenate((b2_h1_t.reshape(-1, 1), b2_h2_t.reshape(-1, 1), b2_h3_t.reshape(-1, 1)), axis=1)\n",
    "    b2_ts = ak.Array(b2_ts)\n",
    "\n",
    "    \n",
    "    \n",
    "    h_pts = np.concatenate((h1_pt.reshape(-1, 1), h2_pt.reshape(-1, 1), h3_pt.reshape(-1, 1)), axis=1)\n",
    "    h_pts = ak.Array(h_pts)\n",
    "    \n",
    "    # select predictions and targets\n",
    "    b1_ts_selected, b2_ts_selected, targetH_selected_pts, bi_cat_H_selected = sel_target_h_by_mask(b1_ts, b2_ts, h_pts, bi_cat_H, h_masks)\n",
    "    b1_ps_selected, b2_ps_selected = sel_pred_h_by_dp(dps, aps, b1_ps, b2_ps, dp_cut=dp_cut)\n",
    "    \n",
    "    # find jets that are overlapped with reco boosted Higgs\n",
    "    if fjs_reco is None:\n",
    "        goodJetIdx =  ak.local_index(js)\n",
    "    else:\n",
    "        goodJetIdx = get_unoverlapped_jet_index(fjs_reco, js, dR_min=0.4)\n",
    "    \n",
    "    # generate look up tables\n",
    "    LUT_pred = gen_pred_h_LUT(b1_ps_selected, b2_ps_selected, b1_ts_selected, b2_ts_selected, js, goodJetIdx, bi_cat_H_selected, ak.ArrayBuilder()).snapshot()\n",
    "    LUT_target = gen_target_h_LUT(b1_ps_selected, b2_ps_selected, b1_ts_selected, b2_ts_selected, targetH_selected_pts, bi_cat_H_selected, ak.ArrayBuilder()).snapshot()\n",
    "    \n",
    "    \n",
    "    return LUT_pred, LUT_target, goodJetIdx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4bef1a35",
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate efficiency\n",
    "# if bins=None, put all data in a single bin\n",
    "def calc_eff(LUT_boosted_pred, LUT_resolved_pred, bins):\n",
    "\n",
    "    predHs = []\n",
    "    \n",
    "    if LUT_boosted_pred is not None:\n",
    "        # boosted H don't need post processing\n",
    "        predHs_boosted = [predH for event in LUT_boosted_pred for predH in event]\n",
    "        predHs += predHs_boosted\n",
    "\n",
    "    if LUT_resolved_pred is not None:\n",
    "        # Remove overlapped resolved H_reco \n",
    "        predHs_resolved = [predH[0:2] for event in LUT_resolved_pred for predH in event if predH[2]==0]\n",
    "        predHs += predHs_resolved\n",
    "        \n",
    "    # then merge into the list with their pT\n",
    "    predHs = np.array(predHs)\n",
    "    \n",
    "    predHs_inds = np.digitize(predHs[:,1], bins)\n",
    "    \n",
    "    correctTruth_per_bin = []\n",
    "    for bin_i in range(1, len(bins)):\n",
    "        correctTruth_per_bin.append(predHs[:,0][predHs_inds==bin_i])\n",
    "    correctTruth_per_bin = ak.Array(correctTruth_per_bin)\n",
    "    \n",
    "    means = ak.mean(correctTruth_per_bin, axis=-1)\n",
    "    \n",
    "    errs = np.abs(\n",
    "    clopper_pearson_interval(num=ak.sum(correctTruth_per_bin, axis=-1),\\\n",
    "                             denom=ak.num(correctTruth_per_bin, axis=-1)) - means\n",
    "    )\n",
    "    \n",
    "    return means, errs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f8b011c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate purity\n",
    "def calc_pur(LUT_boosted_target, LUT_resolved_target, bins):\n",
    "\n",
    "    targetHs = []\n",
    "\n",
    "    if LUT_boosted_target is not None:\n",
    "        # boosted H don't need post processing\n",
    "        targetHs_boosted = [targetH for event in LUT_boosted_target for targetH in event]\n",
    "        targetHs += targetHs_boosted\n",
    "\n",
    "    if LUT_resolved_target is not None:\n",
    "        # only consider resolved target H that doesn't have a boosted reco\n",
    "        targetHs_resolved = [targetH[0:2] for event in LUT_resolved_target for targetH in event if targetH[2]==0]\n",
    "        targetHs += targetHs_resolved\n",
    "\n",
    "    targetHs = np.array(targetHs)\n",
    "\n",
    "    targetHs_inds = np.digitize(targetHs[:,1], bins)\n",
    "    \n",
    "    correctTruth_per_bin = []\n",
    "    for bin_i in range(1, len(bins)):\n",
    "        correctTruth_per_bin.append(targetHs[:,0][targetHs_inds==bin_i])\n",
    "    correctTruth_per_bin = ak.Array(correctTruth_per_bin)\n",
    "    \n",
    "    means = ak.mean(correctTruth_per_bin, axis=-1)\n",
    "    \n",
    "    errs = np.abs(\n",
    "    clopper_pearson_interval(num=ak.sum(correctTruth_per_bin, axis=-1),\\\n",
    "                             denom=ak.num(correctTruth_per_bin, axis=-1)) - means\n",
    "    )\n",
    "    \n",
    "    return means, errs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c7ddc22c",
   "metadata": {},
   "outputs": [],
   "source": [
    "bins = np.arange(0, 1000, 50)\n",
    "bin_centers = [(bins[i]+bins[i+1])/2 for i in range(bins.size-1)]\n",
    "xerr=(bins[1]-bins[0])/2*np.ones(bins.shape[0]-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "25ac25cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "dp_cut=0.5\n",
    "# dp_cut\n",
    "# dR_min\n",
    "# bin_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3b613116",
   "metadata": {},
   "outputs": [],
   "source": [
    "LUT_resolved_pred_spanet, LUT_resolved_target_spanet, _ = parse_resolved_w_target(test_h5, s_h5, dp_cut=dp_cut, fjs_reco=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a25e8585",
   "metadata": {},
   "outputs": [],
   "source": [
    "LUT_resolved_pred_pb, LUT_resolved_target_pb, _ = parse_resolved_w_target(test_h5, pb_h5, dp_cut=dp_cut, fjs_reco=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3aa74f8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "LUT_resolved_pred_base, LUT_resolved_target_base, _ = parse_resolved_w_target(test_h5, b_h5, dp_cut=dp_cut, fjs_reco=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3d858d9c-4423-4402-9344-b68dbfb67ca0",
   "metadata": {},
   "outputs": [],
   "source": [
    "eff_s, efferr_s = calc_eff(None, LUT_resolved_pred_spanet, bins)\n",
    "pur_s, purerr_s = calc_pur(None, LUT_resolved_target_spanet, bins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "bf8c9a14-b0ac-48e4-a0df-68597915e5fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "eff_b, efferr_b = calc_eff(None, LUT_resolved_pred_base, bins)\n",
    "pur_b, purerr_b = calc_pur(None, LUT_resolved_target_base, bins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c8a359a6-de1e-48f7-8138-05108961187e",
   "metadata": {},
   "outputs": [],
   "source": [
    "eff_pb, efferr_pb = calc_eff(None, LUT_resolved_pred_pb, bins)\n",
    "pur_pb, purerr_pb = calc_pur(None, LUT_resolved_target_pb, bins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "65661bca-ad89-47c1-84f5-91b60ad4a8c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x15139b040>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 2, figsize=(12, 5))\n",
    "\n",
    "ax[0].errorbar(x=bin_centers, y=eff_b, xerr=xerr, yerr=efferr_b, fmt='o', capsize=5, label='Baseline')\n",
    "ax[0].errorbar(x=bin_centers, y=eff_s, xerr=xerr, yerr=efferr_s, fmt='o', capsize=5, label='SPANet trained on B+R Task')\n",
    "ax[0].errorbar(x=bin_centers, y=eff_pb, xerr=xerr, yerr=efferr_pb, fmt='o', capsize=5, label='SPANet trained on R')\n",
    "\n",
    "ax[1].errorbar(x=bin_centers, y=pur_b, xerr=xerr, yerr=purerr_b, fmt='o', capsize=5, label='Baseline')\n",
    "ax[1].errorbar(x=bin_centers, y=pur_s, xerr=xerr, yerr=purerr_s, fmt='o', capsize=5, label='SPANet trained on B+R Task')\n",
    "ax[1].errorbar(x=bin_centers, y=pur_pb, xerr=xerr, yerr=purerr_pb, fmt='o', capsize=5, label='SPANet trained on R')\n",
    "\n",
    "ax[0].set(xlabel=r\"Reco H pT (GeV)\", ylabel=r\"Matching efficiency\", title=f\"Resolved Performance of Bi-input Model, DP>{dp_cut}\")\n",
    "ax[1].set(xlabel=r\"Gen H pT (GeV)\", ylabel=r\"Matching purity\", title=f\"Resolved Performance of Bi-input Model, DP>{dp_cut}\")\n",
    "ax[0].legend()\n",
    "ax[1].legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fff82094-85ee-4241-ac4e-8a41580d01a0",
   "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.9.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}