{
 "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/envs/phys239/lib/python3.7/site-packages/coffea/util.py:154: FutureWarning: In coffea version v2023.3.0 (target date: 31 Mar 2023), 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/pb_off_pred_v61.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 = 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 = ak.Array(bh_masks)\n",
    "    \n",
    "    # findout which resolved higgs also have boosted reco\n",
    "    bi_cat_H = h_masks & bh_masks\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",
    "    # boosted H don't need post processing\n",
    "    predHs_boosted = [predH for event in LUT_boosted_pred for predH in event]\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",
    "    # then merge into the list with their pT\n",
    "    predHs = predHs_boosted + predHs_resolved\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",
    "    # boosted H don't need post processing\n",
    "    targetHs_boosted = [targetH for event in LUT_boosted_target for targetH in event]\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_boosted + targetHs_resolved\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_boosted_pred_spanet, LUT_boosted_target_spanet, fjs_reco_spanet = parse_boosted_w_target(test_h5, s_h5, dp_cut=dp_cut)\n",
    "LUT_resolved_pred_spanet, LUT_resolved_target_spanet, goodJetIdx_spanet = parse_resolved_w_target(test_h5, s_h5, dp_cut=dp_cut, fjs_reco=fjs_reco_spanet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a25e8585",
   "metadata": {},
   "outputs": [],
   "source": [
    "LUT_boosted_pred_pb, LUT_boosted_target_pb, fjs_reco_pb = parse_boosted_w_target(test_h5, pb_h5, dp_cut=dp_cut)\n",
    "LUT_resolved_pred_pb, LUT_resolved_target_pb, goodJetIdx_pb = parse_resolved_w_target(test_h5, pb_h5, dp_cut=dp_cut, fjs_reco=fjs_reco_pb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3aa74f8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "LUT_boosted_pred_base, LUT_boosted_target_base, fjs_reco_base = parse_boosted_w_target(test_h5, b_h5, dp_cut=dp_cut)\n",
    "LUT_resolved_pred_base, LUT_resolved_target_base, goodJetIdx_base = parse_resolved_w_target(test_h5, b_h5, dp_cut=dp_cut, fjs_reco=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8af09055",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/billyli/miniforge_x86_new/envs/phys239/lib/python3.7/site-packages/awkward/contents/content.py:1068: DeprecationWarning: In version 2.2.0, this will be an error.\n",
      "To raise these warnings as errors (and get stack traces to find out where they're called), run\n",
      "    import warnings\n",
      "    warnings.filterwarnings(\"error\", module=\"awkward.*\")\n",
      "after the first `import awkward` or use `@pytest.mark.filterwarnings(\"error:::awkward.*\")` in pytest.\n",
      "Issue: Conversion of irreducible unions to backend arrays is deprecated..\n",
      "  return self._to_backend_array(allow_missing, backend)\n"
     ]
    }
   ],
   "source": [
    "eff_s, efferr_s = calc_eff(LUT_boosted_pred_spanet, LUT_resolved_pred_spanet, bins)\n",
    "pur_s, purerr_s = calc_pur(LUT_boosted_target_spanet, LUT_resolved_target_spanet, bins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b54aaa9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "eff_b, efferr_b = calc_eff(LUT_boosted_pred_base, LUT_resolved_pred_base, bins)\n",
    "pur_b, purerr_b = calc_pur(LUT_boosted_target_base, LUT_resolved_target_base, bins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "7a900c1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "eff_pb, efferr_pb = calc_eff(LUT_boosted_pred_pb, LUT_resolved_pred_pb, bins)\n",
    "pur_pb, purerr_pb = calc_pur(LUT_boosted_target_pb, LUT_resolved_target_pb, bins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "be384f5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f806971ce50>"
      ]
     },
     "execution_count": 24,
     "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')\n",
    "ax[0].errorbar(x=bin_centers, y=eff_pb, xerr=xerr, yerr=efferr_pb, fmt='o', capsize=5, label='SPANet Particle Balance Off')\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')\n",
    "ax[1].errorbar(x=bin_centers, y=pur_pb, xerr=xerr, yerr=purerr_pb, fmt='o', capsize=5, label='SPANet Particle Balance Off')\n",
    "\n",
    "ax[0].set(xlabel=r\"Reco H pT (GeV)\", ylabel=r\"Matching efficiency\", title=f\"Boosted+Resolved DP>{dp_cut}, AP>0\")\n",
    "ax[1].set(xlabel=r\"Gen H pT (GeV)\", ylabel=r\"Matching purity\", title=f\"Boosted+Resolved DP>{dp_cut}, AP>0\")\n",
    "ax[0].legend()\n",
    "ax[1].legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "2473bb24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre>[0.0807,\n",
       " 0.0885,\n",
       " 0.135,\n",
       " 0.202,\n",
       " 0.254,\n",
       " 0.363,\n",
       " 0.48,\n",
       " 0.55,\n",
       " 0.58,\n",
       " 0.583,\n",
       " 0.582,\n",
       " 0.57,\n",
       " 0.605,\n",
       " 0.604,\n",
       " 0.737,\n",
       " 0.566,\n",
       " 0.551,\n",
       " 0.679,\n",
       " 0.627]\n",
       "------------------\n",
       "type: 19 * float64</pre>"
      ],
      "text/plain": [
       "<Array [0.0807, 0.0885, 0.135, ..., 0.551, 0.679, 0.627] type='19 * float64'>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eff_s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "dc26f227",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre>[0.105,\n",
       " 0.089,\n",
       " 0.1,\n",
       " 0.13,\n",
       " 0.214,\n",
       " 0.372,\n",
       " 0.65,\n",
       " 0.775,\n",
       " 0.85,\n",
       " 0.877,\n",
       " 0.851,\n",
       " 0.885,\n",
       " 0.887,\n",
       " 0.871,\n",
       " 0.874,\n",
       " 0.948,\n",
       " 1,\n",
       " 0.947,\n",
       " 0.833]\n",
       "------------------\n",
       "type: 19 * float64</pre>"
      ],
      "text/plain": [
       "<Array [0.105, 0.089, 0.1, 0.13, ..., 1, 0.947, 0.833] type='19 * float64'>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pur_s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "5e790a0e",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'LUT_resolved_target' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/lf/yggx1zv12tz2k1d1xnx1g6q00000gn/T/ipykernel_62736/810028004.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mtargetH\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mevent\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mLUT_resolved_target\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mtargetH\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mevent\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtargetH\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'LUT_resolved_target' is not defined"
     ]
    }
   ],
   "source": [
    "a = [targetH[0:2] for event in LUT_resolved_target for targetH in event if targetH[2]==0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "daf99d74",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc4616c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = [targetH for event in LUT_resolved_target for targetH in event]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4c1f248",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40fa59bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(LUT_resolved_target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1dfb3a2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = [targetH[0:2] for event in LUT_resolved_pred for targetH in event if targetH[2]==0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01790fc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bad69bd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = [targetH[0:2] for event in LUT_resolved_pred for targetH in event]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b00e3f56",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d19c7ff8",
   "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
}