andrzejnovak/jeff_plot.ipynb

## jeff_plot.ipynb
{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "02e58858",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-05T09:07:09.842897Z",
     "start_time": "2024-03-05T09:07:09.730090Z"
    }
   },
   "outputs": [],
   "source": [
    "import uproot\n",
    "import mplhep as hep\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import logging\n",
    "import hist\n",
    "np.seterr(divide='ignore', invalid='ignore')\n",
    "\n",
    "# Only have to do this to read fit results :/\n",
    "import ROOT as r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "742fda9d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-05T09:07:10.783383Z",
     "start_time": "2024-03-05T09:07:10.677565Z"
    }
   },
   "outputs": [],
   "source": [
    "hep.style.use(\"CMS\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3e7906c9",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-05T09:07:16.452077Z",
     "start_time": "2024-03-05T09:07:16.344499Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "0c0b2874",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-05T09:08:01.216078Z",
     "start_time": "2024-03-05T09:08:01.097932Z"
    }
   },
   "outputs": [],
   "source": [
    "# Style dicts\n",
    "style_set_A = {\n",
    "    'merge_dict': {\n",
    "        'top': ['st', 'tt'],\n",
    "        'vlep': ['dy', 'wlnu'],\n",
    "        'hbb': ['hbb'],\n",
    "#         'bkg': ['stqq', 'tqq', 'zll', 'wln', \"wcq\", \"wqq\", \"zbb\", \"zqq\"],\n",
    "#         'bkgNoW': ['stqq', 'tqq', 'zll', 'wln', \"wqq\", \"zbb\", \"zqq\"],\n",
    "#         'nonV': ['stqq', 'tqq', 'zll', 'wln'],\n",
    "    },\n",
    "    'color_dict': {\n",
    "        'total_signal': 'red',\n",
    "        'm150': 'red',\n",
    "        'hbb': '#4E5A7E',\n",
    "        'wqq': \"#84a98c\",\n",
    "        'zqq': '#fcbf49',\n",
    "        'qcd': 'gray',\n",
    "        'tt': 'plum',\n",
    "        'st': 'lightblue',\n",
    "        'top': 'plum',\n",
    "        'wlnu': '#DEC1FF',\n",
    "        'dy': '#DEC1FF',\n",
    "        'vlep': '#DEC1FF',\n",
    "        'bkg': 'gray',\n",
    "        'bkgNoW': 'gray',\n",
    "    },\n",
    "    'hatch_dict': {\n",
    "        'total_signal': None,\n",
    "        'm150': None,\n",
    "        'hbb': None,\n",
    "        'wqq': None,\n",
    "        'qcd': None,\n",
    "        'tt': '\\\\\\\\\\\\\\\\',\n",
    "        'st': '\\\\\\\\\\\\\\\\',\n",
    "        'top': None,\n",
    "        'vlep': '///',\n",
    "        'zbb': None,\n",
    "        'zcc': None,\n",
    "        'zqq': None,\n",
    "        'vvqq': None,\n",
    "        'bkg': '\\\\\\\\\\\\\\\\',\n",
    "        'nonV': '\\\\\\\\\\\\\\\\',\n",
    "        'bkgNoW': '\\\\\\\\\\\\\\\\',\n",
    "    },\n",
    "    # Order here will get respected in plot(..., custom_legend=True)\n",
    "    'label_dict': {\n",
    "        'Data': 'Data',\n",
    "        'MC': 'MC',\n",
    "        'total_signal': \"Signal\",\n",
    "        'Toys': 'PostFit\\nToys',\n",
    "        'zcc': \"$\\mathrm{Z(c\\\\bar{c})}$\",\n",
    "        'zbb': \"$\\mathrm{Z(b\\\\bar{b})}$\",\n",
    "        'zqq': \"$\\mathrm{Z(q\\\\bar{q})}$\",\n",
    "        'wcq': \"$\\mathrm{W(c\\\\bar{q})}$\",\n",
    "        'wqq': \"$\\mathrm{W(q\\\\bar{q})}$\",\n",
    "        'wqq': \"$\\mathrm{W(q\\\\bar{q})}$\",\n",
    "        'hbb': \"$\\mathrm{H(b\\\\bar{b})}$\",\n",
    "        'hcc': \"$\\mathrm{H(c\\\\bar{c})}$\",\n",
    "        'vvqq': \"$\\mathrm{VV}$\",\n",
    "        'top': \"$\\mathrm{Top}$\",\n",
    "        'tt': \"$\\mathrm{t\\\\bar{t}}$\",\n",
    "        'zll': \"$\\mathrm{DY}$\",\n",
    "        'dy': \"$\\mathrm{DY}$\",\n",
    "        'vlep': \"$\\mathrm{V(lep.)}$\",\n",
    "        'wlnu': \"$\\mathrm{W(lep.)}$\",\n",
    "        'stqq': \"$\\mathrm{single-t}$\",\n",
    "        'st': \"$\\mathrm{single-t}$\",\n",
    "        'bkg': \"Other\",\n",
    "        'nonV': \"Other\",\n",
    "        'bkgNoW': \"Other\",\n",
    "        'm150': 'm150',\n",
    "        'qcd': \"QCD\",\n",
    "    }\n",
    "}\n",
    "\n",
    "def format_legend(ax, ncols=2, handles_labels=None, **kwargs):\n",
    "    if handles_labels is None:\n",
    "        handles, labels = ax.get_legend_handles_labels()\n",
    "    else:\n",
    "        handles, labels = handles_labels\n",
    "    nentries = len(handles)\n",
    "\n",
    "    kw = dict(framealpha=1, **kwargs)\n",
    "    split = nentries // ncols * ncols\n",
    "    leg1 = ax.legend(handles=handles[:split],\n",
    "                     labels=labels[:split],\n",
    "                     ncol=ncols,\n",
    "                     loc=\"upper right\",\n",
    "                     **kw)\n",
    "    if nentries % 2 == 0:\n",
    "        return leg1\n",
    "\n",
    "    ax.add_artist(leg1)\n",
    "    leg2 = ax.legend(handles=handles[split:],\n",
    "                     labels=labels[split:],\n",
    "                     ncol=nentries - nentries // ncols * ncols,\n",
    "                     **kw)\n",
    "\n",
    "    leg2.remove()\n",
    "\n",
    "    leg1._legend_box._children.append(leg2._legend_handle_box)\n",
    "    leg1._legend_box.stale = True\n",
    "    return leg1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "712d0097",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-05T09:07:42.020258Z",
     "start_time": "2024-03-05T09:07:41.914185Z"
    }
   },
   "outputs": [],
   "source": [
    "# fitDiag extraction\n",
    "def get_fit_val(fitDiag, val, fittype='fit_s', substitute=1.):\n",
    "    if fitDiag is None:\n",
    "        return substitute\n",
    "    if val in fitDiag.Get(fittype).floatParsFinal().contentsString().split(','):\n",
    "        return fitDiag.Get(fittype).floatParsFinal().find(val).getVal()\n",
    "    else:\n",
    "        return substitute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "5af3a7d5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-05T09:07:44.955607Z",
     "start_time": "2024-03-05T09:07:44.841609Z"
    }
   },
   "outputs": [],
   "source": [
    "# Object conversion\n",
    "def tgasym_to_err(tgasym, restoreNorm=True):\n",
    "    x, y = tgasym.values(\"x\"), tgasym.values(\"y\")\n",
    "    xlo, xhi = tgasym.errors(\"low\", axis=\"x\"), tgasym.errors(\"high\", axis=\"x\")\n",
    "    ylo, yhi = tgasym.errors(\"low\", axis=\"y\"), tgasym.errors(\"high\", axis=\"y\")\n",
    "    bins = np.r_[(x - xlo), (x+xhi)[-1]]\n",
    "    binwidth = xlo+xhi\n",
    "    if restoreNorm:\n",
    "        y = y * binwidth\n",
    "        ylo = ylo * binwidth\n",
    "        yhi = yhi * binwidth\n",
    "    return y, bins, ylo, yhi\n",
    "\n",
    "def tgasym_to_hist(tgasym, restoreNorm=True):\n",
    "    y, bins, ylo, yhi = tgasym_to_err(tgasym, restoreNorm)\n",
    "    h = hist.new.Var(bins).Weight()\n",
    "    h.view().value = y\n",
    "#     logging.debug(\"Someone should check the yerr -> variance conversion\")\n",
    "    h.view().variance = yhi**2\n",
    "    return h\n",
    "\n",
    "def geth(name, shapes_dir, restoreNorm=True):\n",
    "    if isinstance(shapes_dir[name], uproot.models.TGraph.Model_TGraphAsymmErrors_v3):\n",
    "        return tgasym_to_hist(shapes_dir[name], restoreNorm=restoreNorm)\n",
    "    else:\n",
    "        h = shapes_dir[name].to_hist()\n",
    "        if restoreNorm:\n",
    "            h = h * h.axes[0].widths\n",
    "        return h \n",
    "\n",
    "def getha(name, channels, restoreNorm=True):\n",
    "    return sum([geth(name, shapes_dir, restoreNorm=restoreNorm) for shapes_dir in channels])\n",
    "\n",
    "def geths(names, channels, sort=True, restoreNorm=True):\n",
    "    if sort:\n",
    "        sorted_names = [k for k, v in style_set_A['label_dict'].items() if k in names]\n",
    "        assert len(sorted_names) == len(names), f\"Sorting incomplete: {names} -> {sorted_names}\"\n",
    "        names = sorted_names\n",
    "    if isinstance(channels, list):  # channels = [shapes_dir, shapes_dir]\n",
    "        return {name: getha(name, channels, restoreNorm=restoreNorm) for name in names}\n",
    "    else:  # channels = shapes_dir\n",
    "        return {name: geth(name, channels, restoreNorm=restoreNorm) for name in names}\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "619b22db",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-05T09:07:47.600537Z",
     "start_time": "2024-03-05T09:07:47.485593Z"
    }
   },
   "outputs": [],
   "source": [
    "# logger = logging.getLogger()\n",
    "# logger.setLevel(logging.WARN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e9f75d2e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-05T09:06:44.417102Z",
     "start_time": "2024-03-05T09:06:44.294219Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def plot(fitDiag_uproot, \n",
    "         fit_type='fit_s', \n",
    "         cats: (str | list) = 'ptbin0pass',\n",
    "         restoreNorm=True,  # Combine outputs binwnormed results - restores to nominal\n",
    "         sigs = None,  # List of samples considered signals, by default matches to `total_signal`\n",
    "         bkgs = None,  # List of samples considered backaground - exclude QCD\n",
    "         project = None,  # Project (duplicate) some samples onto the x-axis for readability\n",
    "         project_signal: (float | None) = None,  # Plot projected total signal on x-axis, scale by `project_signal`\n",
    "         style=style_set_A,  # Style dictionary {'label_dict': {}, 'color_dict': {}, 'hatch_dict': {}, merge_dict: {}}\n",
    "         clipx=False,  # Clip edge bins when empty\n",
    "         custom_legend=True,  # Customized/prettier legend\n",
    "         fitDiag_root=None,  # ROOT fitDiagnostics file to read fit results\n",
    "        ):\n",
    "    ldict = style_set_A['label_dict']\n",
    "    cdict = style_set_A['color_dict']\n",
    "    hdict = style_set_A['hatch_dict']\n",
    "    merge_dict = style_set_A['merge_dict']\n",
    "    \n",
    "    fit_shapes_name = f\"shapes_{fit_type}\"\n",
    "    if not isinstance(cats, list):\n",
    "        cats = [cats]\n",
    "    channels = [fitDiag_uproot[f\"{fit_shapes_name}/{cat}\"] for cat in cats]\n",
    "    keys = [k.split(';')[0] for k in channels[0].keys() if 'data' not in k and \"covar\" not in k]\n",
    "    logging.info(f\"Plotting `{fit_shapes_name}` for categories: {','.join(cats)}\")\n",
    "\n",
    "    # Basic\n",
    "    fig, (ax, rax) = plt.subplots(2, 1, gridspec_kw={'height_ratios': (3, 1)}, sharex=True)\n",
    "    plt.subplots_adjust(hspace=0)\n",
    "\n",
    "    # Fetch hists\n",
    "    data = getha('data', channels, restoreNorm=restoreNorm)\n",
    "    qcd = getha('qcd', channels, restoreNorm=restoreNorm)\n",
    "    hist_dict = geths(keys, channels, sort=False, restoreNorm=restoreNorm)\n",
    "    # Prepare merges\n",
    "    for k, v in merge_dict.items():\n",
    "        if k in hist_dict and k != v[0]:\n",
    "            raise KeyError(f\"Cannot `{k} : {v}` because `{k}` already exists.\")\n",
    "        to_merge = []\n",
    "        for name in v:\n",
    "            if name not in hist_dict:\n",
    "                logging.warn(f\"Histogram `{name}` is not available in a merge {v} -> {k}\")\n",
    "            else:\n",
    "                to_merge.append(hist_dict[name])\n",
    "        hist_dict[k] = sum(to_merge) \n",
    "    \n",
    "    # Fetch keys\n",
    "    default_signal = [k for k in keys if channels[0][k] == channels[0]['total_signal'] and 'total' not in k]\n",
    "    default_bkgs = [k for k in keys if k not in default_signal and k != \"qcd\" and 'total' not in k]\n",
    "    if bkgs is not None and 'qcd' in bkgs:\n",
    "        raise ValueError(\"'qcd' background is treated separately\")\n",
    "    if bkgs is None:\n",
    "        bkgs = default_bkgs\n",
    "    if sigs is None:\n",
    "        sigs = default_signal\n",
    "    logging.info(f\"  Signals: {','.join(sigs)}\")\n",
    "    logging.info(f\"  Backgrounds: {','.join(bkgs)}\")\n",
    "        \n",
    "    # Plotting main\n",
    "    existing_labels = []\n",
    "    _label = 'qcd' if custom_legend else ldict['qcd']\n",
    "    hep.histplot(qcd, ax=ax,\n",
    "                 label=_label, yerr=False,\n",
    "                 histtype='step', color=cdict['qcd'], hatch=hdict['qcd'],\n",
    "                 lw=2,\n",
    "                )\n",
    "    existing_labels.append(ldict['qcd'])\n",
    "    _labels = [\"_\", *(bkgs+sigs)] if custom_legend else [\"_\", *[ldict[k] for k in bkgs+sigs]]\n",
    "    hep.histplot([qcd, *[hist_dict[k] for k in bkgs+sigs]], ax=ax, \n",
    "                 label=_labels,\n",
    "                 stack=True, histtype='fill',\n",
    "                 facecolor=['none', *[cdict[k] for k in bkgs+sigs]],\n",
    "                )\n",
    "    existing_labels += _labels\n",
    "    hep.histplot(data, ax=ax,\n",
    "                 label=\"Data\", xerr=True,\n",
    "                 histtype='errorbar', color='k')\n",
    "    existing_labels.append('Data')\n",
    "\n",
    "    # Ploting projection\n",
    "    if project is not None:\n",
    "        logging.info(f\"  Projecting on x-axis: {','.join(project)}\")\n",
    "        to_label = project if custom_legend else [ldict[k] for k in project]\n",
    "        to_label = [l if l not in existing_labels else f\"_{l}\" for l in to_label]\n",
    "        hep.histplot([hist_dict[k] for k in project], ax=ax, \n",
    "                     label= to_label,\n",
    "                     facecolor=[cdict[k] for k in project],\n",
    "                     stack=True, histtype='fill',\n",
    "                    )\n",
    "        existing_labels += to_label\n",
    "    \n",
    "    # Project signal\n",
    "    if project_signal is not None:\n",
    "        logging.info(f\"  Projecting signal on x-axis: 'Total Signal' x {project_signal}\")\n",
    "        hep.histplot(hist_dict['total_signal']*project_signal, ax=ax, \n",
    "                     color=cdict['total_signal'],\n",
    "                     stack=True, histtype='step',\n",
    "                     label = ('Signal' if project_signal==1 else f\"Signal x {project_signal:.0f}\"),\n",
    "                     yerr=False, ls='--', lw=2,\n",
    "                    )\n",
    "\n",
    "    # Subplot\n",
    "    tot_bkg =  getha('total_background', channels, restoreNorm=restoreNorm)\n",
    "    tot_sig =  getha('total_signal', channels, restoreNorm=restoreNorm)\n",
    "    tot =  getha('total', channels, restoreNorm=restoreNorm)\n",
    "    rh = (data.values() - tot_bkg.values())/np.sqrt(data.variances())\n",
    "\n",
    "    ## Plotting subplot\n",
    "    hep.histplot(rh, data.axes[0].edges, ax=rax, yerr=1,\n",
    "                 histtype='errorbar', color='k', xerr=True,)\n",
    "    hep.histplot(tot_sig/np.sqrt(data.variances()), ax=rax,\n",
    "                 color=cdict['total_signal'], lw=2,\n",
    "                 label='Signal',\n",
    "                )\n",
    "    #########\n",
    "    # Styling\n",
    "    hep.cms.label(\"Preliminary\", ax=ax)\n",
    "    \n",
    "    ax.legend(ncol=2)\n",
    "    if clipx:\n",
    "        _h, _bins = data.to_numpy()\n",
    "        nonzero = _bins[:-1][_h > 0]\n",
    "        ax.set_xlim(nonzero[0], nonzero[-1])\n",
    "    else:\n",
    "        ax.set_xlim(data.axes[0].edges[0], data.axes[0].edges[-1])\n",
    "    ax.set_ylim(0, np.max(data.values())*1.3)\n",
    "    ax.set_xlabel(None)\n",
    "    ax.set_ylabel(\"Events\")\n",
    "    \n",
    "    rax.legend()\n",
    "    limlo, limhi = rax.get_ylim()\n",
    "    rax.set_ylim(np.min([-2, limlo]), np.max([2, limhi]))\n",
    "    rax.axhline(0, color='gray', ls='--')\n",
    "    rax.set_ylabel(r\"$\\frac{Data-Bkg}{\\sigma_{Data}}$\", y=0.5)\n",
    "    rax.set_xlabel(r\"Jet $m_{SD}$\")\n",
    "    \n",
    "    if custom_legend:\n",
    "        # Customized legend formatting (requires nominal keys be used for labels previously)\n",
    "        order = np.argsort(\n",
    "            [list(ldict.keys()).index(i) for i in ax.get_legend_handles_labels()[-1]])\n",
    "        handles, labels = ax.get_legend_handles_labels()\n",
    "        handles = [handles[i] for i in order]\n",
    "        labels = [ldict[labels[i]] for i in order]\n",
    "        leg = format_legend(ax,\n",
    "                            ncols=2,\n",
    "                            handles_labels=(handles, labels),\n",
    "                            bbox_to_anchor=(1, 1),\n",
    "                            markerscale=0.8, fontsize='small',\n",
    "                            labelspacing=0.4,\n",
    "                            columnspacing=1.5)\n",
    "    if fit_type == 'prefit':\n",
    "        leg.set_title(title=fit_type.capitalize(), prop={'size': \"small\"})\n",
    "    else:\n",
    "        # Don't write postfit to save space, just print r\n",
    "        if fitDiag_root is not None:\n",
    "            fig.canvas.draw()\n",
    "            _r = get_fit_val(fitDiag_root, 'r', fittype='fit_s', substitute=1.)\n",
    "            val_str = \"$\\mu_{Signal}$ = \" + \"{:.1f}\".format(_r)\n",
    "            fig.canvas.draw()\n",
    "            bbox = leg.get_window_extent().transformed(ax.transAxes.inverted())\n",
    "            x, y = bbox.xmin + bbox.width / 2, bbox.ymin\n",
    "            ax.text(x,\n",
    "                    y,\n",
    "                    val_str,\n",
    "                    fontsize='small',\n",
    "                    ha='center',\n",
    "                    va='top',\n",
    "                    transform=ax.transAxes)\n",
    "    \n",
    "    lab_reg = \"Passing\" if \"pass\" in cats[0] else \"Failing\"\n",
    "    lab_cats =  \",\".join(cats)\n",
    "    reg, reg2 = \",\", \"\\n\"\n",
    "    lab_cats = \"\".join([reg + x if i != 2 else reg2 + x for i, x in enumerate(lab_cats.split(reg))])[len(reg):]\n",
    "    annot = lab_cats + '\\n' + '{} Region'.format(lab_reg)\n",
    "    ax.annotate(annot,\n",
    "                linespacing=1.7,\n",
    "                xy=(0.04, 0.94),\n",
    "                xycoords='axes fraction',\n",
    "                ha='left',\n",
    "                va='top',\n",
    "                ma='center',\n",
    "                fontsize='small',\n",
    "                bbox={\n",
    "                    'facecolor': 'white',\n",
    "                    'edgecolor': 'white',\n",
    "                    'alpha': 0,\n",
    "                    'pad': 13\n",
    "                },\n",
    "                annotation_clip=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "32553e82",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-05T09:07:02.603756Z",
     "start_time": "2024-03-05T09:07:01.549005Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ptbin0pass,ptbin1pass\n",
      "ptbin1pass\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "FD = 'm150_model_new/FD_t1TF_realtoy.root'\n",
    "fd = uproot.open(FD)\n",
    "rfd = r.TFile.Open(FD)\n",
    "\n",
    "    \n",
    "plot(fd, 'fit_s', cats=['ptbin0pass', 'ptbin1pass', 'ptbin1pass'], restoreNorm=True,\n",
    "     bkgs = ['zqq', 'wqq','hbb','top', 'vlep'],\n",
    "     project=['top', 'vlep'],\n",
    "#      project_signal=5.,\n",
    "     custom_legend=True,\n",
    "     clipx=True,\n",
    "     fitDiag_root=rfd,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97c05fb3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b129e153",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:combine]",
   "language": "python",
   "name": "conda-env-combine-py"
  },
  "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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}