{
 "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/resolved_pred_v29.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_v1.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*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=0.0, 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=0.0, 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": 24,
   "id": "65661bca-ad89-47c1-84f5-91b60ad4a8c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x153a8d1f0>"
      ]
     },
     "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='R input SPANet')\n",
    "ax[0].errorbar(x=bin_centers, y=eff_pb, xerr=xerr, yerr=efferr_pb, fmt='o', capsize=5, label='B+R input SPANet')\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='R input SPANet')\n",
    "ax[1].errorbar(x=bin_centers, y=pur_pb, xerr=xerr, yerr=purerr_pb, fmt='o', capsize=5, label='B+R input SPANet')\n",
    "\n",
    "ax[0].set(xlabel=r\"Reco H pT (GeV)\", ylabel=r\"Matching efficiency\", title=f\"Resolve Performance of Resolved Model, DP>{0.0}\")\n",
    "ax[1].set(xlabel=r\"Gen H pT (GeV)\", ylabel=r\"Matching purity\", title=f\"Resolve Performance of Resolved Mode, DP>{0.0}l\")\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
}