gof.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Goodness-of-fit test with Combine\n",
    "Assuming background model is rejected events (fail VAE cut) miltiplied by some transfer factor (single number or function of dijet invariant mass)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to JupyROOT 6.12/07\n"
     ]
    }
   ],
   "source": [
    "# Imports\n",
    "import os, sys\n",
    "import numpy as np\n",
    "import ROOT as rt\n",
    "import uproot\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "import root_numpy as rtnp\n",
    "import pandas\n",
    "from math import log10, floor\n",
    "from subprocess import Popen\n",
    "import shlex \n",
    "import cmsstyle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Usign luminosity 63.981237457\n",
      "Scale QCD with 1.0\n",
      "Scale signal with 0.000526567460168\n",
      "[1200. 1300. 1400. 1500. 1600. 1700. 1800. 1900. 2000. 2100. 2200. 2300.\n",
      " 2400. 2500. 2600. 2700. 2800. 2900. 3000. 3100. 3200. 3300. 3400. 3500.\n",
      " 3600. 3700. 3800. 3900. 4000. 4100. 4200. 4300. 4400. 4500. 4600. 4700.\n",
      " 4800. 4900. 5000. 5100. 5200. 5300. 5400. 5500.]\n"
     ]
    }
   ],
   "source": [
    "# Set some important variables\n",
    "\n",
    "# Rescaling the inputs to lumi\n",
    "qcd_xsec       = 8730000.0 # Crossection in fb             \n",
    "qcd_gen_events = 134366091.0+199435365.0+90490645.0+134264102.0 #(all generated QCD)\n",
    "sig_xsec       = 10. #In units of fb (== 0.01 pb) \n",
    "sig_gen_events = 972050.0 #(all generated signal)\n",
    "lumi           = qcd_gen_events/qcd_xsec # assuming 64/fb since qcd_gen_events/8730000 ~ 64\n",
    "\n",
    "scale_qcd = qcd_xsec*lumi/qcd_gen_events\n",
    "scale_sig = 0.8*sig_xsec*lumi/sig_gen_events #20% already used for quantile regression, must be removed\n",
    "print('Usign luminosity {}'.format(lumi))\n",
    "print('Scale QCD with {}'.format(scale_qcd))\n",
    "print('Scale signal with {}'.format(scale_sig))\n",
    "\n",
    "# Set binning\n",
    "useDijet = False #DOESN'T WORK FOR GOF!!! Only use for plotting\n",
    "# Dijet variable-binwidth binning (depends on dijet resolution)\n",
    "if useDijet:\n",
    "    histfile = 'histograms_dijet.root'\n",
    "    wsfile   = 'datacard_ws_dijet'   #only prefix\n",
    "#     bin_edges = np.array([1126,1181,1246,1313,1383,1455,1530,\n",
    "#                           1607,1687,1770,1856,1945,2037,2132,\n",
    "#                           2231,2332,2438,2546,2659,2775,2895,\n",
    "#                           3019,3147,3279,3416,3558,3704,3854,\n",
    "#                           4010,4171,4337,4509,4686,4869,5058,\n",
    "#                           5253,5500,5663,5877,6099,6328,6564,6808]).astype('float')\n",
    "    #Use  latest binning\n",
    "    bin_edges = np.array([1200, 1255, 1320, 1387, 1457, 1529,\n",
    "                          1604, 1681, 1761, 1844, 1930, 2019, \n",
    "                          2111, 2206, 2305, 2406, 2512, 2620, \n",
    "                          2733, 2849, 2969, 3093, 3221, 3353,\n",
    "                          3490, 3632, 3778, 3928, 4084, 4245, \n",
    "                          4411, 4583, 4760, 4943, 5132, 5327,\n",
    "                          5574, 5737, 5951, 6173, 6402, 6638, 6882]).astype('float')\n",
    "\n",
    "# Constant binwidth\n",
    "else:\n",
    "    histfile = 'histograms_100GeV_5500.root'\n",
    "    wsfile   = 'datacard_ws_100GeV_5500'   \n",
    "    bin_edges = np.array(np.arange(1200.,5600., 100.).tolist()).astype('float') #100 GeV binning. Stop at 5600! Fit fails if going to 6800\n",
    "print(bin_edges)\n",
    "n_bins = len(bin_edges)-1\n",
    "max_bin = bin_edges[-1]\n",
    "min_bin = bin_edges[0]\n",
    "\n",
    "# Signal strengths to inject for statistical test\n",
    "# Define some signal parameters\n",
    "MX = 3500. #Signal mass in units of GeV\n",
    "sig_inj_vals = [0,0.1, 1, 2,5,10] #These correspond to xsecs of 0fb(used for GOF w.o signal), 1fb, 10fb, 20fb, 50fb, 100fb\n",
    "\n",
    "# Where to save data histograms and workspace+datacards\n",
    "\n",
    "\n",
    "#quantiles\n",
    "quants = [0.01,0.1,0.3,0.5,0.7,0.9]\n",
    "\n",
    "#Color style\n",
    "scol = ['#fdd49e','#fdbb84','#fc8d59','#ef6548','#d7301f','#990000']\n",
    "scol.reverse()\n",
    "bcol = ['#ccece6','#99d8c9','#66c2a4','#41ae76','#238b45','#005824'] \n",
    "bcol.reverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[u'eventFeatureNames', u'eventFeatures']\n",
      "['mJJ', 'j1Pt', 'j1Eta', 'j1Phi', 'j1M', 'j1E', 'j2Pt', 'j2M', 'j2E', 'DeltaEtaJJ', 'DeltaPhiJJ', 'j1TotalLoss', 'j1RecoLoss', 'j1KlLoss', 'j2TotalLoss', 'j2RecoLoss', 'j2KlLoss', 'sel_q90', 'sel_q70', 'sel_q50', 'sel_q30', 'sel_q10', 'sel_q01']\n",
      "N QCD events = 7671759\n"
     ]
    }
   ],
   "source": [
    "#  Get the total, accepted and rejected events for signal and data\n",
    "path = '/eos/project/d/dshep/TOPCLASS/DijetAnomaly/VAE_results/run_113/sig_GtoWW35naReco/xsec_0/'\n",
    "\n",
    "f_qcd = h5py.File(path+'qcd_sqrtshatTeV_13TeV_PU40_NEW_ALL_Test_reco.h5', 'r')\n",
    "f_sig = h5py.File(path+'RSGraviton_WW_NARROW_13TeV_PU40_3.5TeV_reco.h5', 'r')\n",
    "\n",
    "print(f_qcd.keys())\n",
    "print(list(f_qcd.get(\"eventFeatureNames\")))\n",
    "print('N QCD events = {}'.format(len(f_qcd.get(\"eventFeatures\"))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No dEta cut Total = 531825\n",
      "No dEta cut pass q 1% = 13284\n",
      "With dEta cut Total = 531825\n",
      "With dEta cut pass q 1% = 13284\n"
     ]
    }
   ],
   "source": [
    "# Define which columns represent whiich variaibles\n",
    "\n",
    "mjj_idx = int(np.where(f_qcd['eventFeatureNames'][()] == 'mJJ')[0])\n",
    "deta_idx = int(np.where(f_sig['eventFeatureNames'][()] == 'DeltaEtaJJ')[0])\n",
    "\n",
    "# Different quantiles (not yet orthogonal!)\n",
    "columns   = {}\n",
    "columns[0.9]  = int(np.where(f_qcd['eventFeatureNames'][()] == 'sel_q90')[0]) # 0=rejected 1=accepted\n",
    "columns[0.7]  = int(np.where(f_qcd['eventFeatureNames'][()] == 'sel_q70')[0])\n",
    "columns[0.5]  = int(np.where(f_qcd['eventFeatureNames'][()] == 'sel_q50')[0])\n",
    "columns[0.3]  = int(np.where(f_qcd['eventFeatureNames'][()] == 'sel_q30')[0])\n",
    "columns[0.1]  = int(np.where(f_qcd['eventFeatureNames'][()] == 'sel_q10')[0])\n",
    "columns[0.01] = int(np.where(f_qcd['eventFeatureNames'][()] == 'sel_q01')[0])\n",
    "\n",
    "\n",
    "# Get all features as numpy arrays and apply dEta cut\n",
    "qcd_tot = np.array(f_qcd.get(\"eventFeatures\"))\n",
    "sig_tot = np.array(f_sig.get(\"eventFeatures\"))\n",
    "print('No dEta cut Total = {}'.format(sig_tot.shape[0]))\n",
    "print('No dEta cut pass q 1% = {}'.format(sig_tot[sig_tot[:,columns[0.01]] == 1].shape[0]))\n",
    "qcd_tot = qcd_tot[abs(qcd_tot[:,deta_idx]) < 1.40]\n",
    "sig_tot = sig_tot[abs(sig_tot[:,deta_idx]) < 1.40]\n",
    "print('With dEta cut Total = {}'.format(sig_tot.shape[0]))\n",
    "print('With dEta cut pass q 1% = {}'.format(sig_tot[sig_tot[:,columns[0.01]] == 1].shape[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the different dijet invariant mass datasets (total, orthogonal quantiles)\n",
    "datas_qcd_acc = {}\n",
    "datas_sig_acc = {}\n",
    "\n",
    "sig_all      = sig_tot[:,mjj_idx]\n",
    "qcd_all      = qcd_tot[:,mjj_idx]\n",
    "\n",
    "#Define the main templates as the 'unused quantile' at 90-100% background efficiency\n",
    "qcd_template = qcd_tot[qcd_tot[:,columns[0.9]] == 0]\n",
    "qcd_template = qcd_template[:,mjj_idx]\n",
    "sig_template = sig_tot[sig_tot[:,columns[0.9]] == 0]\n",
    "sig_template = sig_template[:,mjj_idx]\n",
    "\n",
    "# Make sure all quantiles are orthogonal (removing events passing q-1 from q distribution)\n",
    "qcd = np.copy(qcd_tot)\n",
    "sig = np.copy(sig_tot)\n",
    "\n",
    "for key in sorted(columns.keys()):\n",
    "    \n",
    "    # Start with q=0.01 and take all events that pass cut on VAE\n",
    "    datas_qcd_acc[key] = qcd[qcd[:,columns[key]] == 1]\n",
    "    datas_qcd_acc[key] = datas_qcd_acc[key][:,mjj_idx]\n",
    "    \n",
    "    datas_sig_acc[key] = sig[sig[:,columns[key]] == 1]\n",
    "    datas_sig_acc[key] = datas_sig_acc[key][:,mjj_idx]\n",
    "    \n",
    "    #Remove those events from dataset and continue to next quantile\n",
    "    qcd = qcd[qcd[:,columns[key]] == 0]\n",
    "    sig = sig[sig[:,columns[key]] == 0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/afs/cern.ch/user/t/thaarres/.local/lib/python2.7/site-packages/matplotlib/font_manager.py:1333: UserWarning: findfont: Font family [u'sans-serif'] not found. Falling back to DejaVu Sans\n",
      "  (prop.get_family(), self.defaultFamily[fontext]))\n",
      "/afs/cern.ch/user/t/thaarres/.local/lib/python2.7/site-packages/matplotlib/font_manager.py:1333: UserWarning: findfont: Font family [u'TeX Gyre Heros'] not found. Falling back to DejaVu Sans\n",
      "  (prop.get_family(), self.defaultFamily[fontext]))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Some quick control plots to check shapes\n",
    "\n",
    "from matplotlib.lines import Line2D\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "for i,key in enumerate(sorted(datas_qcd_acc.keys())):\n",
    "    if i > 0:\n",
    "        lower_bound = sorted(datas_qcd_acc.keys())[i-1]\n",
    "    else:\n",
    "       lower_bound = 0.0 \n",
    "    plt.hist(datas_qcd_acc[key],bins=bin_edges,label=r'Data (q = ${}-{}$)'.format(lower_bound,key),histtype='step', linewidth=2, facecolor='none', edgecolor=bcol[i],fill=True,density=True)\n",
    "plt.hist(qcd_all,bins=bin_edges,label=r'Data all',histtype='step', linewidth=2,linestyle=\"dashed\",  facecolor='none', edgecolor='Black',fill=True,density=True)\n",
    "plt.hist(qcd_template,bins=bin_edges,label=r'Data rejected',histtype='step', linewidth=2, facecolor='none', edgecolor='Black',fill=True,density=True)\n",
    "       \n",
    "for i,key in enumerate(sorted(datas_sig_acc.keys())):\n",
    "    if i > 0:\n",
    "        lower_bound = sorted(datas_sig_acc.keys())[i-1]\n",
    "    else:\n",
    "       lower_bound = 0.0 \n",
    "    plt.hist(datas_sig_acc[key],bins=bin_edges,label=r'G $\\rightarrow$ WW (q = {}-{})'.format(lower_bound,key),histtype='step', linewidth=2, facecolor='none', edgecolor=scol[i],fill=True,density=True)\n",
    "    \n",
    "plt.hist(sig_all,bins=bin_edges,label=r'G $\\rightarrow$ WW all',histtype='step', linewidth=2,linestyle=\"dashed\",  facecolor='none', edgecolor='Black',fill=True,density=True)\n",
    "plt.hist(sig_template,bins=bin_edges,label=r'G $\\rightarrow$ WW rejected',histtype='step', linewidth=2, facecolor='none', edgecolor='Black',fill=True,density=True)\n",
    "plt.hist(qcd_all,bins=bin_edges,histtype='step', linewidth=2,linestyle=\"dashed\",  facecolor='none', edgecolor='Black',fill=True,density=True)\n",
    "plt.hist(qcd_template,bins=bin_edges,histtype='step', linewidth=2, facecolor='none', edgecolor='Black',fill=True,density=True)\n",
    "    \n",
    "handles, labels = ax.get_legend_handles_labels()\n",
    "new_handles = [Line2D([], [], c=h.get_edgecolor(),linestyle=h.get_linestyle()) for h in handles]\n",
    "plt.ylabel('A.U')\n",
    "plt.xlabel(u'$M_{jj}$ (GeV)')\n",
    "plt.locator_params(nbins=4)\n",
    "plt.legend(handles=new_handles, labels=labels,loc='best',frameon=False, ncol=2,fontsize='xx-small')\n",
    "plt.savefig('signal_shapes_nolog.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N total data events = 7671755\n",
      "Sum of all events up to 90th quantile = 6902595\n",
      "Sum of all events between 90th-100th quantile = 769160\n",
      "N_total - N_1to90 - N_90to100 = 0\n"
     ]
    }
   ],
   "source": [
    "# Sanity checks\n",
    "\n",
    "#Check that sum of orthogonal quantiles yield total\n",
    "print('N total data events = {}'.format(qcd_tot.shape[0]))\n",
    "sum_quantiles = 0\n",
    "for i,key in enumerate(sorted(datas_qcd_acc.keys())):\n",
    "    sum_quantiles += datas_qcd_acc[key].shape[0]\n",
    "print('Sum of all events up to 90th quantile = {}'.format(sum_quantiles))\n",
    "print('Sum of all events between 90th-100th quantile = {}'.format(qcd_template.shape[0]))\n",
    "print('N_total - N_1to90 - N_90to100 = {}'.format(qcd_tot.shape[0]-sum_quantiles-qcd_template.shape[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fill histograms using dijet binning and proper lumi scaling.\n",
    "#These are the baseline histograms for statistical analysis.\n",
    "axis_title = ['M_{jj}','Events']\n",
    "\n",
    "#Fill and scale to lumi\n",
    "background_hist_template = rt.TH1D('background_hist_template','background_hist_template',n_bins,bin_edges.astype('float'))\n",
    "data_rejected = rt.TH1D('data_rejected','data_rejected',n_bins,bin_edges.astype('float'))\n",
    "\n",
    "rtnp.fill_hist(background_hist_template, qcd_template, weights=None)\n",
    "rtnp.fill_hist(data_rejected, qcd_template, weights=None)\n",
    "# background_hist_template.Scale(scale_qcd)\n",
    "background_hist_template.SetStats(0)\n",
    "background_hist_template.Sumw2()\n",
    "signal_hist_template     = rt.TH1D('signal_rej'    ,'signal_rej'    ,n_bins,bin_edges.astype('float'))\n",
    "rtnp.fill_hist(signal_hist_template    , sig_template, weights=None)\n",
    "signal_hist_template.Scale(scale_sig)\n",
    "signal_hist_template.SetStats(0)\n",
    "signal_hist_template.Sumw2()\n",
    "\n",
    "background_hist_template.SetXTitle(axis_title[0])\n",
    "background_hist_template.SetYTitle(axis_title[1])\n",
    "background_hist_template.binning = bin_edges\n",
    "background_hist_template.SetLineColor(rt.kBlack)\n",
    "background_hist_template.SetLineColor(rt.kBlack)\n",
    "background_hist_template.SetLineStyle(rt.kSolid)\n",
    "background_hist_template.SetLineWidth(2)\n",
    "\n",
    "leg = rt.TLegend(0.31, 0.6, 0.85, 0.9)\n",
    "leg.SetNColumns(2)\n",
    "leg.SetTextSize(0.035)\n",
    "leg.SetBorderSize(0)\n",
    "leg.SetFillStyle(0)\n",
    "\n",
    "histos_data = {}\n",
    "histos_signal = {}\n",
    "scol = ['#fdd49e','#fdbb84','#fc8d59','#ef6548','#d7301f','#990000']\n",
    "scol.reverse()\n",
    "bcol = ['#ccece6','#99d8c9','#66c2a4','#41ae76','#238b45','#005824'] \n",
    "bcol.reverse()\n",
    "colors = ['#d55e00','#cc79a7','#0072b2','#f0e442','#009e73','#b3de69','#fccde5','#d9d9d9']\n",
    "i = 0\n",
    "for keyD,keyS in zip( sorted(datas_qcd_acc.keys()), sorted(datas_sig_acc.keys()) ):\n",
    "    histos_data[keyD]  = rt.TH1D('data_obs_{}'.format(keyD),'',n_bins,bin_edges.astype('float'))\n",
    "    histos_signal[keyS]= rt.TH1D('signal_{}'  .format(keyS),'',n_bins,bin_edges.astype('float'))\n",
    "    rtnp.fill_hist(histos_data[keyD]   , datas_qcd_acc[keyD], weights=None)\n",
    "    rtnp.fill_hist(histos_signal[keyS] , datas_sig_acc[keyS], weights=None)\n",
    "    \n",
    "#     .histos_data[keyD].Scale(scale_qcd)\n",
    "    histos_signal[keyS].Scale(scale_sig)\n",
    "    \n",
    "    histos_data[keyD]  .SetStats(0)\n",
    "    histos_signal[keyS].SetStats(0)\n",
    "    \n",
    "#     histos_data[keyD].SetBinErrorOption(rt.TH1.kPoisson)\n",
    "    histos_data[keyD].Sumw2()\n",
    "    histos_signal[keyS].Sumw2()\n",
    "\n",
    "    histos_data[keyD].SetXTitle(axis_title[0])\n",
    "    histos_data[keyD].SetYTitle(axis_title[1])\n",
    "    histos_data[keyD].binning = bin_edges\n",
    "    \n",
    "    histos_signal[keyS].SetXTitle(axis_title[0])\n",
    "    histos_signal[keyS].SetYTitle(axis_title[1])\n",
    "    histos_signal[keyS].binning = bin_edges\n",
    "    \n",
    "    histos_data[keyD].SetLineColor(rt.TColor.GetColor(bcol[i]))\n",
    "    histos_data[keyD].SetMarkerColor(rt.TColor.GetColor(bcol[i]))\n",
    "    \n",
    "    histos_signal[keyS].SetLineColor(rt.TColor.GetColor(scol[i]))\n",
    "    histos_signal[keyS].SetLineStyle(rt.kSolid)\n",
    "    histos_signal[keyS].SetLineWidth(2)\n",
    "    histos_signal[keyS].SetFillColorAlpha((rt.TColor.GetColor(scol[i])), 0.30)\n",
    "\n",
    "    histos_data[keyD].SetMarkerStyle(20+i)\n",
    "    histos_data[keyD].SetMarkerSize(0.9)\n",
    "    i += 1\n",
    "\n",
    "\n",
    "#Draw\n",
    "c = rt.TCanvas('c','c',800,800)\n",
    "background_hist_template.Draw('HIST')\n",
    "background_hist_template.SetTitle(\"\")\n",
    "background_hist_template.SetMinimum(0.1)\n",
    "background_hist_template.SetMaximum(qcd_tot.shape[0])\n",
    "signal_hist_template.SetLineColor(rt.kBlack)\n",
    "signal_hist_template.SetLineStyle(rt.kSolid)\n",
    "signal_hist_template.SetLineWidth(2)\n",
    "signal_hist_template.Draw('HISTsame')\n",
    "# signal_hist_template    .Draw('same HIST')\n",
    "\n",
    "for i,key in enumerate(sorted(histos_data.keys())):\n",
    "    if i > 0:\n",
    "        lower_bound = sorted(histos_data.keys())[i-1]\n",
    "    else:\n",
    "       lower_bound = 0.0 \n",
    "#     leg.AddEntry(histos_data[key], 'Data (q = {}-{})'.format(lower_bound,key), 'lep')\n",
    "    leg.AddEntry(histos_data[key], 'Data    ', 'lep')\n",
    "    leg.AddEntry(histos_signal[key], 'G#rightarrowWW   (q = {}-{})'.format(lower_bound,key), 'l')\n",
    "    histos_data[key].Draw('pez same')\n",
    "#     histos_signal[key].Scale(10000.)\n",
    "    histos_signal[key].Draw('HIST same')   \n",
    "leg.AddEntry(background_hist_template , 'QCD', 'l')   \n",
    "leg.AddEntry(signal_hist_template , 'Signal (q = 0.9-1.0)', 'l') \n",
    "c.SetLogy()\n",
    "c.SetTitle('')\n",
    "\n",
    "leg.Draw(\"same\")\n",
    "c.Draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Warning in <TH1D::Sumw2>: Sum of squares of weights structure already created\n",
      "Info in <TCanvas::Print>: pdf file mjj_all.pdf has been created\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Draw \"nice\" ratio plot for paper, check efficiency quantile/template and smoothness\n",
    "import cmsstyle #mplhep for Python2 cheatsheet\n",
    "\n",
    "c_out = rt.TCanvas(\"ratio\", \"\", 1000, 1000)\n",
    "pad1 = rt.TPad(\"pad1\", \"pad1\", 0, 0.3, 1, 1.0)\n",
    "pad1.SetBottomMargin(0.001)\n",
    "pad1.SetLeftMargin(0.13)\n",
    "# pad1.SetGridx()\n",
    "pad1.Draw()\n",
    "pad1.cd()\n",
    "leg = rt.TLegend(0.42, 0.45, 0.89, 0.80)\n",
    "leg.SetNColumns(2)\n",
    "leg.SetTextSize(0.045)\n",
    "leg.SetBorderSize(0)\n",
    "leg.SetFillStyle(0)\n",
    "\n",
    "background_hist_template.Draw('HIST')\n",
    "background_hist_template.SetTitle(\"\")\n",
    "background_hist_template.SetMinimum(0.2)\n",
    "background_hist_template.GetYaxis().SetTitleSize(0.05)\n",
    "background_hist_template.GetYaxis().SetLabelSize(0.05)\n",
    "background_hist_template.GetYaxis().SetTitleOffset(0.95)\n",
    "background_hist_template.SetMaximum(qcd_tot.shape[0]*1.2)\n",
    "background_hist_template.GetYaxis().SetNdivisions(304)\n",
    "# background_hist_template.GetYaxis().SetLabelSize(0.05)\n",
    "# background_hist_template.GetYaxis().SetTitleSize(0.05)\n",
    "# signal_hist_template    .Draw('same HIST')\n",
    "# leg.SetTextSize (0.03)\n",
    "# leg.SetTextFont( 62 )\n",
    "leg.SetHeader('QCD MC:              Narrow G#rightarrowWW:')\n",
    "# leg.SetTextSize (0.03)\n",
    "# leg.SetTextFont( 42 )\n",
    "for i,key in enumerate(sorted(histos_data.keys())):\n",
    "    if i > 0:\n",
    "        lower_bound = sorted(histos_data.keys())[i-1]\n",
    "    else:\n",
    "       lower_bound = 0.0 \n",
    "    histos_data[key].Draw('pez same')\n",
    "    histos_signal[key].Draw('HIST same')\n",
    "    leg.AddEntry(histos_data[key]  , 'q = {} - {}'.format(lower_bound,key), 'lep')\n",
    "    leg.AddEntry(histos_signal[key], 'q = {} - {}'.format(lower_bound,key), 'l')\n",
    "background_hist_template.Draw('same HIST')\n",
    "histos_signal[0.1].Draw('HIST same')\n",
    "histos_signal[0.01].Draw('HIST same')\n",
    "# leg.SetTextSize(0.04)  \n",
    "leg.AddEntry(background_hist_template , 'q = 0.9 - 1.0', 'l') \n",
    "leg.Draw('same')\n",
    "\n",
    "pad1.SetLogy()\n",
    "pad1.SetTitle('')\n",
    "\n",
    "c_out.cd()\n",
    "pad2 = rt.TPad(\"pad2\", \"pad2\", 0, 0, 1, 0.3)\n",
    "pad2.SetTopMargin(0.00)\n",
    "pad2.SetBottomMargin(0.27)\n",
    "pad2.SetLeftMargin(0.13)\n",
    "# pad2.SetGrid()\n",
    "pad2.Draw()\n",
    "pad2.cd()\n",
    "data_hist_ratio = {}\n",
    "tline = {}\n",
    "for i,key in enumerate(sorted(histos_data.keys())):\n",
    "    pad2.cd()\n",
    "    if i > 0:\n",
    "        lower_bound = sorted(histos_data.keys())[i-1]\n",
    "    else:\n",
    "        lower_bound = 0.0 \n",
    "    histos_data[key].Sumw2()\n",
    "    data_hist_ratio[key] = histos_data[key].Clone('data_hist_ratio_{}'.format(i))\n",
    "    background_hist_template.Sumw2()\n",
    "    data_hist_ratio[key].Divide(background_hist_template)\n",
    "    data_hist_ratio[key].Scale(background_hist_template.Integral()/histos_data[key].Integral())\n",
    "    data_hist_ratio[key].binning = bin_edges\n",
    "    if i == 0:\n",
    "        print(i)\n",
    "        data_hist_ratio[key].SetTitle('')\n",
    "        data_hist_ratio[key].Draw('pez')\n",
    "        data_hist_ratio[key].SetMaximum(2.2)\n",
    "        data_hist_ratio[key].SetMinimum(-0.2)\n",
    "        data_hist_ratio[key].SetYTitle('#frac{#epsilon#timesq}{q_{0.9-1.0}}')\n",
    "        data_hist_ratio[key].GetYaxis().CenterTitle()\n",
    "        data_hist_ratio[key].SetXTitle('M_{jj} (GeV)')\n",
    "        data_hist_ratio[key].GetYaxis().SetTitleOffset(0.4)\n",
    "        data_hist_ratio[key].GetYaxis().SetTitleSize(0.12)\n",
    "        data_hist_ratio[key].GetYaxis().SetLabelSize(0.12)\n",
    "        data_hist_ratio[key].GetYaxis().SetNdivisions(304)\n",
    "        data_hist_ratio[key].GetXaxis().SetNdivisions(909)\n",
    "        data_hist_ratio[key].GetXaxis().SetTitleOffset(0.95)\n",
    "        data_hist_ratio[key].GetXaxis().SetTitleSize(0.12)\n",
    "        data_hist_ratio[key].GetXaxis().SetLabelSize(0.12)\n",
    "        data_hist_ratio[key].GetXaxis().SetTickSize(0.07)\n",
    "    else:\n",
    "        data_hist_ratio[key].Draw('pez same')\n",
    "    \n",
    "    \n",
    "#     tline[key] = rt.TLine(min_bin, (key-lower_bound)/0.1, max_bin, (key-lower_bound)/0.1)\n",
    "    tline[key] = rt.TLine(min_bin, 1.0, max_bin, 1.0)\n",
    "    tline[key].SetLineColor(rt.kBlack)\n",
    "    tline[key].SetLineStyle(rt.kDashed)\n",
    "    tline[key].Draw('same')\n",
    "\n",
    "# sig_hist_ratio = signal_hist_acc.Clone('signal_hist_ratio')\n",
    "# sig_hist_ratio.SetTitle('')\n",
    "# sig_hist_ratio.Sumw2()\n",
    "# sig_hist_ratio.Divide(signal_hist_rej)\n",
    "# sig_hist_ratio.binning = bin_edges\n",
    "# data_hist_ratio.Scale(data_hist_rej.Integral()/data_hist_acc.Integral())\n",
    "\n",
    "# sig_hist_ratio.Draw('pez same')\n",
    "c_out.cd()\n",
    "latex = rt.TLatex()\n",
    "latex.SetNDC ()\n",
    "latex.SetTextSize (0.033)\n",
    "latex.SetTextFont( 42 )\n",
    "latex.DrawLatex (0.16 ,0.88 , \"%.0f fb^{-1} dijet events\"%lumi)\n",
    "# latex.SetTextSize (0.03)\n",
    "# latex.SetTextFont( 42 )\n",
    "# latex.DrawLatex(0.17 ,0.83 , \"#Delta#eta_{jj} < 1.3, M_{jj} > 1.2 TeV\")\n",
    "# latex.DrawLatex(0.17 ,0.79 , \"p_{T} > 200 GeV, |#eta| < 2.5\")\n",
    "c_out.Update()\n",
    "c_out.Draw()\n",
    "c_out.SaveAs('mjj_all.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fig = plt.figure()\n",
    "\n",
    "# plt.hist(qcd_template,bins=bin_edges,histtype='step', linewidth=2, facecolor='none', edgecolor='Black',fill=True,density=False)\n",
    "# plt.semilogy()\n",
    "# plt.ylabel(\"Events\")\n",
    "# plt.xlabel(\"$M_{jj}$ (GeV)\")\n",
    "# plt.xlim(bin_edges[0],bin_edges[-1])\n",
    "# # plt.ylim(0.2,1.1)\n",
    "# legend2 = plt.legend(loc='lower right',frameon=False)\n",
    "# legend1 = plt.legend([t1,g1], ['Class = t','Class = g'], loc='center right',frameon=False)\n",
    "# plt.gca().set_prop_cycle(None)\n",
    "# plt.gca().add_artist(legend1)\n",
    "# plt.gca().add_artist(legend2)\n",
    "# plt.show()\n",
    "# fig.tight_layout()\n",
    "# # fig.savefig('roc.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define data for 90-100% quantile (used for control region datacards)\n",
    "histos_data  [1.0] = background_hist_template\n",
    "histos_signal[1.0] = signal_hist_template"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{tabular}{lrrrrrrr}\n",
      "\\toprule\n",
      "          q & $\\sigma$ [fb] & $N_{bkg}$ & $N_{sig}$ & $S/\\sqrt{B}$ & $N_{bkg}$ ($M_{X} \\pm 10\\%$) & $N_{sig}$ ($M_{X} \\pm 10\\%$) & $S/\\sqrt{B}$ ($M_{X} \\pm 10\\%$) \\\\\n",
      "\\midrule\n",
      " 0.0 - 0.01 &             1 &     76808 &         0 &        0.000 &                          380 &                            0 &                            0.00 \\\\\n",
      " 0.0 - 0.01 &            10 &     76808 &         6 &        0.020 &                          380 &                            6 &                            0.30 \\\\\n",
      " 0.0 - 0.01 &            20 &     76808 &        13 &        0.050 &                          380 &                           12 &                            0.60 \\\\\n",
      " 0.0 - 0.01 &            50 &     76808 &        34 &        0.100 &                          380 &                           30 &                            2.00 \\\\\n",
      " 0.0 - 0.01 &           100 &     76808 &        69 &        0.200 &                          380 &                           60 &                            3.00 \\\\\n",
      " 0.01 - 0.1 &             1 &    690749 &         6 &        0.007 &                         3638 &                            5 &                            0.08 \\\\\n",
      " 0.01 - 0.1 &            10 &    690749 &        61 &        0.070 &                         3638 &                           56 &                            0.90 \\\\\n",
      " 0.01 - 0.1 &            20 &    690749 &       123 &        0.100 &                         3638 &                          113 &                            2.00 \\\\\n",
      " 0.01 - 0.1 &            50 &    690749 &       308 &        0.400 &                         3638 &                          283 &                            5.00 \\\\\n",
      " 0.01 - 0.1 &           100 &    690749 &       616 &        0.700 &                         3638 &                          566 &                            9.00 \\\\\n",
      "  0.1 - 0.3 &             1 &   1532650 &         9 &        0.007 &                         8274 &                            8 &                            0.09 \\\\\n",
      "  0.1 - 0.3 &            10 &   1532650 &        91 &        0.070 &                         8274 &                           83 &                            0.90 \\\\\n",
      "  0.1 - 0.3 &            20 &   1532650 &       182 &        0.100 &                         8274 &                          167 &                            2.00 \\\\\n",
      "  0.1 - 0.3 &            50 &   1532650 &       456 &        0.400 &                         8274 &                          419 &                            5.00 \\\\\n",
      "  0.1 - 0.3 &           100 &   1532650 &       913 &        0.700 &                         8274 &                          838 &                            9.00 \\\\\n",
      "  0.3 - 0.5 &             1 &   1535535 &         5 &        0.004 &                         8419 &                            4 &                            0.04 \\\\\n",
      "  0.3 - 0.5 &            10 &   1535535 &        52 &        0.040 &                         8419 &                           46 &                            0.50 \\\\\n",
      "  0.3 - 0.5 &            20 &   1535535 &       105 &        0.080 &                         8419 &                           92 &                            1.00 \\\\\n",
      "  0.3 - 0.5 &            50 &   1535535 &       263 &        0.200 &                         8419 &                          230 &                            3.00 \\\\\n",
      "  0.3 - 0.5 &           100 &   1535535 &       526 &        0.400 &                         8419 &                          461 &                            5.00 \\\\\n",
      "  0.5 - 0.7 &             1 &   1534500 &         3 &        0.002 &                         8358 &                            2 &                            0.02 \\\\\n",
      "  0.5 - 0.7 &            10 &   1534500 &        33 &        0.030 &                         8358 &                           26 &                            0.30 \\\\\n",
      "  0.5 - 0.7 &            20 &   1534500 &        66 &        0.050 &                         8358 &                           53 &                            0.60 \\\\\n",
      "  0.5 - 0.7 &            50 &   1534500 &       166 &        0.100 &                         8358 &                          134 &                            1.00 \\\\\n",
      "  0.5 - 0.7 &           100 &   1534500 &       332 &        0.300 &                         8358 &                          268 &                            3.00 \\\\\n",
      "  0.7 - 0.9 &             1 &   1532280 &         2 &        0.002 &                         8540 &                            1 &                            0.01 \\\\\n",
      "  0.7 - 0.9 &            10 &   1532280 &        23 &        0.020 &                         8540 &                           16 &                            0.20 \\\\\n",
      "  0.7 - 0.9 &            20 &   1532280 &        47 &        0.040 &                         8540 &                           33 &                            0.40 \\\\\n",
      "  0.7 - 0.9 &            50 &   1532280 &       118 &        0.100 &                         8540 &                           83 &                            0.90 \\\\\n",
      "  0.7 - 0.9 &           100 &   1532280 &       237 &        0.200 &                         8540 &                          166 &                            2.00 \\\\\n",
      "  0.9 - 1.0 &             1 &    769152 &         1 &        0.001 &                         4346 &                            0 &                            0.00 \\\\\n",
      "  0.9 - 1.0 &            10 &    769152 &        10 &        0.010 &                         4346 &                            4 &                            0.06 \\\\\n",
      "  0.9 - 1.0 &            20 &    769152 &        20 &        0.020 &                         4346 &                            8 &                            0.10 \\\\\n",
      "  0.9 - 1.0 &            50 &    769152 &        51 &        0.060 &                         4346 &                           22 &                            0.30 \\\\\n",
      "  0.9 - 1.0 &           100 &    769152 &       103 &        0.100 &                         4346 &                           44 &                            0.70 \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: ratio\n",
      "Info in <TCanvas::Print>: pdf file sigInj_all.pdf has been created\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Make data with injected signal!\n",
    "# Do some validation checks and plot data distribution with injected signal.\n",
    "# Also make table with S/sqrt(B) over full dijet range and in mJJ window.\n",
    "\n",
    "data = {'q':[],'q_string':[],'sig_inj':[],'mjjmin':[],  'mjjmax':[], 'NQCD':[], 'NSIG':[],'SB':[],'NQCD_SLICE':[], 'NSIG_SLICE':[],'SB_SLICE':[]}\n",
    "        \n",
    "# These dictionaries will contain the 90-100% quantile with injected signal (data_hist_rej_inj_all)\n",
    "# and the orthogonal quantiles with injected signal (data_hist_acc_inj_all). They will be saved to 'histfile'\n",
    "# The format is data_hist_rej_inj_all[quantile][sig_injected]\n",
    "\n",
    "data_hist_rej_inj_all = {}\n",
    "data_hist_acc_inj_all = {}\n",
    "\n",
    "#Define signal Mjj window as 20% of each side of MX. Only used for drawing purposes and S/sqrt(B) values\n",
    "axis = background_hist_template.GetXaxis()\n",
    "bmin = axis.FindBin(MX*0.8)\n",
    "bmax  = axis.FindBin(MX*1.2)\n",
    "mjjmin = axis.GetBinCenter(bmin)\n",
    "mjjmax = axis.GetBinCenter(bmax)\n",
    "\n",
    "# Helper function to round numbers for TeX table\n",
    "def round_sig(x, sig=1):\n",
    "    if x == 0.:\n",
    "        return 0\n",
    "    else:\n",
    "        return round(x, sig-int(floor(log10(abs(x))))-1)\n",
    "\n",
    "\n",
    "leg = rt.TLegend(0.48, 0.5, 0.89, 0.85)\n",
    "#stick to no injecion for now\n",
    "c_out = rt.TCanvas(\"ratio\", \"\", 1000, 800)\n",
    "pad1 = rt.TPad(\"pad1\", \"pad1\", 0, 0.3, 1, 1.0)\n",
    "pad1.SetBottomMargin(0.001)\n",
    "pad1.SetLeftMargin(0.13)\n",
    "pad1.SetLogy()\n",
    "pad1.SetTitle('')\n",
    "pad1.Draw()\n",
    "pad1.cd()\n",
    "leg = rt.TLegend(0.45, 0.61, 0.89, 0.91)\n",
    "leg.SetNColumns(2)\n",
    "leg.SetTextSize(0.05)\n",
    "leg.SetBorderSize(0)\n",
    "leg.SetFillStyle(0)\n",
    "leg.SetTextSize (0.03)\n",
    "leg.SetTextFont( 62 )\n",
    "leg.SetHeader('SR (#forall q):                  CR (q = 0.9 - 1.0):')\n",
    "leg.SetTextSize (0.03)\n",
    "leg.SetTextFont( 42 )\n",
    "background_hist_template.Draw('HIST')\n",
    "histos_signal[0.01].Draw('HISTsame')\n",
    "background_hist_template.SetTitle(\"\")\n",
    "background_hist_template.SetMinimum(0.2)\n",
    "background_hist_template.SetMaximum(qcd_tot.shape[0]*1.2)\n",
    "background_hist_template.GetYaxis().SetLabelSize(0.05)\n",
    "background_hist_template.GetYaxis().SetTitleSize(0.05)\n",
    "\n",
    "\n",
    "for i,key in enumerate(sorted(histos_data.keys())):\n",
    "    if i > 0:\n",
    "        lower_bound = sorted(histos_data.keys())[i-1]\n",
    "    else:\n",
    "        lower_bound = 0.0 \n",
    "#     if key == 1.0: #To skip reject quantile\n",
    "#        continue\n",
    "    prefix = 'q'+str(int(key*100))\n",
    "#     print(prefix) \n",
    "#     print('Quantile integral = {}'.format(histos_data[key].Integral()))\n",
    "#     print('Template integral = {} (10%efficiency)'.format(background_hist_template.Integral()))\n",
    "#     print('Efficiency= {}'.format(histos_data[key].Integral()/background_hist_template.Integral()))\n",
    "    \n",
    "    data_hist_rej_inj = {}\n",
    "    data_hist_acc_inj = {}\n",
    "    for k,sig_inj in enumerate(sig_inj_vals):\n",
    "        data_hist_rej_inj[sig_inj] = background_hist_template.Clone('background_hist_template_inj{}_{}'.format(sig_inj,prefix))\n",
    "        data_hist_acc_inj[sig_inj] = histos_data[key].Clone('data_hist_acc_inj{}_{}'.format(sig_inj,prefix))\n",
    "        data_hist_rej_inj[sig_inj].Add(signal_hist_template,sig_inj)\n",
    "        data_hist_acc_inj[sig_inj].Add(histos_signal[key],sig_inj)\n",
    "        \n",
    "        # Compute some useful S/B quantities and print as latex table\n",
    "        if sig_inj != 0:\n",
    "            data['q'].append(key)\n",
    "            keystring = '{} - {}'.format(lower_bound,key)\n",
    "            data['q_string'].append(keystring)\n",
    "            data['sig_inj'].append(int(sig_inj*10.))\n",
    "            data['mjjmin'].append(mjjmin)\n",
    "            data['mjjmax'].append(mjjmax)\n",
    "            NQCD       = int(histos_data[key].Integral())\n",
    "            NSIG       = int(data_hist_acc_inj[sig_inj].Integral())-int(histos_data[key].Integral())\n",
    "            SB         = round_sig(NSIG/np.sqrt(NQCD))\n",
    "            NQCD_SLICE = int(histos_data[key].Integral(bmin,bmax))\n",
    "            NSIG_SLICE = int(data_hist_acc_inj[sig_inj].Integral(bmin,bmax))-int(histos_data[key].Integral(bmin,bmax))\n",
    "            SB_SLICE   = round_sig(NSIG_SLICE/np.sqrt(NQCD_SLICE))\n",
    "            data['NQCD'].append(NQCD)\n",
    "            data['NSIG'].append(NSIG)\n",
    "            data['SB'].append(SB)\n",
    "            data['NQCD_SLICE'].append(NQCD_SLICE)\n",
    "            data['NSIG_SLICE'].append(NSIG_SLICE)\n",
    "            data['SB_SLICE'].append(SB_SLICE)\n",
    "        if key != 1.0:\n",
    "            data_hist_acc_inj[sig_inj].SetLineColor(rt.TColor.GetColor(bcol[i]))\n",
    "            data_hist_acc_inj[sig_inj].SetLineStyle(k+1)\n",
    "            data_hist_rej_inj[sig_inj].SetLineStyle(k+1)\n",
    "            data_hist_acc_inj[sig_inj].SetLineWidth(2)\n",
    "            data_hist_rej_inj[sig_inj].SetLineWidth(2)\n",
    "            data_hist_rej_inj[sig_inj].Draw('sameHIST')\n",
    "            data_hist_acc_inj[sig_inj].Draw('sameHIST')\n",
    "        if key == 0.01:\n",
    "            leg.AddEntry(data_hist_acc_inj[sig_inj],'Inj. #sigma = {} fb'.format(int(sig_inj*10.)),'l')\n",
    "            leg.AddEntry(data_hist_rej_inj[sig_inj],'Inj. #sigma = {} fb'.format(int(sig_inj*10.)),'l')\n",
    "            \n",
    "        \n",
    "    data_hist_rej_inj_all[key] = data_hist_rej_inj\n",
    "    data_hist_acc_inj_all[key] = data_hist_acc_inj\n",
    "    \n",
    "dataP = pandas.DataFrame(data)\n",
    "dataP.to_pickle('Yields.pkl')\n",
    "print(dataP.to_latex(columns=['q_string','sig_inj','NQCD','NSIG','SB','NQCD_SLICE','NSIG_SLICE','SB_SLICE'],header=['q','$\\sigma$ [fb]','$N_{bkg}$','$N_{sig}$','$S/\\sqrt{B}$','$N_{bkg}$ ($M_{X} \\pm 10\\%$)','$N_{sig}$ ($M_{X} \\pm 10\\%$)','$S/\\sqrt{B}$ ($M_{X} \\pm 10\\%$)'],index=False,escape=False)) \n",
    "leg2 = rt.TLegend(0.18, 0.12, 0.3, 0.2)\n",
    "leg2.SetBorderSize(0)\n",
    "leg2.SetFillStyle(0)\n",
    "leg2.SetTextSize (0.04)\n",
    "leg2.SetTextFont( 42 )\n",
    "leg2.AddEntry(histos_signal[0.01],'G (M = 3.5 TeV) #rightarrow WW','l')\n",
    "leg2.AddEntry(None,'(q = 0.01, #sigma = 10 fb)','')\n",
    "leg2.Draw('same')\n",
    "c_out.Update()\n",
    "\n",
    "\n",
    "# Add ratio SRinj/CRinj\n",
    "c_out.cd()\n",
    "pad2 = rt.TPad(\"pad2\", \"pad2\", 0, 0, 1, 0.3)\n",
    "pad2.SetTopMargin(0.00)\n",
    "pad2.SetBottomMargin(0.27)\n",
    "pad2.SetLeftMargin(0.13)\n",
    "# pad2.SetGrid()\n",
    "pad2.Draw()\n",
    "pad2.cd()\n",
    "data_hist_ratio_all = {}\n",
    "tline = {}\n",
    "for i,key in enumerate(sorted(histos_data.keys())):\n",
    "    if key == 1.0:\n",
    "        continue\n",
    "    data_hist_ratio = {}\n",
    "    pad2.cd()\n",
    "    if i > 0:\n",
    "        lower_bound = sorted(histos_data.keys())[i-1]\n",
    "    else:\n",
    "        lower_bound = 0.0 \n",
    "    \n",
    "    for k,sig_inj in enumerate(sig_inj_vals):\n",
    "        \n",
    "        data_hist_ratio[sig_inj] = data_hist_acc_inj_all[key][sig_inj].Clone('data_hist_ratio_{}{}'.format(i,k))\n",
    "        data_hist_ratio[sig_inj].Divide(data_hist_rej_inj_all[key][sig_inj])\n",
    "        data_hist_ratio[sig_inj].binning = bin_edges\n",
    "\n",
    "        if k == 0 and i == 0:\n",
    "            data_hist_ratio[sig_inj].SetTitle('')\n",
    "            data_hist_ratio[sig_inj].Draw('pez')\n",
    "            data_hist_ratio[sig_inj].SetMaximum(2.8)\n",
    "            data_hist_ratio[sig_inj].SetMinimum(0.0)\n",
    "            data_hist_ratio[sig_inj].SetYTitle('#frac{Data+S_{in}}{Template+S_{in}}')\n",
    "            data_hist_ratio[sig_inj].GetYaxis().SetTitleOffset(0.5)\n",
    "            data_hist_ratio[sig_inj].GetYaxis().SetTitleSize(0.12)\n",
    "            data_hist_ratio[sig_inj].GetYaxis().SetLabelSize(0.12)\n",
    "            data_hist_ratio[sig_inj].GetYaxis().SetNdivisions(506)\n",
    "            data_hist_ratio[sig_inj].GetXaxis().SetNdivisions(506)\n",
    "            data_hist_ratio[sig_inj].GetXaxis().SetTitleOffset(0.95)\n",
    "            data_hist_ratio[sig_inj].GetXaxis().SetTitleSize(0.12)\n",
    "            data_hist_ratio[sig_inj].GetXaxis().SetLabelSize(0.12)\n",
    "            data_hist_ratio[sig_inj].GetXaxis().SetTickSize(0.07)\n",
    "        else:\n",
    "            data_hist_ratio[sig_inj].Draw('pez same')\n",
    "    \n",
    "    data_hist_ratio_all[key] = data_hist_ratio\n",
    "    \n",
    "    tline[key] = rt.TLine(min_bin, (key-lower_bound)/0.1, max_bin, (key-lower_bound)/0.1)\n",
    "    tline[key].SetLineColor(rt.kBlack)\n",
    "    tline[key].SetLineStyle(rt.kDashed)\n",
    "    tline[key].Draw('same')\n",
    "\n",
    "vlineDown = rt.TLine(mjjmin, 0.0, mjjmin, 2.8)\n",
    "vlineDown.SetLineColor(rt.TColor.GetColor(scol[0]))\n",
    "vlineDown.SetLineStyle(rt.kDashed)\n",
    "vlineDown.Draw('same')\n",
    "vlineUp = rt.TLine(mjjmax, 0.0, mjjmax, 2.8)\n",
    "vlineUp.SetLineColor(rt.TColor.GetColor(scol[0]))\n",
    "vlineUp.SetLineStyle(rt.kDashed)\n",
    "vlineUp.Draw('same')\n",
    "c_out.cd()\n",
    "\n",
    "\n",
    "latex = rt.TLatex()\n",
    "latex.SetNDC ()\n",
    "latex.SetTextSize (0.03)\n",
    "latex.SetTextFont( 62 )\n",
    "latex.DrawLatex (0.17 ,0.87 , \"%.1f fb^{-1} dijet events\"%lumi)\n",
    "latex.SetTextSize (0.03)\n",
    "latex.SetTextFont( 42 )\n",
    "latex.DrawLatex(0.17 ,0.83 , \"#Delta#eta_{jj} < 1.3, M_{jj} > 1246 GeV\")\n",
    "latex.DrawLatex(0.17 ,0.79 , \"p_{T} > 200 GeV, |#eta| < 2.5\")\n",
    "c_out.Update()\n",
    "c_out.Draw()\n",
    "leg.Draw('same')\n",
    "c_out.SaveAs('sigInj_all.pdf')\n",
    "\n",
    "\n",
    "leg.Draw('same')\n",
    "c_out.Draw()       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantile=0.01 signalInj=0\n",
      "data_acc_inj0fb_q1percent: 76808.0 events\n",
      "Quantile=0.01 signalInj=1\n",
      "data_acc_inj1fb_q1percent: 76808.6993869 events\n",
      "Quantile=0.01 signalInj=10\n",
      "data_acc_inj10fb_q1percent: 76814.993869 events\n",
      "Quantile=0.01 signalInj=20\n",
      "data_acc_inj20fb_q1percent: 76821.987738 events\n",
      "Quantile=0.01 signalInj=50\n",
      "data_acc_inj50fb_q1percent: 76842.969345 events\n",
      "Quantile=0.01 signalInj=100\n",
      "data_acc_inj100fb_q1percent: 76877.9386901 events\n",
      "Quantile=0.1 signalInj=0\n",
      "data_acc_inj0fb_q10percent: 690749.0 events\n",
      "Quantile=0.1 signalInj=1\n",
      "data_acc_inj1fb_q10percent: 690755.168948 events\n",
      "Quantile=0.1 signalInj=10\n",
      "data_acc_inj10fb_q10percent: 690810.689484 events\n",
      "Quantile=0.1 signalInj=20\n",
      "data_acc_inj20fb_q10percent: 690872.378968 events\n",
      "Quantile=0.1 signalInj=50\n",
      "data_acc_inj50fb_q10percent: 691057.447421 events\n",
      "Quantile=0.1 signalInj=100\n",
      "data_acc_inj100fb_q10percent: 691365.894842 events\n",
      "Quantile=0.3 signalInj=0\n",
      "data_acc_inj0fb_q30percent: 1532650.0 events\n",
      "Quantile=0.3 signalInj=1\n",
      "data_acc_inj1fb_q30percent: 1532659.13126 events\n",
      "Quantile=0.3 signalInj=10\n",
      "data_acc_inj10fb_q30percent: 1532741.31259 events\n",
      "Quantile=0.3 signalInj=20\n",
      "data_acc_inj20fb_q30percent: 1532832.62518 events\n",
      "Quantile=0.3 signalInj=50\n",
      "data_acc_inj50fb_q30percent: 1533106.56295 events\n",
      "Quantile=0.3 signalInj=100\n",
      "data_acc_inj100fb_q30percent: 1533563.1259 events\n",
      "Quantile=0.5 signalInj=0\n",
      "data_acc_inj0fb_q50percent: 1535535.0 events\n",
      "Quantile=0.5 signalInj=1\n",
      "data_acc_inj1fb_q50percent: 1535540.26183 events\n",
      "Quantile=0.5 signalInj=10\n",
      "data_acc_inj10fb_q50percent: 1535587.61831 events\n",
      "Quantile=0.5 signalInj=20\n",
      "data_acc_inj20fb_q50percent: 1535640.23661 events\n",
      "Quantile=0.5 signalInj=50\n",
      "data_acc_inj50fb_q50percent: 1535798.09153 events\n",
      "Quantile=0.5 signalInj=100\n",
      "data_acc_inj100fb_q50percent: 1536061.18307 events\n",
      "Quantile=0.7 signalInj=0\n",
      "data_acc_inj0fb_q70percent: 1534500.0 events\n",
      "Quantile=0.7 signalInj=1\n",
      "data_acc_inj1fb_q70percent: 1534503.32701 events\n",
      "Quantile=0.7 signalInj=10\n",
      "data_acc_inj10fb_q70percent: 1534533.27011 events\n",
      "Quantile=0.7 signalInj=20\n",
      "data_acc_inj20fb_q70percent: 1534566.54022 events\n",
      "Quantile=0.7 signalInj=50\n",
      "data_acc_inj50fb_q70percent: 1534666.35056 events\n",
      "Quantile=0.7 signalInj=100\n",
      "data_acc_inj100fb_q70percent: 1534832.70112 events\n",
      "Quantile=0.9 signalInj=0\n",
      "data_acc_inj0fb_q90percent: 1532280.0 events\n",
      "Quantile=0.9 signalInj=1\n",
      "data_acc_inj1fb_q90percent: 1532282.37182 events\n",
      "Quantile=0.9 signalInj=10\n",
      "data_acc_inj10fb_q90percent: 1532303.71818 events\n",
      "Quantile=0.9 signalInj=20\n",
      "data_acc_inj20fb_q90percent: 1532327.43636 events\n",
      "Quantile=0.9 signalInj=50\n",
      "data_acc_inj50fb_q90percent: 1532398.59089 events\n",
      "Quantile=0.9 signalInj=100\n",
      "data_acc_inj100fb_q90percent: 1532517.18178 events\n",
      "Quantile=1.0 signalInj=0\n",
      "data_acc_inj0fb_q100percent: 769152.0 events\n",
      "Quantile=1.0 signalInj=1\n",
      "data_acc_inj1fb_q100percent: 769153.038496 events\n",
      "Quantile=1.0 signalInj=10\n",
      "data_acc_inj10fb_q100percent: 769162.384963 events\n",
      "Quantile=1.0 signalInj=20\n",
      "data_acc_inj20fb_q100percent: 769172.769927 events\n",
      "Quantile=1.0 signalInj=50\n",
      "data_acc_inj50fb_q100percent: 769203.924817 events\n",
      "Quantile=1.0 signalInj=100\n",
      "data_acc_inj100fb_q100percent: 769255.849634 events\n"
     ]
    }
   ],
   "source": [
    "# Make sure the data is correctly created and store all histograms to file (will be imported to workspace below)\n",
    "\n",
    "outfile = rt.TFile(histfile, 'RECREATE' )\n",
    "\n",
    "signal_hist_template.Write('signal_template')\n",
    "background_hist_template.Write('background_template')\n",
    "for i,qkey in enumerate(sorted(data_hist_acc_inj_all.keys())):\n",
    "    quantile = int(qkey*100)\n",
    "    histos_signal[qkey].Write('signal_q{}percent'.format(quantile))\n",
    "    histos_data[qkey].Write('background_q{}percent'.format(quantile))\n",
    "    for i,skey in enumerate(sorted(data_hist_acc_inj_all[key])):\n",
    "        injected = int(skey*10.)\n",
    "        prefix = 'inj{}fb_q{}percent'.format(injected,quantile)\n",
    "        print('Quantile={} signalInj={}'.format(qkey,injected))\n",
    "        print('{}: {} events'.format('data_acc_{}'.format(prefix),data_hist_acc_inj_all[qkey][skey].Integral()))\n",
    "        data_hist_acc_inj_all[qkey][skey].Write('data_acc_{}'.format(prefix))\n",
    "        data_hist_rej_inj_all[qkey][skey].Write('data_rej_{}'.format(prefix))\n",
    "\n",
    "\n",
    "outfile.Close()        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def makeWS(data_rej,data_acc,signal_rej,signal_acc, outname, quantile,injectedSignal):\n",
    "  \n",
    "  efficiency = data_acc.Integral()/data_rej.Integral() #How much rej histogram needs to be scaled to match acc\n",
    "  print('Using efficiency = {} '.format(efficiency))\n",
    "  \n",
    "  xaxis = data_acc.GetXaxis().GetXbins()\n",
    "  min_bin = xaxis[0]\n",
    "  max_bin = xaxis[len(xaxis)-1]\n",
    "  n_bins  = len(xaxis)-1\n",
    "  # set up workspace\n",
    "  datacard_ws = rt.TFile.Open(outname,'recreate')\n",
    "  w = rt.RooWorkspace('w','w')\n",
    "  x = rt.RooRealVar('x','x',min_bin,max_bin)\n",
    "  w.factory('x[%.1f,%.1f]'%(min_bin, max_bin))\n",
    "\n",
    "  acc_bin_functions = rt.RooArgList()\n",
    "  rej_bin_functions = rt.RooArgList()\n",
    "  w.factory('eff[%f]'%(efficiency))\n",
    "  w.var('eff').setConstant(True)\n",
    "\n",
    "  empty_hist = rt.TH1D('empty_hist','empty_hist', data_rej.GetNbinsX(), data_rej.GetXaxis().GetXbins().GetArray())\n",
    "  # empty_hist = rt.TH1D('empty_hist','empty_hist', n_bins, min_bin, max_bin)\n",
    "  for iBinX in range(1,data_rej.GetNbinsX()+1):\n",
    "      empty_hist.SetBinContent(iBinX,1)\n",
    "      w.factory('crBin%i_In[%.1f]'%(iBinX,data_rej.GetBinContent(iBinX)))\n",
    "      w.factory('crBin%i[0,-100,100]'%(iBinX))\n",
    "      w.var('crBin%i_In'%iBinX).setConstant(True)\n",
    "      w.var('crBin%i'%iBinX).setConstant(False)\n",
    "      if data_rej.GetBinContent(iBinX) !=  0.:\n",
    "        power = 1/rt.TMath.Sqrt(data_rej.GetBinContent(iBinX))\n",
    "      else:\n",
    "        power = -1.0\n",
    "        w.var('crBin%i'%iBinX).setConstant(True)\n",
    "      #what is fit is actually (mjj+mjj/sqrt(mjj))^x_bin, meaning x_bin is representative of how many sigma acc is from rej\n",
    "      w.factory(\"expr::crBin%iFunc('max(0,@0*pow(1.0+%f,@1))',crBin%i_In,crBin%i)\"%(iBinX,power,iBinX,iBinX))\n",
    "      # w.factory(\"expr::crBin%iFunc('max(0,@0*pow(1.0+%f,@1))',crBin%i_In,crBin%i)\"%(iBinX,1/rt.TMath.Sqrt(data_rej.GetBinContent(iBinX)),iBinX,iBinX))\n",
    "      w.factory(\"expr::bin%iFunc('max(0,@0*@1)',eff,crBin%iFunc)\"%(iBinX,iBinX))\n",
    "      rej_bin_functions.add(w.function('crBin%iFunc'%iBinX))\n",
    "      acc_bin_functions.add(w.function('bin%iFunc'%iBinX))\n",
    "    \n",
    "  qcd_rph_rej = rt.RooParametricHist('background_rej','background_rej',w.var('x'),rej_bin_functions,empty_hist)\n",
    "  qcd_rph_rej_norm = rt.RooAddition('background_rej_norm','background_rej_norm',rej_bin_functions)\n",
    "  qcd_rph_acc = rt.RooParametricHist('background_acc','background_acc',w.var('x'),acc_bin_functions,empty_hist)\n",
    "  qcd_rph_acc_norm = rt.RooAddition('background_acc_norm','background_acc_norm',acc_bin_functions)\n",
    "  getattr(w,'import')(qcd_rph_rej, rt.RooCmdArg())\n",
    "  getattr(w,'import')(qcd_rph_rej_norm, rt.RooFit.RecycleConflictNodes())\n",
    "  getattr(w,'import')(qcd_rph_acc, rt.RooCmdArg())\n",
    "  getattr(w,'import')(qcd_rph_acc_norm, rt.RooFit.RecycleConflictNodes())\n",
    "\n",
    "  ds_signal_acc = rt.RooDataHist('signal_acc','signal_acc',rt.RooArgList(w.var('x')),signal_acc)\n",
    "  ds_signal_rej = rt.RooDataHist('signal_rej','signal_rej',rt.RooArgList(w.var('x')),signal_rej)\n",
    "  getattr(w,'import')(ds_signal_acc, rt.RooCmdArg())\n",
    "  getattr(w,'import')(ds_signal_rej, rt.RooCmdArg())\n",
    "\n",
    "  ds_data_acc = rt.RooDataHist('data_obs_acc','data_obs_acc',rt.RooArgList(w.var('x')),data_acc)\n",
    "  ds_data_rej = rt.RooDataHist('data_obs_rej','data_obs_rej',rt.RooArgList(w.var('x')),data_rej)\n",
    "  getattr(w,'import')(ds_data_acc, rt.RooCmdArg())\n",
    "  getattr(w,'import')(ds_data_rej, rt.RooCmdArg())\n",
    "\n",
    "  datacard_ws.cd()\n",
    "  w.Write()\n",
    "  datacard_ws.Close()\n",
    "\n",
    "  # w.Print('v')\n",
    "  \n",
    "  datacard_ratio = \\\n",
    "  '''\n",
    "  imax 1\n",
    "  jmax 1\n",
    "  kmax *\n",
    "  ---------------\n",
    "  shapes * * {WS} w:$PROCESS_$CHANNEL w:$PROCESS_$CHANNEL_$SYSTEMATIC\n",
    "  ---------------\n",
    "  bin {BIN}\n",
    "  observation {OBS}\n",
    "  ------------------------------\n",
    "  bin             {BIN}      {BIN}\n",
    "  process         signal     background\n",
    "  process         0          1\n",
    "  rate            {SIGRATE}    {BKGRATE}\n",
    "  --------------------------------\n",
    "  lumi lnN 1.01 -\n",
    "  eff   flatParam\n",
    "  '''\n",
    "\n",
    "  for i in range(1,n_bins+1):\n",
    "      datacard_ratio += 'crBin%i   flatParam\\n'%i\n",
    "  \n",
    "  # write datacard\n",
    "  datacard_ratio_acc = datacard_ratio.format(BIN='acc',\n",
    "                            OBS=-1,\n",
    "                            BKGRATE=1,\n",
    "                            SIGRATE=signal_acc.Integral(),\n",
    "                            WS=outname)\n",
    "  print(datacard_ratio_acc)\n",
    "  with open(outname.replace('.root','_acc.txt'),'w') as f:\n",
    "      f.write(datacard_ratio_acc)\n",
    "    \n",
    "    \n",
    "  datacard_ratio_rej = datacard_ratio.format(BIN='rej',\n",
    "                            OBS=-1,\n",
    "                            BKGRATE=1,\n",
    "                            SIGRATE=signal_rej.Integral(),\n",
    "                            WS=outname)\n",
    "  print(datacard_ratio_rej)\n",
    "  with open(outname.replace('.root','_rej.txt'),'w') as f:\n",
    "      f.write(datacard_ratio_rej)\n",
    "  os.system('combineCards.py rej={REJ} acc={ACC} > {RATIO}'.format(REJ=outname.replace('.root','_rej.txt'),ACC=outname.replace('.root','_acc.txt'),RATIO=outname.replace('.root','_ratio.txt')))\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using efficiency = 0.0998606257281 \n",
      "\n",
      "  imax 1\n",
      "  jmax 1\n",
      "  kmax *\n",
      "  ---------------\n",
      "  shapes * * datacard_ws_inj0fb_q1percent.root w:$PROCESS_$CHANNEL w:$PROCESS_$CHANNEL_$SYSTEMATIC\n",
      "  ---------------\n",
      "  bin acc\n",
      "  observation -1\n",
      "  ------------------------------\n",
      "  bin             acc      acc\n",
      "  process         signal     background\n",
      "  process         0          1\n",
      "  rate            6.99386900595    1\n",
      "  --------------------------------\n",
      "  lumi lnN 1.01 -\n",
      "  eff   flatParam\n",
      "  crBin1   flatParam\n",
      "crBin2   flatParam\n",
      "crBin3   flatParam\n",
      "crBin4   flatParam\n",
      "crBin5   flatParam\n",
      "crBin6   flatParam\n",
      "crBin7   flatParam\n",
      "crBin8   flatParam\n",
      "crBin9   flatParam\n",
      "crBin10   flatParam\n",
      "crBin11   flatParam\n",
      "crBin12   flatParam\n",
      "crBin13   flatParam\n",
      "crBin14   flatParam\n",
      "crBin15   flatParam\n",
      "crBin16   flatParam\n",
      "crBin17   flatParam\n",
      "crBin18   flatParam\n",
      "crBin19   flatParam\n",
      "crBin20   flatParam\n",
      "crBin21   flatParam\n",
      "crBin22   flatParam\n",
      "crBin23   flatParam\n",
      "crBin24   flatParam\n",
      "crBin25   flatParam\n",
      "crBin26   flatParam\n",
      "crBin27   flatParam\n",
      "crBin28   flatParam\n",
      "crBin29   flatParam\n",
      "crBin30   flatParam\n",
      "crBin31   flatParam\n",
      "crBin32   flatParam\n",
      "crBin33   flatParam\n",
      "crBin34   flatParam\n",
      "crBin35   flatParam\n",
      "crBin36   flatParam\n",
      "crBin37   flatParam\n",
      "crBin38   flatParam\n",
      "crBin39   flatParam\n",
      "crBin40   flatParam\n",
      "crBin41   flatParam\n",
      "crBin42   flatParam\n",
      "crBin43   flatParam\n",
      "\n",
      "\n",
      "  imax 1\n",
      "  jmax 1\n",
      "  kmax *\n",
      "  ---------------\n",
      "  shapes * * datacard_ws_inj0fb_q1percent.root w:$PROCESS_$CHANNEL w:$PROCESS_$CHANNEL_$SYSTEMATIC\n",
      "  ---------------\n",
      "  bin rej\n",
      "  observation -1\n",
      "  ------------------------------\n",
      "  bin             rej      rej\n",
      "  process         signal     background\n",
      "  process         0          1\n",
      "  rate            10.3849634494    1\n",
      "  --------------------------------\n",
      "  lumi lnN 1.01 -\n",
      "  eff   flatParam\n",
      "  crBin1   flatParam\n",
      "crBin2   flatParam\n",
      "crBin3   flatParam\n",
      "crBin4   flatParam\n",
      "crBin5   flatParam\n",
      "crBin6   flatParam\n",
      "crBin7   flatParam\n",
      "crBin8   flatParam\n",
      "crBin9   flatParam\n",
      "crBin10   flatParam\n",
      "crBin11   flatParam\n",
      "crBin12   flatParam\n",
      "crBin13   flatParam\n",
      "crBin14   flatParam\n",
      "crBin15   flatParam\n",
      "crBin16   flatParam\n",
      "crBin17   flatParam\n",
      "crBin18   flatParam\n",
      "crBin19   flatParam\n",
      "crBin20   flatParam\n",
      "crBin21   flatParam\n",
      "crBin22   flatParam\n",
      "crBin23   flatParam\n",
      "crBin24   flatParam\n",
      "crBin25   flatParam\n",
      "crBin26   flatParam\n",
      "crBin27   flatParam\n",
      "crBin28   flatParam\n",
      "crBin29   flatParam\n",
      "crBin30   flatParam\n",
      "crBin31   flatParam\n",
      "crBin32   flatParam\n",
      "crBin33   flatParam\n",
      "crBin34   flatParam\n",
      "crBin35   flatParam\n",
      "crBin36   flatParam\n",
      "crBin37   flatParam\n",
      "crBin38   flatParam\n",
      "crBin39   flatParam\n",
      "crBin40   flatParam\n",
      "crBin41   flatParam\n",
      "crBin42   flatParam\n",
      "crBin43   flatParam\n",
      "\n",
      "Obs gof = 80.0381165668\n",
      "Exp gof (mean) = 44.8081189856\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) importing RooParametricHist::background_rej\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) importing RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin1Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin1_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin1 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin2Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin2_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin2 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin3Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin3_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin3 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin4Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin4_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin4 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin5Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin5_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin5 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin6Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin6_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin6 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin7Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin7_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin7 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin8Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin8_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin8 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin9Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin9_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin9 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin10Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin10_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin10 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin11Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin11_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin11 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin12Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin12_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin12 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin13Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin13_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin13 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin14Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin14_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin14 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin15Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin15_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin15 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin16Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin16_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin16 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin17Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin17_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin17 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin18Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin18_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin18 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin19Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin19_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin19 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin20Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin20_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin20 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin21Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin21_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin21 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin22Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin22_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin22 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin23Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin23_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin23 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin24Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin24_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin24 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin25Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin25_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin25 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin26Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin26_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin26 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin27Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin27_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin27 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin28Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin28_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin28 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin29Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin29_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin29 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin30Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin30_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin30 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin31Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin31_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin31 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin32Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin32_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin32 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin33Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin33_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin33 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin34Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin34_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin34 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin35Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin35_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin35 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin36Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin36_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin36 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin37Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin37_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin37 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin38Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin38_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin38 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin39Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin39_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin39 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin40Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin40_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin40 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin41Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin41_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin41 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin42Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin42_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin42 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin43Func for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin43_In for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin43 for import of RooAddition::background_rej_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) importing RooParametricHist::background_acc\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) importing RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin1Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::eff for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin1Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin1_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin1 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin2Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin2Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin2_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin2 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin3Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin3Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin3_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin3 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin4Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin4Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin4_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin4 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin5Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin5Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin5_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin5 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin6Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin6Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin6_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin6 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin7Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin7Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin7_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin7 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin8Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin8Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin8_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin8 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin9Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin9Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin9_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin9 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin10Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin10Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin10_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin10 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin11Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin11Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin11_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin11 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin12Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin12Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin12_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin12 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin13Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin13Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin13_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin13 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin14Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin14Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin14_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin14 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin15Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin15Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin15_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin15 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin16Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin16Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin16_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin16 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin17Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin17Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin17_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin17 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin18Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin18Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin18_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin18 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin19Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin19Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin19_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin19 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin20Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin20Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin20_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin20 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin21Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin21Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin21_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin21 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin22Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin22Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin22_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin22 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin23Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin23Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin23_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin23 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin24Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin24Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin24_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin24 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin25Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin25Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin25_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin25 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin26Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin26Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin26_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin26 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin27Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin27Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin27_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin27 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin28Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin28Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin28_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin28 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin29Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin29Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin29_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin29 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin30Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin30Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin30_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin30 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin31Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin31Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin31_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin31 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin32Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin32Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin32_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin32 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin33Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin33Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin33_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin33 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin34Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin34Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin34_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin34 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin35Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin35Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin35_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin35 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin36Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin36Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin36_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin36 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin37Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin37Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin37_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin37 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin38Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin38Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin38_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin38 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin39Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin39Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin39_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin39 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin40Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin40Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin40_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin40 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin41Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin41Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin41_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin41 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin42Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin42Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin42_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin42 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::bin43Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooFormulaVar::crBin43Func for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin43_In for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) using existing copy of RooRealVar::crBin43 for import of RooAddition::background_acc_norm\n",
      "[#1] INFO:DataHandling -- RooDataHist::adjustBinning(signal_acc): fit range of variable x expanded to nearest bin boundaries: [1200,5500] --> [1200,5500]\n",
      "[#1] INFO:DataHandling -- RooDataHist::adjustBinning(signal_rej): fit range of variable x expanded to nearest bin boundaries: [1200,5500] --> [1200,5500]\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) importing dataset signal_acc\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) importing dataset signal_rej\n",
      "[#1] INFO:DataHandling -- RooDataHist::adjustBinning(data_obs_acc): fit range of variable x expanded to nearest bin boundaries: [1200,5500] --> [1200,5500]\n",
      "[#1] INFO:DataHandling -- RooDataHist::adjustBinning(data_obs_rej): fit range of variable x expanded to nearest bin boundaries: [1200,5500] --> [1200,5500]\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) importing dataset data_obs_acc\n",
      "[#1] INFO:ObjectHandling -- RooWorkspace::import(w) importing dataset data_obs_rej\n",
      " <<< Combine >>> \n",
      "Will use saturated models to compute goodness of fit for a binned likelihood\n",
      ">>> method used is GoodnessOfFit\n",
      ">>> random number generator seed is 123456\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 80.0381\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      " <<< Combine >>> \n",
      "Will use saturated models to compute goodness of fit for a binned likelihood\n",
      ">>> method used is GoodnessOfFit\n",
      ">>> random number generator seed is 40\n",
      "Generate toy 1/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 35.3386\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 2/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 65.7574\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 3/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 44.857\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 4/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 35.4397\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 5/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 46.6152\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 6/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 37.5192\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 7/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 29.6248\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 8/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 61.7597\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 9/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 53.1073\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 10/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 41.758\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 11/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 47.8349\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 12/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 26.0478\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 13/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 46.7423\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 14/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 55.7234\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 15/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 64.7506\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 16/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 48.3353\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 17/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 45.4825\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 18/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 55.2441\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 19/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 30.9556\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 20/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 49.3786\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 21/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 46.1622\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 22/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 34.5151\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 23/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 62.2481\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 24/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 44.8377\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 25/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 45.7485\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 26/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 37.7678\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 27/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 38.8526\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 28/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 48.1405\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 29/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 47.4216\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 30/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 51.8861\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 31/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 40.3096\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 32/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 38.8993\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 33/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 54.6386\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 34/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 57.7693\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 35/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 41.685\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 36/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 26.3396\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 37/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 56.4589\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 38/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 51.5284\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 39/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 52.5447\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 40/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 45.1299\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 41/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 48.5596\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 42/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 38.958\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 43/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 55.1162\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 44/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 44.4945\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 45/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 37.4693\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 46/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 34.5268\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 47/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 39.7566\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 48/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 46.3696\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 49/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 39.3705\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 50/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 37.0914\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 51/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 33.1896\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 52/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 50.014\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 53/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 48.9086\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 54/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 36.7695\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 55/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 48.9693\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 56/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 44.4788\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 57/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 36.9298\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 58/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 53.4998\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 59/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 41.1265\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 60/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 40.803\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 61/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 34.661\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 62/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 39.2314\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 63/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 56.5357\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 64/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 47.4677\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 65/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 41.6074\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 66/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 49.0427\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 67/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 68.5584\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 68/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 47.196\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 69/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 42.8047\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 70/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 43.6804\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 71/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 34.9975\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 72/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 44.0081\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 73/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 76.1342\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 74/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 32.9879\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 75/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 40.9968\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 76/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 45.5213\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 77/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 55.2355\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 78/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 44.0611\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 79/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 65.6411\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 80/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 40.3424\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 81/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 39.9872\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 82/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 36.4232\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 83/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 50.1893\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 84/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 42.0004\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 85/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 36.6818\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 86/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 40.4551\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 87/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 29.7469\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 88/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 45.0956\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 89/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 41.0989\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 90/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 44.7635\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 91/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 42.9086\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 92/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 41.5029\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 93/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 45.5361\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 94/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 57.1877\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 95/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 43.2957\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 96/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 41.7156\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 97/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 49.1921\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 98/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 48.9782\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 99/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 44.3771\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 100/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 47.1959\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 101/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 36.9416\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 102/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 51.6008\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 103/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 36.8843\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 104/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 44.8564\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 105/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 45.2239\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 106/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 40.343\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 107/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 55.5537\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 108/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 39.365\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 109/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 34.5868\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 110/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 48.062\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 111/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 41.5845\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 112/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 42.8554\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 113/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 55.7825\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 114/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 44.8734\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 115/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 46.9349\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 116/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 36.4508\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 117/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 54.1089\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 118/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 43.0193\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 119/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 52.8522\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 120/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 33.7359\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 121/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 50.2369\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 122/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 41.049\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 123/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 25.25\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 124/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 34.4124\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 125/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 57.7472\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 126/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 54.8726\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 127/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 47.005\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 128/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 37.2055\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 129/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 37.3882\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 130/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 56.7893\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 131/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 48.7083\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 132/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 38.1136\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 133/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 38.2681\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 134/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 60.9894\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 135/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 43.0377\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 136/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 31.4559\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 137/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 28.995\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 138/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 41.6792\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 139/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 42.9628\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 140/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 35.0753\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 141/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 43.9747\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 142/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 38.5029\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 143/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 36.8319\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 144/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 31.8684\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 145/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 45.3136\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 146/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 33.4759\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 147/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 62.4836\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 148/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 50.8424\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 149/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 39.1766\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 150/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 49.4469\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 151/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 42.3349\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 152/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 51.2143\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 153/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 45.5033\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 154/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 46.4538\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 155/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 44.8244\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 156/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 49.5503\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 157/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 38.8268\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 158/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 40.7623\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 159/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 61.3034\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 160/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 42.7522\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 161/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 47.9843\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 162/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 31.0334\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 163/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 57.5701\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 164/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 41.8421\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 165/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 36.1089\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 166/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 35.279\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 167/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 48.4778\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 168/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 37.1082\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 169/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 25.4703\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 170/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 28.1935\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 171/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 53.0054\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 172/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 56.9512\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 173/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 41.5164\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 174/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 43.1702\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 175/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 46.9843\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 176/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 43.0526\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 177/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 46.6001\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 178/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 44.4888\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 179/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 31.9057\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 180/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 57.5103\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 181/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 43.4214\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 182/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 58.2855\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 183/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 45.5813\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 184/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 39.5182\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 185/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 40.066\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 186/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 61.7798\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 187/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 64.6869\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 188/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 49.6496\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 189/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 49.478\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 190/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 41.1339\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 191/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 45.7173\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 192/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 39.3877\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 193/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 37.5772\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 194/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 63.5981\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 195/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 38.5849\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 196/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 48.4412\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 197/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 35.2097\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 198/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 52.7103\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 199/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 47.8779\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "Generate toy 200/200\n",
      "\n",
      " --- GoodnessOfFit --- \n",
      "Best fit test statistic: 51.7671\n",
      "Done in 0.00 min (cpu), 0.00 min (real)\n",
      "mean   expected limit: r < 44.8081 +/- 0.629905 @ 95%CL (200 toyMC)\n",
      "median expected limit: r < 44.4279 @ 95%CL (200 toyMC)\n",
      "   68% expected band : 36.7695 < r < 54.1089\n",
      "   95% expected band : 28.995 < r < 64.7506\n",
      "hadd Target file: higgsCombineRatio_gof_toys_inj0fb_q1percent.GoodnessOfFit.mH120.ALLTOYS.root\n",
      "hadd compression setting for all ouput: 1\n",
      "hadd Source file 1: higgsCombineRatio_gof_toys_inj0fb_q1percent.GoodnessOfFit.mH120.40.root\n",
      "hadd Target path: higgsCombineRatio_gof_toys_inj0fb_q1percent.GoodnessOfFit.mH120.ALLTOYS.root:/\n",
      "hadd Target path: higgsCombineRatio_gof_toys_inj0fb_q1percent.GoodnessOfFit.mH120.ALLTOYS.root:/toys\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning! -- You haven't picked default values for the Parameters of Interest (either with --expectSignal or --setParameters) for generating toys. Combine will use the 'B-only' ModelConfig to generate, which may lead to undesired behaviour if not using the default Physics Model\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "Warning! -- You haven't picked default values for the Parameters of Interest (either with --expectSignal or --setParameters) for generating toys. Combine will use the 'B-only' ModelConfig to generate, which may lead to undesired behaviour if not using the default Physics Model\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n",
      "RooSimultaneousOpt: number of channel masks must equal number of channels\n"
     ]
    }
   ],
   "source": [
    "#histfile = 'histograms_200GeV_5600.root'\n",
    "lumi = 60\n",
    "MX   = 3500. #Signal mass in units of GeV\n",
    "#Only lool at one quantile/signal injection for debugging\n",
    "sig_inj_vals = [0] #These correspond to xsecs of 0fb(used for GOF w.o signal), 1fb, 10fb, 20fb, 50fb, 100fb\n",
    "quants       = [0.01]\n",
    "\n",
    "doCombine = True #If run combine\n",
    "doPlots = False # If you already ran combine and only want to plot results. Currently only running combine and debugging below\n",
    "\n",
    "\n",
    "for i,qkey in enumerate(quants):\n",
    "\n",
    "    if i > 0:\n",
    "      lower_bound = quants[i-1]\n",
    "    else:\n",
    "      lower_bound = 0.0\n",
    "\n",
    "    for skey in sig_inj_vals:\n",
    "      injectedSignal = int(skey*10.) #Stick to no injected signal for now\n",
    "      quantile       = int(qkey*100)\n",
    "      prefix = 'inj{}fb_q{}percent'.format(injectedSignal,quantile) #different name for all quantiles/injected signal\n",
    "\n",
    "      # Get histograms\n",
    "      f = rt.TFile.Open(histfile,\"r\")\n",
    "      data_rej = f.Get('data_rej_{}'.format(prefix)); data_rej.SetDirectory(0);\n",
    "      data_acc = f.Get('data_acc_{}'.format(prefix)); data_acc.SetDirectory(0);\n",
    "      efficiency = data_acc.Integral()/data_rej.Integral()\n",
    "\n",
    "      signal_acc     = f.Get('signal_q{}percent'.format(quantile)) ; signal_acc.SetDirectory(0);\n",
    "      signal_rej     = f.Get('signal_template') ; signal_rej.SetDirectory(0);\n",
    "      f.Close() \n",
    "\n",
    "      xaxis = data_acc.GetXaxis().GetXbins()\n",
    "      min_bin = xaxis[0]\n",
    "      max_bin = xaxis[len(xaxis)-1]\n",
    "      n_bins  = len(xaxis)-1\n",
    "\n",
    "      makeWS(data_rej,data_acc,signal_rej,signal_acc, outname='datacard_ws_{PREFIX}.root'.format(PREFIX=prefix), quantile=quantile,injectedSignal=injectedSignal)\n",
    "      if doCombine:\n",
    "        os.system('combine -M GoodnessOfFit --algo saturated --fixedSignalStrength 0 -d datacard_ws_{PREFIX}_ratio.txt -n Ratio_gof_{PREFIX} --dataset data_obs -v 0'.format(PREFIX=prefix))\n",
    "        for i in range(1):\n",
    "          os.system('combine -M GoodnessOfFit --algo saturated --fixedSignalStrength 0 -d datacard_ws_{PREFIX}_ratio.txt -t 200 --toysFreq -n Ratio_gof_toys_{PREFIX}  --dataset data_obs -s {S} -v 0'.format(PREFIX=prefix,S=40+i))\n",
    "        os.system('hadd -f higgsCombineRatio_gof_toys_{PREFIX}.GoodnessOfFit.mH120.ALLTOYS.root higgsCombineRatio_gof_toys_{PREFIX}.GoodnessOfFit.mH120.4*.root'.format(PREFIX=prefix))\n",
    "\n",
    "        # open file\n",
    "        obs_gof_file = uproot.open('higgsCombineRatio_gof_{PREFIX}.GoodnessOfFit.mH120.root'.format(PREFIX=prefix))\n",
    "        obs_gof = obs_gof_file['limit'].arrays('limit')['limit'][0]\n",
    "        print(\"Obs gof = {}\".format(obs_gof))\n",
    "        exp_gof_file = uproot.open('higgsCombineRatio_gof_toys_{PREFIX}.GoodnessOfFit.mH120.ALLTOYS.root'.format(PREFIX=prefix))\n",
    "        exp_gof = exp_gof_file['limit'].arrays('limit')['limit']\n",
    "        print(\"Exp gof (mean) = {}\".format(np.mean(exp_gof)))\n",
    "\n",
    "\n",
    "      if doPlots:\n",
    "\n",
    "        # open file\n",
    "        obs_gof_file = uproot.open('higgsCombineRatio_gof_{PREFIX}.GoodnessOfFit.mH120.root'.format(PREFIX=prefix))\n",
    "        obs_gof = obs_gof_file['limit'].arrays('limit')['limit'][0]\n",
    "\n",
    "        exp_gof_file = uproot.open('higgsCombineRatio_gof_toys_{PREFIX}.GoodnessOfFit.mH120.ALLTOYS.root'.format(PREFIX=prefix)) #limit contains the value of the test-statistic in each toy\n",
    "        exp_gof = exp_gof_file['limit'].arrays('limit')['limit']\n",
    "\n",
    "        # get p-value from toys\n",
    "        n_extreme = len(exp_gof[exp_gof > obs_gof])\n",
    "        n_total = len(exp_gof)\n",
    "        pval_toys = 1.*n_extreme/n_total\n",
    "\n",
    "        # get p-value assuming chi2 dist (may not be valid)\n",
    "        pval = rt.TMath.Prob(obs_gof,n_bins)\n",
    "        # print('sig inj = %.1f fb, gof = %.2f, p-value (from chi2) = %.6f, p-value (from toys) = %.6f'%(sig_inj*sig_xsec,obs_gof,pval,pval_toys))\n",
    "\n",
    "        bin_width = (max(exp_gof+[obs_gof])+np.std(exp_gof)-(min(exp_gof)-np.std(exp_gof)))/30.\n",
    "        exp_gof_hist = rt.TH1D('gof','gof',30,min(exp_gof)-np.std(exp_gof), max(exp_gof+[obs_gof])+np.std(exp_gof))\n",
    "        exp_gof_hist_gt = rt.TH1D('gof_gt','gof_gt',30,min(exp_gof)-np.std(exp_gof), max(exp_gof+[obs_gof])+np.std(exp_gof))\n",
    "        for g in exp_gof:\n",
    "            exp_gof_hist.Fill(g)\n",
    "            if g > obs_gof:\n",
    "                exp_gof_hist_gt.Fill(g)\n",
    "\n",
    "\n",
    "        d = rt.TCanvas(\"ratio\", \"\", 1000, 800)\n",
    "        d.SetLeftMargin(0.13)\n",
    "        # signal_hist_template    .Draw('same HIST')\n",
    "\n",
    "        rt.gStyle.SetOptTitle(0)\n",
    "        rt.gStyle.SetOptStat(0)\n",
    "        f = rt.TF1(\"chi2\",\"%f*ROOT::Math::chisquared_pdf(x,%i,0)\"%(exp_gof_hist.Integral()*bin_width,n_bins),min(exp_gof)-np.std(exp_gof),max(exp_gof+[obs_gof])+np.std(exp_gof))\n",
    "\n",
    "        tleg = rt.TLegend(0.48, 0.6, 0.89, 0.85)\n",
    "        tleg.SetTextSize(0.05)\n",
    "        tleg.SetBorderSize(0)\n",
    "        tleg.SetFillStyle(0)\n",
    "        tleg.SetTextSize (0.03)\n",
    "        tleg.SetTextFont( 62 )\n",
    "        tleg.SetTextSize (0.03)\n",
    "        tleg.SetTextFont( 42 )\n",
    "        exp_gof_hist.Draw('hist')\n",
    "        exp_gof_hist.SetXTitle('Test statistic -2ln#lambda')\n",
    "        exp_gof_hist.SetYTitle('N toys')\n",
    "        exp_gof_hist.SetTitle(\"\")\n",
    "        exp_gof_hist.GetYaxis().SetLabelSize(0.05)\n",
    "        exp_gof_hist.GetYaxis().SetTitleSize(0.05)\n",
    "        f.SetLineColor((rt.TColor.GetColor(scol[1])))\n",
    "        exp_gof_hist.SetLineWidth(2)\n",
    "        exp_gof_hist.SetLineColor((rt.TColor.GetColor(bcol[0])))\n",
    "        exp_gof_hist_gt.SetLineColor((rt.TColor.GetColor(bcol[0])))\n",
    "        exp_gof_hist_gt.SetFillColorAlpha((rt.TColor.GetColor(bcol[0])), 0.30)\n",
    "        exp_gof_hist_gt.Draw('fhistsame')\n",
    "        f.Draw('same')\n",
    "        line = rt.TLine(obs_gof,0,obs_gof,exp_gof_hist.GetMaximum())\n",
    "        line.SetLineWidth(2)\n",
    "        line.Draw()\n",
    "        tleg.AddEntry(exp_gof_hist_gt,'p-value (from toys) = %.2f'%pval_toys)\n",
    "        tleg.AddEntry(f,'p-value (from #chi^{2}) = %.2f'%pval,'l')\n",
    "        tleg.AddEntry(line,'Observed (Best fit = {:.1f})'.format(obs_gof),'l')\n",
    "        tleg.Draw()\n",
    "        latex = rt.TLatex()\n",
    "        latex.SetNDC ()\n",
    "        latex.SetTextSize (0.03)\n",
    "        latex.SetTextFont( 62 )\n",
    "        latex.DrawLatex (0.67 ,0.27 , \"%.1f fb^{-1} dijet events\"%lumi)\n",
    "        latex.SetTextSize (0.03)\n",
    "        latex.SetTextFont( 42 )\n",
    "        latex.DrawLatex(0.67 ,0.23 , 'q = {} - {}'.format(lower_bound,qkey))\n",
    "        # latex.DrawLatex(0.67 ,0.19 , \"Acc./rej. = {:.2f}\".format(efficiency))\n",
    "        # latex.DrawLatex(0.67 ,0.15 , \"50 GeV binning\")\n",
    "        # d.Draw()\n",
    "        d.SaveAs('gof_{}.pdf'.format(prefix))\n",
    "\n",
    "        # # by hand GOF calculation\n",
    "        os.system('combine -M FitDiagnostics -d datacard_ws_{PREFIX}_ratio.txt -n _fit_result_{PREFIX} --saveShapes --saveWithUncertainties --dataset data_obs'.format(PREFIX=prefix))\n",
    "        fitDiag = rt.TFile.Open('fitDiagnostics_fit_result_{PREFIX}.root'.format(PREFIX=prefix),'r')\n",
    "\n",
    "        byhand_gof = 0\n",
    "        bw = 100\n",
    "        f = rt.TCanvas('f','f',1000,800)\n",
    "        f.cd()\n",
    "        for cat in ['rej', 'acc']:\n",
    "            bkgd = fitDiag.Get('shapes_fit_b/{cat}/background'.format(cat=cat))\n",
    "            if not bkgd:\n",
    "              continue\n",
    "            bkgd.Scale(bw) # need to multiply by bin width for some reason?\n",
    "            data = fitDiag.Get('shapes_fit_b/{cat}/data'.format(cat=cat))\n",
    "            if cat=='rej':\n",
    "                bkgd.Draw('hist')\n",
    "                bkgd.SetMinimum(5000)\n",
    "                bkgd.SetMaximum(15000)\n",
    "                bkgd.GetXaxis().SetRangeUser(100,1700)\n",
    "            else:\n",
    "                bkgd.Draw(\"histsame\")\n",
    "            data.SetMarkerStyle(20)\n",
    "            data.SetMarkerColor(rt.kBlack)\n",
    "            for i in range(0,bkgd.GetNbinsX()):\n",
    "                bw = bkgd.GetBinWidth(i)\n",
    "                data.SetPointEXlow(i,0)\n",
    "                data.SetPointEXhigh(i,0)\n",
    "                data.SetPoint(i,data.GetX()[i], bw*data.GetY()[i]) # need to multiply by bin width for some reason?\n",
    "                data.SetPointEYlow(i,bw*data.GetErrorYlow(i)) # need to multiply by bin width for some reason?\n",
    "                data.SetPointEYhigh(i,bw*data.GetErrorYhigh(i)) # need to multiply by bin width for some reason?\n",
    "            data.Draw('samepez')\n",
    "\n",
    "\n",
    "            for i in range(0,bkgd.GetNbinsX()):\n",
    "                x = bkgd.GetBinCenter(i+1)\n",
    "                fi = bkgd.GetBinContent(i+1)\n",
    "                di = data.GetY()[i]\n",
    "                gofi = 2*(fi - di + di*rt.TMath.Log(di/fi)) # see eq. 14 of http://cousins.web.cern.ch/cousins/ongoodness6march2016.pdf\n",
    "\n",
    "                # expect each bin to give GOF contribution ~ O(1)\n",
    "                if gofi>5:\n",
    "                    print('Bin center {}'.format(x))\n",
    "                    print('{cat} bin {i}: fi={fi}, di={di}, gofi={gofi}'.format(cat=cat,i=i,fi=fi,di=di,gofi=gofi))\n",
    "                    print(\" -> BIG GOF CONTRIBUTION in this bin\")\n",
    "                byhand_gof += gofi\n",
    "            f.SetLogy()\n",
    "            f.Draw()\n",
    "            fitDiag.Close()\n",
    "        print(\"by hand obs GOF = {}\".format(byhand_gof))\n",
    "        print(\"combine obs GOF = {}\".format(obs_gof))\n",
    "        print(\"combine exp GOF = {}\".format(np.mean(exp_gof)))\n",
    "\n",
    "        print(\"Done with quantile \",qkey )\n",
    "        print(\"p-value = {}\".format(pval_toys))\n",
    "        print(\"Observed GOF = {}\".format(obs_gof))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: ratio\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# DEBUG! Plot GOF\n",
    "n_bins = background_hist_template.GetNbinsX()\n",
    "print n_bins\n",
    "prefix = \"inj0fb_q1percent\"\n",
    "obs_gof_file = uproot.open('higgsCombineRatio_gof_{PREFIX}.GoodnessOfFit.mH120.root'.format(PREFIX=prefix))\n",
    "obs_gof = obs_gof_file['limit'].arrays('limit')['limit'][0]\n",
    "\n",
    "exp_gof_file = uproot.open('higgsCombineRatio_gof_toys_{PREFIX}.GoodnessOfFit.mH120.ALLTOYS.root'.format(PREFIX=prefix)) #limit contains the value of the test-statistic in each toy\n",
    "exp_gof = exp_gof_file['limit'].arrays('limit')['limit']\n",
    "\n",
    "# get p-value from toys\n",
    "n_extreme = len(exp_gof[exp_gof > obs_gof])\n",
    "n_total = len(exp_gof)\n",
    "pval_toys = 1.*n_extreme/n_total\n",
    "\n",
    "# get p-value assuming chi2 dist (may not be valid)\n",
    "pval = rt.TMath.Prob(obs_gof,n_bins)\n",
    "# print('sig inj = %.1f fb, gof = %.2f, p-value (from chi2) = %.6f, p-value (from toys) = %.6f'%(sig_inj*sig_xsec,obs_gof,pval,pval_toys))\n",
    "\n",
    "bin_width = (max(exp_gof+[obs_gof])+np.std(exp_gof)-(min(exp_gof)-np.std(exp_gof)))/30.\n",
    "exp_gof_hist = rt.TH1D('gof','gof',30,min(exp_gof)-np.std(exp_gof), max(exp_gof+[obs_gof])+np.std(exp_gof))\n",
    "exp_gof_hist_gt = rt.TH1D('gof_gt','gof_gt',30,min(exp_gof)-np.std(exp_gof), max(exp_gof+[obs_gof])+np.std(exp_gof))\n",
    "for g in exp_gof:\n",
    "    exp_gof_hist.Fill(g)\n",
    "    if g > obs_gof:\n",
    "        exp_gof_hist_gt.Fill(g)\n",
    "\n",
    "\n",
    "d = rt.TCanvas(\"ratio\", \"\", 1000, 800)\n",
    "d.SetLeftMargin(0.13)\n",
    "# signal_hist_template    .Draw('same HIST')\n",
    "\n",
    "rt.gStyle.SetOptTitle(0)\n",
    "rt.gStyle.SetOptStat(0)\n",
    "f = rt.TF1(\"chi2\",\"%f*ROOT::Math::chisquared_pdf(x,%i,0)\"%(exp_gof_hist.Integral()*bin_width,n_bins),min(exp_gof)-np.std(exp_gof),max(exp_gof+[obs_gof])+np.std(exp_gof))\n",
    "\n",
    "tleg = rt.TLegend(0.48, 0.6, 0.89, 0.85)\n",
    "tleg.SetTextSize(0.05)\n",
    "tleg.SetBorderSize(0)\n",
    "tleg.SetFillStyle(0)\n",
    "tleg.SetTextSize (0.03)\n",
    "tleg.SetTextFont( 62 )\n",
    "tleg.SetTextSize (0.03)\n",
    "tleg.SetTextFont( 42 )\n",
    "exp_gof_hist.Draw('hist')\n",
    "exp_gof_hist.SetXTitle('Test statistic -2ln#lambda')\n",
    "exp_gof_hist.SetYTitle('N toys')\n",
    "exp_gof_hist.SetTitle(\"\")\n",
    "exp_gof_hist.GetYaxis().SetLabelSize(0.05)\n",
    "exp_gof_hist.GetYaxis().SetTitleSize(0.05)\n",
    "f.SetLineColor((rt.TColor.GetColor(scol[1])))\n",
    "exp_gof_hist.SetLineWidth(2)\n",
    "exp_gof_hist.SetLineColor((rt.TColor.GetColor(bcol[0])))\n",
    "exp_gof_hist_gt.SetLineColor((rt.TColor.GetColor(bcol[0])))\n",
    "exp_gof_hist_gt.SetFillColorAlpha((rt.TColor.GetColor(bcol[0])), 0.30)\n",
    "exp_gof_hist_gt.Draw('fhistsame')\n",
    "f.Draw('same')\n",
    "line = rt.TLine(obs_gof,0,obs_gof,exp_gof_hist.GetMaximum())\n",
    "line.SetLineWidth(2)\n",
    "line.Draw()\n",
    "tleg.AddEntry(exp_gof_hist_gt,'p-value (from toys) = %.2f'%pval_toys)\n",
    "tleg.AddEntry(f,'p-value (from #chi^{2}) = %.2f'%pval,'l')\n",
    "tleg.AddEntry(line,'Observed (Best fit = {:.1f})'.format(obs_gof),'l')\n",
    "tleg.Draw()\n",
    "latex = rt.TLatex()\n",
    "latex.SetNDC ()\n",
    "latex.SetTextSize (0.03)\n",
    "latex.SetTextFont( 62 )\n",
    "latex.DrawLatex (0.67 ,0.27 , \"%.1f fb^{-1} dijet events\"%lumi)\n",
    "latex.SetTextSize (0.03)\n",
    "latex.SetTextFont( 42 )\n",
    "latex.DrawLatex(0.67 ,0.23 , '{}'.format(prefix))\n",
    "# latex.DrawLatex(0.67 ,0.23 , 'q = {} - {}'.format(lower_bound,qkey))\n",
    "# latex.DrawLatex(0.67 ,0.19 , \"Acc./rej. = {:.2f}\".format(efficiency))\n",
    "# latex.DrawLatex(0.67 ,0.15 , \"50 GeV binning\")\n",
    "d.Draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rej\n",
      "acc\n",
      "acc bin 2: fi=10721.8671875, di=11041.0, gofi=9.40601638833\n",
      " -> BIG GOF CONTRIBUTION in this bin, mjj 1450.0\n",
      "acc bin 8: fi=1067.29736328, di=962.0, gofi=10.7479753865\n",
      " -> BIG GOF CONTRIBUTION in this bin, mjj 2050.0\n",
      "acc bin 33: fi=1.81516134739, di=6.0, gofi=5.97734400073\n",
      " -> BIG GOF CONTRIBUTION in this bin, mjj 4550.0\n",
      "acc bin 35: fi=1.81516134739, di=6.0, gofi=5.97734400073\n",
      " -> BIG GOF CONTRIBUTION in this bin, mjj 4750.0\n",
      "acc bin 38: fi=0.907879889011, di=4.0, gofi=5.67926018662\n",
      " -> BIG GOF CONTRIBUTION in this bin, mjj 5050.0\n",
      "('No data at mjj', 5250.0)\n",
      "('fi', 0.7267633676528931)\n",
      "('di', 0.0)\n",
      "('No data at mjj', 5450.0)\n",
      "('fi', 0.4542270600795746)\n",
      "('di', 0.0)\n",
      "('Done with quantile ', 'inj0fb_q1percent')\n",
      "By hand obs GOF = 77.6761616786\n",
      "Combine obs GOF = 80.0381165668\n",
      "Combine exp GOF (mean) = 44.8081189856\n",
      "p-value = 0.0\n",
      " <<< Combine >>> \n",
      ">>> method used is FitDiagnostics\n",
      ">>> random number generator seed is 123456\n",
      "SimNLL created with 0 channels, 0 generic constraints, 1 fast gaussian constraints, 0 fast poisson constraints, 0 fast group constraints, \n",
      "SimNLL created with 2 channels, 0 generic constraints, 1 fast gaussian constraints, 0 fast poisson constraints, 0 fast group constraints, \n",
      "\n",
      " --- FitDiagnostics ---\n",
      "Best fit r: 2.77191e-06  -2.77191e-06/+1.30652  (68% CL)\n",
      "Done in 0.19 min (cpu), 0.20 min (real)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Missing background ModelConfig 'ModelConfig_bonly' in workspace 'w' in file roostats-ncxeiJ.root\n",
      "Will make one from the signal ModelConfig 'ModelConfig' setting signal strenth 'r' to zero\n",
      "Warning! -- You haven't picked default values for the Parameters of Interest (either with --expectSignal or --setParameters) for generating toys. Combine will use the 'B-only' ModelConfig to generate, which may lead to undesired behaviour if not using the default Physics Model\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#DEBUG! Plot fit results!\n",
    "\n",
    "import math\n",
    "os.system('combine -M FitDiagnostics -d datacard_ws_{PREFIX}_ratio.txt -n _fit_result_{PREFIX} --saveShapes --saveWithUncertainties --dataset data_obs'.format(PREFIX=prefix))\n",
    "fitDiag = rt.TFile.Open('fitDiagnostics_fit_result_{PREFIX}.root'.format(PREFIX=prefix),'r')\n",
    "\n",
    "\n",
    "f = rt.TCanvas('f','f',1000,800)\n",
    "f.cd()\n",
    "\n",
    "tleg = rt.TLegend(0.48, 0.6, 0.89, 0.85)\n",
    "tleg.SetTextSize(0.05)\n",
    "tleg.SetBorderSize(0)\n",
    "tleg.SetFillStyle(0)\n",
    "tleg.SetTextSize (0.03)\n",
    "tleg.SetTextFont( 62 )\n",
    "tleg.SetTextSize (0.03)\n",
    "tleg.SetTextFont( 42 )\n",
    "\n",
    "byhand_gof = 0.0\n",
    "for cat in ['rej', 'acc']:\n",
    "    print cat\n",
    "    bkgd = fitDiag.Get('shapes_fit_b/{cat}/background'.format(cat=cat))\n",
    "    bkgd.Scale(100) # need to multiply by bin width for some reason?\n",
    "    data = fitDiag.Get('shapes_fit_b/{cat}/data'.format(cat=cat))\n",
    "    if cat=='rej':\n",
    "        bkgd.Draw('hist')\n",
    "        bkgd.SetLineColor(rt.kRed)\n",
    "#         bkgd.SetMinimum(10E3)\n",
    "#         bkgd.SetMaximum(20E3)\n",
    "#         bkgd.GetXaxis().SetRangeUser(1400,1500)\n",
    "        tleg.AddEntry(bkgd,'rej','l')\n",
    "    else:\n",
    "        bkgd.Draw(\"histsame\")\n",
    "        tleg.AddEntry(bkgd,'acc','l')\n",
    "    data.SetMarkerStyle(20)\n",
    "    data.SetMarkerColor(rt.kBlack)\n",
    "    for i in range(0,bkgd.GetNbinsX()):\n",
    "        data.SetPointEXlow(i,0)\n",
    "        data.SetPointEXhigh(i,0)\n",
    "        data.SetPoint(i,data.GetX()[i], 100*data.GetY()[i]) # need to multiply by bin width for some reason?\n",
    "        data.SetPointEYlow(i,100*data.GetErrorYlow(i)) # need to multiply by bin width for some reason?\n",
    "        data.SetPointEYhigh(i,100*data.GetErrorYhigh(i)) # need to multiply by bin width for some reason?\n",
    "    data.Draw('samepez')\n",
    "    \n",
    "\n",
    "    for i in range(0,bkgd.GetNbinsX()):\n",
    "        mjjvalue = bkgd.GetBinCenter(i+1)\n",
    "        fi = bkgd.GetBinContent(i+1)\n",
    "        di = data.GetY()[i]\n",
    "        if di == 0:\n",
    "            print (\"No data at mjj\", mjjvalue)\n",
    "            print (\"fi\", fi)\n",
    "            print (\"di\", di)\n",
    "            gofi = 0.\n",
    "        else:    \n",
    "            gofi = 2*(fi - di + di*rt.TMath.Log(di/fi)) # see eq. 14 of http://cousins.web.cern.ch/cousins/ongoodness6march2016.pdf\n",
    "        # expect each bin to give GOF contribution ~ O(1)\n",
    "        if gofi>5:\n",
    "            print('{cat} bin {i}: fi={fi}, di={di}, gofi={gofi}'.format(cat=cat,i=i,fi=fi,di=di,gofi=gofi))\n",
    "            print(\" -> BIG GOF CONTRIBUTION in this bin, mjj {}\".format(mjjvalue))\n",
    "        byhand_gof += gofi\n",
    "\n",
    "tleg.Draw('same')\n",
    "f.SetLogy()\n",
    "f.Draw()\n",
    "\n",
    "print(\"Done with quantile \",prefix )\n",
    "\n",
    "print(\"By hand obs GOF = {}\".format(byhand_gof))\n",
    "print(\"Combine obs GOF = {}\".format(obs_gof))\n",
    "print(\"Combine exp GOF (mean) = {}\".format(np.mean(exp_gof)))\n",
    "\n",
    "print(\"p-value = {}\".format(pval_toys))\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14+"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}