background_prediction_closure_CSC_CSC_v1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c839451f",
   "metadata": {},
   "source": [
    "## Import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "58b6e643",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to JupyROOT 6.24/06\n"
     ]
    }
   ],
   "source": [
    "import ROOT as rt\n",
    "import csv\n",
    "import re\n",
    "import sys\n",
    "import collections\n",
    "from collections import OrderedDict\n",
    "import uproot\n",
    "import pandas as pd\n",
    "from root_numpy import array2tree\n",
    "import scipy\n",
    "import awkward\n",
    "import numpy as np\n",
    "import time\n",
    "import math\n",
    "#import PrettyTable\n",
    "\n",
    "sys.path.append('/afs/desy.de/user/l/lbenato/cms-lpc-llp_repo/run3_muon_system_analysis/lib/')\n",
    "from histo_utilities import create_TH1D, create_TH2D, std_color_list, create_TGraph, make_ratio_plot, addOverflow\n",
    "from helper_functions import deltaR, deltaPhi, drawCMS\n",
    "\n",
    "rt.gStyle.SetOptStat(0)\n",
    "rt.gROOT.SetBatch(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80d97fb5",
   "metadata": {},
   "source": [
    "## Load ntuples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0c47f19",
   "metadata": {},
   "source": [
    "## Load variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "368e657b",
   "metadata": {},
   "outputs": [],
   "source": [
    "fpath =OrderedDict()\n",
    "tree = OrderedDict()\n",
    "\n",
    "start_t = time.time()\n",
    "data_year = 2022\n",
    "\n",
    "tag  = 'V1p19'\n",
    "vers = 'v6'\n",
    "#v1 includes events without selections\n",
    "#v3 includes events with at least 2 clusters\n",
    "#v4: no event level cuts, clusters made with DBSCAN, HLT time definition\n",
    "#v5: no event level cuts, clusters made with CA\n",
    "\n",
    "data_path = '/nfs/dust/cms/group/cms-llp/muon_system_run3/'+tag+'/Data'+str(data_year)+'/'+vers+'/'\n",
    "lumi = 23.02*1000\n",
    "\n",
    "if data_year == 2022:\n",
    "    fpath['data'] = data_path + 'DisplacedJet-EXOCSCCluster_Run2022EFG-PromptReco-v1_goodLumi.root'\n",
    "    fpath['signal'] = data_path + 'ggH_HToSSTobbbb_MH-125_MS-15_CTau1000_13p6TeV_1pb_weighted.root'\n",
    "\n",
    "NEvents = {}\n",
    "for k,v in fpath.items():\n",
    "    root_dir = uproot.open(v)\n",
    "    tree[k] = root_dir['MuonSystem']\n",
    "    NEvents[k] = root_dir['NEvents'][1]\n",
    "    a = tree[k][\"weight\"].array()\n",
    "    \n",
    "for k, T in tree.items():\n",
    "    branch_names = T.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "899a72f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "JET_PT_CUT = 10.0\n",
    "MUON_PT_CUT = 20.0\n",
    "N_RECHIT_CUT = 90\n",
    "jetPt_cut = 50\n",
    "tightid = False\n",
    "ring_cut = 50\n",
    "\n",
    "#cut_based = True\n",
    "#cut_based_version = 'v4'\n",
    "\n",
    "intime = True\n",
    "DPHI_CUT = 1\n",
    "\n",
    "\n",
    "gLLP_csc = {}\n",
    "\n",
    "\n",
    "selections_cluster = {}\n",
    "sel_cluster = {}\n",
    "sel_jetveto_csc = {}\n",
    "sel_muonveto_csc = {}\n",
    "sel_jetveto_dt = {}\n",
    "sel_muonveto_dt = {}\n",
    "met_trigger = {}\n",
    "met = {}\n",
    "gLLP_beta = {}\n",
    "jetPt = {}\n",
    "jetPhi = {}\n",
    "metPhi = {}\n",
    "angle ={}\n",
    "nLeptons = {}\n",
    "genJetPt = {}\n",
    "genJetPhi = {}\n",
    "genMet = {}\n",
    "genMetPhi = {}\n",
    "pileupWeight = {}\n",
    "gLLP_ctau = {}\n",
    "npv = {}\n",
    "nRechitClusters = {}\n",
    "nJets = {}\n",
    "nJets_50gev = {}\n",
    "nCscRings = {}\n",
    "nDtRings = {}\n",
    "\n",
    "weight = {}\n",
    "jetMet_dPhiMin = {}\n",
    "dphiMet_cluster = {}\n",
    "nRechits_sr = {}\n",
    "jetMet_dPhiMin30_sr = {}\n",
    "cscClusterTimeSpread = {}\n",
    "bdt_score = {}\n",
    "nCscChambers = {}\n",
    "\n",
    "sel_ev = {}\n",
    "hlt_sel_ev = {}\n",
    "cluster_index = ''\n",
    "nRings = {}\n",
    "\n",
    "#CSC cluster variables\n",
    "cscClusterMuonVetoPt = {}\n",
    "cscClusterJetVetoPt = {}\n",
    "cscClusterPhi = {}\n",
    "cscClusterEta = {}\n",
    "cscClusterEta2 = {}\n",
    "cscClusterEta3 = {}\n",
    "cscClusterR = {}\n",
    "cscClusterZ = {}\n",
    "cscClusterSize = {}\n",
    "cscClusterSize2 = {}\n",
    "cscClusterSize3 = {}\n",
    "cscClusterTimeSpread = {}\n",
    "cscClusterTime = {}\n",
    "cscClusterTime2 = {}\n",
    "cscClusterTime3 = {}\n",
    "cscClusterMet_dPhi = {}\n",
    "\n",
    "cscClusterNStation = {}\n",
    "cscClusterDphi = {}\n",
    "nCscClusters = {}\n",
    "\n",
    "\n",
    "#DT cluster variables\n",
    "dtClusterMuonVetoPt = {}\n",
    "dtClusterJetVetoPt = {}\n",
    "dtClusterTime = {}\n",
    "dtClusterPhi = {}\n",
    "dtClusterEta = {}\n",
    "dtClusterSize = {}\n",
    "dtClusterDphi = {}\n",
    "nDtClusters = {}\n",
    "dtClusterNStation = {}\n",
    "dtClusterMaxStation = {}\n",
    "dtClusterNHitStation1 = {}\n",
    "dtCluster_match_MB1hits_0p4 = {}\n",
    "dtCluster_match_MB1hits_0p5 = {}\n",
    "dtClusterMaxStationRatio = {}\n",
    "dtClusterMet_dPhi = {}\n",
    "\n",
    "deltaEta = {}        \n",
    "deltaRCluster = {}\n",
    "\n",
    "metPhi = {}\n",
    "evtNum = {}\n",
    "runNum = {}\n",
    "lumiNum = {}\n",
    "\n",
    "nMe11 = {}\n",
    "\n",
    "tree_keys = []\n",
    "nClusterRatio = {}\n",
    "\n",
    "\n",
    "#L1 plateau\n",
    "first_in_ME11 = {}\n",
    "first_in_ME12 = {}\n",
    "first_in_ME13 = {}\n",
    "first_in_ME21 = {}\n",
    "first_in_ME22 = {}\n",
    "first_in_ME31 = {}\n",
    "first_in_ME32 = {}\n",
    "first_in_ME41 = {}\n",
    "first_in_ME42 = {}\n",
    "\n",
    "\n",
    "first_in_plateau_ME11 = {}\n",
    "first_in_plateau_ME12 = {}\n",
    "first_in_plateau_ME13 = {}\n",
    "first_in_plateau_ME21 = {}\n",
    "first_in_plateau_ME22 = {}\n",
    "first_in_plateau_ME31 = {}\n",
    "first_in_plateau_ME32 = {}\n",
    "first_in_plateau_ME41 = {}\n",
    "first_in_plateau_ME42 = {}\n",
    "first_in_plateau = {}\n",
    "\n",
    "#Angular variables\n",
    "dPhi_csc_csc = {}\n",
    "dEta_csc_csc = {}\n",
    "dR_csc_csc = {}\n",
    "dt_csc_csc = {}\n",
    "dPhi_csc_dt = {}\n",
    "dEta_csc_dt = {}\n",
    "dR_csc_dt = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8091520",
   "metadata": {},
   "source": [
    "## Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6f8fbffd",
   "metadata": {},
   "outputs": [],
   "source": [
    "category = 0#-1#0\n",
    "category = 1\n",
    "#-1: at least 1csc\n",
    "#0: exactly 1 csc\n",
    "#1: 2csc,\n",
    "#2: 1csc+1dt, \n",
    "\n",
    "do_jet_veto = False\n",
    "do_inverted_jet_veto = False\n",
    "if (do_jet_veto and do_inverted_jet_veto):\n",
    "    print(\"Please check jet veto! Aborting...\")\n",
    "    exit()\n",
    "\n",
    "do_muon_veto = False\n",
    "do_inverted_muon_veto = False\n",
    "if (do_muon_veto and do_inverted_muon_veto):\n",
    "    print(\"Please check muon veto! Aborting...\")\n",
    "    exit()\n",
    "\n",
    "do_csc_time_spread_cut = False\n",
    "do_csc_in_time_cut = False\n",
    "do_ME_veto = True\n",
    "do_MB_veto = True\n",
    "do_HLT_eta_cut = False#True\n",
    "do_L1_plateau = True\n",
    "\n",
    "plot_string = \"\"\n",
    "#plot_string = \"_jet_veto\"\n",
    "#plot_string = \"_csc_time_spread_cut\"\n",
    "#plot_string = \"_csc_in_time_cut\"\n",
    "#plot_string = \"\"\n",
    "#plot_string = \"_ME_veto\"\n",
    "#plot_string = \"_ME_veto_HLT_eta_cut\"\n",
    "#plot_string = \"_ME_veto_HLT_eta_cut_at_least_1_cluster\"\n",
    "#plot_string = \"_ME_veto_HLT_eta_cut_in_time_cut_at_least_1_cluster\"\n",
    "#plot_string+= \"_exactly_1_csc_cluster\"\n",
    "\n",
    "plot_string+= \"_exactly_2_csc_clusters_ME_veto\"\n",
    "#plot_string+= \"_2_csc_clusters_ME_veto\"\n",
    "#plot_string+= \"_at_least_1_csc_cluster_ME_veto\"\n",
    "#plot_string+= \"_csc_dt_cluster_ME_veto\"\n",
    "#plot_string+= \"_csc_dt_cluster_ME_MB_veto\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "52e5fddf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'dtRechitClusterMaxStationRatio'\n"
     ]
    }
   ],
   "source": [
    "for a in branch_names:\n",
    "    #if \"MB1\" in str(a):\n",
    "    #    print(a)\n",
    "    if \"dtRechitClusterMaxStationRatio\" in str(a):\n",
    "        print(a)\n",
    "    #if \"atio\" in str(a):\n",
    "    #    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "bb3672eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "for k, T in tree.items():\n",
    "    tree_keys.append(k)\n",
    "    #if not k == 'data' and not k[-4:] == '1000':continue\n",
    "########### SELECTION: CLUSTERS ############\n",
    "    jet_veto_csc = T.array('cscRechitCluster' + cluster_index + 'JetVetoPt')<30\n",
    "    muon_veto_csc = np.logical_not(np.logical_and(T.array('cscRechitClusterMuonVetoPt') >= 30, T.array('cscRechitClusterMuonVetoGlobal')))\n",
    "    \n",
    "    sel_csccluster = T.array('cscRechitClusterSize') >= 0\n",
    "    \n",
    "    if do_jet_veto:\n",
    "        sel_csccluster = jet_veto_csc\n",
    "    if do_inverted_jet_veto:\n",
    "        sel_csccluster = np.logical_not(jet_veto_csc)       \n",
    "\n",
    "    if do_muon_veto:\n",
    "        sel_csccluster = np.logical_and(sel_csccluster, muon_veto_csc)\n",
    "    if do_inverted_muon_veto:\n",
    "        sel_csccluster = np.logical_and(sel_csccluster, np.logical_not(muon_veto_csc))    \n",
    "          \n",
    "    #Missing branch:\n",
    "    #sel_csccluster = np.logical_and(sel_csccluster, np.abs(T.array('cscRechitCluster' + cluster_index + 'MetEENoise_dPhi'))<1.2)\n",
    "\n",
    "    #Missing branch:\n",
    "    #sel_csccluster = np.logical_and(sel_csccluster, T.array('cscRechitCluster' + cluster_index + 'Me11Ratio')<1)\n",
    "\n",
    "    #Time spread cut\n",
    "    if do_csc_time_spread_cut:\n",
    "        sel_csccluster = np.logical_and(sel_csccluster, T.array('cscRechitCluster' + cluster_index + 'TimeSpreadWeightedAll')<20)\n",
    "    \n",
    "    #Time cut\n",
    "    if do_csc_in_time_cut:\n",
    "        sel_csccluster = np.logical_and(sel_csccluster, np.logical_and(\n",
    "            T.array('cscRechitCluster' + cluster_index + 'TimeWeighted')< 12.5, \n",
    "            T.array('cscRechitCluster' + cluster_index + 'TimeWeighted') > -5))\n",
    "\n",
    "    #ME11 and ME12 veto\n",
    "    ME11_veto = np.logical_and(\n",
    "        T.array('cscRechitCluster' + cluster_index + 'NRechitChamberMinus11')==0  ,\n",
    "        T.array('cscRechitCluster' + cluster_index + 'NRechitChamberPlus11')==0\n",
    "    )  \n",
    "\n",
    "    ME12_veto = np.logical_and(\n",
    "        T.array('cscRechitCluster' + cluster_index + 'NRechitChamberMinus12')==0  ,\n",
    "        T.array('cscRechitCluster' + cluster_index + 'NRechitChamberPlus12')==0\n",
    "    )      \n",
    "\n",
    "       \n",
    "    \n",
    "    if do_ME_veto:\n",
    "        sel_csccluster = np.logical_and(sel_csccluster,\n",
    "                                    np.logical_and(ME11_veto,ME12_veto)\n",
    "                                   ) \n",
    "    if do_HLT_eta_cut:\n",
    "        sel_csccluster = np.logical_and(sel_csccluster,sel_trgCluster)\n",
    "        \n",
    "        \n",
    "    sel_dtcluster = T.array('dtRechitClusterSize') >= 0\n",
    "    #Missing branch:\n",
    "    #sel_dtcluster = np.abs(T.array('dtRechitClusterMetEENoise_dPhi')) < 1\n",
    "    jet_veto_dt = np.abs(T.array('dtRechitClusterJetVetoPt')) < 50\n",
    "    muon_veto_dt = np.logical_not(np.logical_and(T.array('dtRechitClusterMuonVetoPt') >= 10, T.array('dtRechitClusterMuonVetoLooseId')))\n",
    "\n",
    "    if do_muon_veto:\n",
    "        sel_dtcluster = np.logical_and(sel_dtcluster, muon_veto_dt)\n",
    "    if do_jet_veto:\n",
    "        sel_dtcluster = np.logical_and(sel_dtcluster, jet_veto_dt)\n",
    "\n",
    "    MB1_veto = T.array('dtRechitClusterNHitStation1') == 0\n",
    "    if do_MB_veto:\n",
    "        sel_dtcluster = np.logical_and(sel_dtcluster, MB1_veto)\n",
    "        \n",
    "    \n",
    "########### SELECTION: JETS ############\n",
    "    \n",
    "    sel_jet = np.logical_and(T.array('jetPt') > jetPt_cut, np.abs(T.array('jetEta')) < 2.4 )\n",
    "\n",
    "########### SELECTION: EVENTS ############\n",
    "    hlt = T['HLTDecision'].array()    \n",
    "    HLT_CscCluster_Loose = hlt[:,566]\n",
    "    HLT_CscCluster_Medium = hlt[:,567]\n",
    "    HLT_CscCluster_Tight = hlt[:,568]\n",
    "    HLT_L1CSCShower_DTCluster50 = hlt[:,569]\n",
    "    HLT_L1CSCShower_DTCluster75 = hlt[:,570]\n",
    "\n",
    "    #Or of the triggers: starting with the CSC ones\n",
    "    #hlt_sel_ev[k] = np.logical_or(HLT_CscCluster_Loose,np.logical_or(HLT_CscCluster_Medium,HLT_CscCluster_Tight))\n",
    "    if category==2:\n",
    "        hlt_sel_ev[k] = HLT_L1CSCShower_DTCluster50\n",
    "    else:\n",
    "        hlt_sel_ev[k] = HLT_CscCluster_Loose\n",
    "     \n",
    "    \n",
    "    #sel_ev[k]  = np.logical_and(sel_ev[k], T.array('category') == 0)\n",
    "    #sel_ev[k] = np.logical_and(sel_ev[k], (T.array('nDtRings')+T.array('nCscRings'))<10)\n",
    "    sel_ev[k] = T.array('nLeptons') == 0\n",
    "    \n",
    "    #If trigger:\n",
    "    #We don't have correct trigger emulation in signal at the moment\n",
    "    if k == 'data': sel_ev[k] = np.logical_and(sel_ev[k],hlt_sel_ev[k])\n",
    "    if k == 'data': sel_ev[k] = np.logical_and(sel_ev[k], T.array('runNum')>=360019)\n",
    "\n",
    "    #At least one pre-selected csc cluster, always required\n",
    "    sel_ev[k] = np.logical_and(sel_ev[k],sel_csccluster.sum()>=1)\n",
    "    \n",
    "    \n",
    "    if category == 0:\n",
    "        sel_ev[k]  = np.logical_and(sel_ev[k],sel_csccluster.sum() == 1)\n",
    "        hlt_sel_ev[k] = np.logical_and(sel_ev[k],hlt_sel_ev[k])\n",
    "    elif category == 1:\n",
    "        sel_ev[k]  = np.logical_and(sel_ev[k],sel_csccluster.sum() == 2)\n",
    "        hlt_sel_ev[k] = np.logical_and(sel_ev[k],hlt_sel_ev[k])\n",
    "    elif category == 2:      \n",
    "        sel_ev[k]  = np.logical_and(sel_ev[k],sel_csccluster.sum() == 1)\n",
    "        sel_ev[k]  = np.logical_and(sel_ev[k],sel_dtcluster.sum() == 1)\n",
    "        hlt_sel_ev[k] = np.logical_and(sel_ev[k],hlt_sel_ev[k])\n",
    "    elif category == -1:      \n",
    "        sel_ev[k]  = np.logical_and(sel_ev[k],sel_csccluster.sum() >= 1)\n",
    "        hlt_sel_ev[k] = np.logical_and(sel_ev[k],hlt_sel_ev[k])\n",
    "           \n",
    "########### BRANCHES ############\n",
    "\n",
    "    \n",
    "    dtClusterMuonVetoPt[k] = T.array('dtRechitClusterMuonVetoPt')[sel_dtcluster][sel_ev[k]][:,:]\n",
    "    dtClusterJetVetoPt[k] = T.array('dtRechitClusterJetVetoPt')[sel_dtcluster][sel_ev[k]][:,:]\n",
    "    dtClusterPhi[k] = T.array('dtRechitClusterPhi')[sel_dtcluster][sel_ev[k]][:,:]\n",
    "    dtClusterEta[k] = T.array('dtRechitClusterEta')[sel_dtcluster][sel_ev[k]][:,:]\n",
    "    dtClusterSize[k] =  T.array('dtRechitClusterSize')[sel_dtcluster][sel_ev[k]][:,:]\n",
    "    dtClusterTime[k] =  T.array('dtRechitCluster_match_RPCBx_dPhi0p5')[sel_dtcluster][sel_ev[k]][:,:]\n",
    "    dtClusterNStation[k] =  T.array('dtRechitClusterNStation10')[sel_dtcluster][sel_ev[k]][:,:]\n",
    "    dtClusterNHitStation1[k] = T.array('dtRechitClusterNHitStation1')[sel_dtcluster][sel_ev[k]][:,:]\n",
    "    dtCluster_match_MB1hits_0p4[k] = T.array('dtRechitCluster_match_MB1hits_0p4')[sel_dtcluster][sel_ev[k]][:,:]\n",
    "    dtCluster_match_MB1hits_0p5[k] = T.array('dtRechitCluster_match_MB1hits_0p5')[sel_dtcluster][sel_ev[k]][:,:]\n",
    "    dtClusterMet_dPhi[k] =  T.array('dtRechitCluster' + cluster_index + 'Met_dPhi')[sel_dtcluster][sel_ev[k]][:,:]\n",
    "    dtClusterMaxStationRatio[k] = T.array('dtRechitCluster' + cluster_index + 'MaxStationRatio')[sel_dtcluster][sel_ev[k]][:,:]\n",
    "        \n",
    "    cscClusterMuonVetoPt[k] = T.array('cscRechitCluster' + cluster_index + 'MuonVetoPt')[sel_csccluster][sel_ev[k]][:,:]\n",
    "    cscClusterJetVetoPt[k] = T.array('cscRechitCluster' + cluster_index + 'JetVetoPt')[sel_csccluster][sel_ev[k]][:,:]\n",
    "    cscClusterPhi[k] = T.array('cscRechitCluster' + cluster_index + 'Phi')[sel_csccluster][sel_ev[k]][:,:]\n",
    "    cscClusterEta[k] = T.array('cscRechitCluster' + cluster_index + 'Eta')[sel_csccluster][sel_ev[k]][:,:]\n",
    "    cscClusterR[k] = np.sqrt(  T.array('cscRechitCluster' + cluster_index + 'X')[sel_csccluster][sel_ev[k]][:,:]**2 + T.array('cscRechitCluster' + cluster_index + 'Y')[sel_csccluster][sel_ev[k]][:,:]**2 )\n",
    "    cscClusterZ[k] = T.array('cscRechitCluster' + cluster_index + 'Z')[sel_csccluster][sel_ev[k]][:,:]\n",
    "    cscClusterSize[k] =  T.array('cscRechitCluster' + cluster_index + 'Size')[sel_csccluster][sel_ev[k]][:,:]\n",
    "    cscClusterTime[k] =  T.array('cscRechitCluster' + cluster_index + 'Time')[sel_csccluster][sel_ev[k]][:,:]\n",
    "    cscClusterTimeSpread[k] =  T.array('cscRechitCluster' + cluster_index + 'TimeSpread')[sel_csccluster][sel_ev[k]][:,:]\n",
    "    cscClusterNStation[k] =  T.array('cscRechitCluster' + cluster_index + 'NStation10')[sel_csccluster][sel_ev[k]][:,:]\n",
    "    cscClusterMet_dPhi[k] =  T.array('cscRechitCluster' + cluster_index + 'Met_dPhi')[sel_csccluster][sel_ev[k]][:,:]\n",
    "    nCscClusters[k] = sel_csccluster.sum()[sel_ev[k]]\n",
    "    nDtClusters[k] = sel_dtcluster.sum()[sel_ev[k]]\n",
    "      \n",
    "    sel_jetveto_csc[k] = jet_veto_csc[sel_csccluster][sel_ev[k]][:,:]\n",
    "    sel_muonveto_csc[k] = muon_veto_csc[sel_csccluster][sel_ev[k]][:,:]\n",
    "       \n",
    "    sel_jetveto_dt[k] = jet_veto_dt[sel_dtcluster][sel_ev[k]][:,:]\n",
    "    sel_muonveto_dt[k] = muon_veto_dt[sel_dtcluster][sel_ev[k]][:,:]        \n",
    "\n",
    "    dtClusterMaxStation[k] = T.array('dtRechitClusterMaxStation')[sel_dtcluster][sel_ev[k]]\n",
    "       \n",
    "    hlt_sel_ev[k] = hlt_sel_ev[k][ sel_ev[k] ]\n",
    "    sel_ev[k] = sel_ev[k][ sel_ev[k] ]\n",
    "\n",
    "    nClusterRatio[k] = np.divide(nCscClusters[k].astype(float),nDtClusters[k].astype(float),out=np.zeros_like(nDtClusters[k].astype(float)),where=(nDtClusters[k].astype(float) != 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2afacb34",
   "metadata": {},
   "source": [
    "* Study delta phi with met\n",
    "* Apply at least one csc cluster requirement\n",
    "* Apply L1 plateau"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38016838",
   "metadata": {},
   "source": [
    "# L1 plateau"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7c541ab6",
   "metadata": {},
   "outputs": [],
   "source": [
    "first_in_tr1 = {}\n",
    "first_in_tr2 = {}\n",
    "first_in_tr3 = {}\n",
    "\n",
    "for k in tree_keys:\n",
    "    first_in_ME11[k] = (cscClusterR[k][:,0]>100)&(cscClusterR[k][:,0]<275) &(abs(cscClusterZ[k][:,0])>580)&(abs(cscClusterZ[k][:,0])<632) \n",
    "    first_in_ME12[k] = (cscClusterR[k][:,0]>275)&(cscClusterR[k][:,0]<465) &(abs(cscClusterZ[k][:,0])>668)&(abs(cscClusterZ[k][:,0])<724)\n",
    "    first_in_ME13[k] = (cscClusterR[k][:,0]>505)&(cscClusterR[k][:,0]<700) &(abs(cscClusterZ[k][:,0])>668)&(abs(cscClusterZ[k][:,0])<724)\n",
    "\n",
    "    first_in_ME21[k] = (cscClusterR[k][:,0]>139)&(cscClusterR[k][:,0]<345) &(abs(cscClusterZ[k][:,0])>789)&(abs(cscClusterZ[k][:,0])<850)\n",
    "    first_in_ME22[k] = (cscClusterR[k][:,0]>357)&(cscClusterR[k][:,0]<700) &(abs(cscClusterZ[k][:,0])>791)&(abs(cscClusterZ[k][:,0])<850)\n",
    "\n",
    "    first_in_ME31[k] = (cscClusterR[k][:,0]>160)&(cscClusterR[k][:,0]<345) &(abs(cscClusterZ[k][:,0])>915)&(abs(cscClusterZ[k][:,0])<970)\n",
    "    first_in_ME32[k] = (cscClusterR[k][:,0]>357)&(cscClusterR[k][:,0]<700) &(abs(cscClusterZ[k][:,0])>911)&(abs(cscClusterZ[k][:,0])<970)\n",
    "\n",
    "    first_in_ME41[k] = (cscClusterR[k][:,0]>178)&(cscClusterR[k][:,0]<345) &(abs(cscClusterZ[k][:,0])>1002)&(abs(cscClusterZ[k][:,0])<1063)\n",
    "    first_in_ME42[k] = (cscClusterR[k][:,0]>357)&(cscClusterR[k][:,0]<700) &(abs(cscClusterZ[k][:,0])>1002)&(abs(cscClusterZ[k][:,0])<1063)\n",
    "    \n",
    "    first_in_plateau_ME11[k] = first_in_ME11[k] & (cscClusterSize[k][:,0]>=500)\n",
    "    first_in_plateau_ME21[k] = first_in_ME21[k] & (cscClusterSize[k][:,0]>=500)\n",
    "    first_in_plateau_ME31[k] = first_in_ME31[k] & (cscClusterSize[k][:,0]>=500)\n",
    "    first_in_plateau_ME41[k] = first_in_ME41[k] & (cscClusterSize[k][:,0]>=500)\n",
    "\n",
    "    first_in_plateau_ME12[k] = first_in_ME12[k] & (cscClusterSize[k][:,0]>=200)\n",
    "    first_in_plateau_ME13[k] = first_in_ME13[k] & (cscClusterSize[k][:,0]>=200)\n",
    "    first_in_plateau_ME22[k] = first_in_ME22[k] & (cscClusterSize[k][:,0]>=200)\n",
    "    first_in_plateau_ME32[k] = first_in_ME32[k] & (cscClusterSize[k][:,0]>=200)\n",
    "    first_in_plateau_ME42[k] = first_in_ME42[k] & (cscClusterSize[k][:,0]>=200)    \n",
    "    \n",
    "    first_in_plateau[k] = first_in_plateau_ME11[k] | first_in_plateau_ME12[k] | first_in_plateau_ME13[k] | first_in_plateau_ME21[k] | first_in_plateau_ME22[k] | first_in_plateau_ME31[k] | first_in_plateau_ME32[k] | first_in_plateau_ME41[k] | first_in_plateau_ME42[k]\n",
    "    \n",
    "\n",
    "    first_in_tr1[k] = np.logical_and( cscClusterSize[k][:,0] >= 100, np.logical_and(cscClusterNStation[k][:,0]>=2, np.abs(cscClusterEta[k][:,0])<1.9))\n",
    "    first_in_tr2[k] = np.logical_and( cscClusterSize[k][:,0] >= 200, np.logical_and(cscClusterNStation[k][:,0]==1, np.abs(cscClusterEta[k][:,0])<1.9))\n",
    "    first_in_tr3[k] = np.logical_and( cscClusterSize[k][:,0] >= 500, np.abs(cscClusterEta[k][:,0])>=1.9)\n",
    " \n",
    "    sel_ev[k] = np.logical_and(sel_ev[k],first_in_plateau[k])\n",
    "    \n",
    "    if category==1:\n",
    "        dPhi_csc_csc[k] = ( deltaPhi(  cscClusterPhi[k][:,0].flatten(), cscClusterPhi[k][:,1].flatten() ) )\n",
    "        dEta_csc_csc[k] = (  cscClusterEta[k][:,0].flatten() - cscClusterEta[k][:,1].flatten() )\n",
    "        dR_csc_csc[k]   = deltaR( cscClusterEta[k][:,0].flatten(), cscClusterPhi[k][:,0].flatten(), cscClusterEta[k][:,1].flatten(), cscClusterPhi[k][:,1].flatten() )\n",
    "        dt_csc_csc[k]   = (  cscClusterTime[k][:,0].flatten() - cscClusterTime[k][:,1].flatten() )\n",
    "        min_dphi = 0.65\n",
    "        sel_ev[k] = np.logical_and(sel_ev[k],np.abs(dPhi_csc_csc[k])>min_dphi)\n",
    "    if category==2:\n",
    "        dPhi_csc_dt[k] = ( deltaPhi(  cscClusterPhi[k][:,0].flatten(), dtClusterPhi[k][:,0].flatten() ) )\n",
    "        dEta_csc_dt[k] = (  cscClusterEta[k][:,0].flatten() - dtClusterEta[k][:,0].flatten() )\n",
    "        dR_csc_dt[k]   = deltaR( cscClusterEta[k][:,0].flatten(), cscClusterPhi[k][:,0].flatten(), dtClusterEta[k][:,0].flatten(), dtClusterPhi[k][:,0].flatten() )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "215db933",
   "metadata": {},
   "source": [
    "## Study delta phi met-clusters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d9e34dd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Info in <TCanvas::Print>: pdf file plots/V1p19_v6/CscCscMet_dPhi_in_plateau_exactly_2_csc_clusters_ME_veto.pdf has been created\n",
      "Info in <TCanvas::Print>: png file plots/V1p19_v6/CscCscMet_dPhi_in_plateau_exactly_2_csc_clusters_ME_veto.png 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": [
    "can = rt.TCanvas('c','c', 1000, 800)\n",
    "leg = rt.TLegend(0.12+0.5,0.75,0.37+0.5,0.87)\n",
    "leg.SetTextSize(0.03)\n",
    "leg.SetBorderSize(0)\n",
    "leg.SetEntrySeparation(0.01)\n",
    "h0 = {}\n",
    "h1 = {}\n",
    "h2 = {}\n",
    "can.cd()\n",
    "scale=False\n",
    "scale=True\n",
    "\n",
    "leg.SetHeader(\"First CSC cluster in L1/HLT plateau\")\n",
    "lab = \"\"\n",
    "       \n",
    "for k in tree_keys:\n",
    "        cut = sel_ev[k]\n",
    "        h1[k] = create_TH1D(np.abs(cscClusterMet_dPhi[k][ cut ][:,0].flatten()),title=\"\",axis_title = ['Cluster Met_dPhi','Events'], binning=[20,0,3.2])\n",
    "        h1[k].SetLineColor(2)\n",
    "        h1[k].SetLineWidth(2)\n",
    "        h1[k].SetMarkerColor(2)\n",
    "        h1[k].SetMarkerStyle(20)\n",
    "        h1[k].SetMarkerSize(1.2)\n",
    "        if scale and h1[k].Integral()>0:h1[k].Scale(1./h1[k].Integral())\n",
    "        \n",
    "        h0[k] = create_TH1D(np.abs(cscClusterMet_dPhi[k][ cut ][:,1].flatten()),title=\"\",axis_title = ['Cluster Met_dPhi','Events'], binning=[20,0,3.2])\n",
    "        h0[k].SetLineColor(1)\n",
    "        h0[k].SetLineWidth(2)\n",
    "        h0[k].SetMarkerColor(1)\n",
    "        h0[k].SetMarkerStyle(20)\n",
    "        h0[k].SetMarkerSize(1.2)\n",
    "        if scale and h0[k].Integral()>0:h0[k].Scale(1./h0[k].Integral())\n",
    "        if not scale:\n",
    "            h0[k].SetMinimum(0.8)\n",
    "            h1[k].SetMinimum(0.8)\n",
    "        if 'data' in k:\n",
    "            h0[k].Draw('PE same')\n",
    "            h1[k].Draw('PE same')\n",
    "            leg.AddEntry(h0[k],\"1st CSC data\",\"PE\")\n",
    "            leg.AddEntry(h1[k],\"2nd CSC data\",\"PE\")\n",
    "        else:\n",
    "            h0[k].Draw('HISTO same')\n",
    "            h1[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h0[k],\"1st CSC signal\",\"L\")\n",
    "            leg.AddEntry(h1[k],\"2nd CSC signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\n",
    "\n",
    "#print(\"??\")\n",
    "leg.Draw()\n",
    "can.SetRightMargin(0.05)\n",
    "drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "can.SetLogy()\n",
    "can.Draw()\n",
    "can.Print(\"plots/V1p19_\"+vers+\"/CscCscMet_dPhi_in_plateau\"+lab+plot_string+\".pdf\")\n",
    "can.Print(\"plots/V1p19_\"+vers+\"/CscCscMet_dPhi_in_plateau\"+lab+plot_string+\".png\")\n",
    "#can.Close()        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "92fcfdbd",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Info in <TCanvas::Print>: pdf file plots/V1p19_v6/CscCscJetVetoPt_in_plateau_exactly_2_csc_clusters_ME_veto.pdf has been created\n",
      "Info in <TCanvas::Print>: png file plots/V1p19_v6/CscCscJetVetoPt_in_plateau_exactly_2_csc_clusters_ME_veto.png 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": [
    "can = rt.TCanvas('c','c', 1000, 800)\n",
    "leg = rt.TLegend(0.12+0.5,0.75,0.37+0.5,0.87)\n",
    "leg.SetTextSize(0.03)\n",
    "leg.SetBorderSize(0)\n",
    "leg.SetEntrySeparation(0.01)\n",
    "h0 = {}\n",
    "h1 = {}\n",
    "h2 = {}\n",
    "can.cd()\n",
    "scale=False\n",
    "#scale=True\n",
    "\n",
    "leg.SetHeader(\"First CSC cluster in L1/HLT plateau\")\n",
    "lab = \"\"\n",
    "       \n",
    "for k in tree_keys:\n",
    "        cut = sel_ev[k] & (np.abs(dEta_csc_csc[k])<2)\n",
    "        h1[k] = create_TH1D(np.abs(cscClusterJetVetoPt[k][ cut ][:,0].flatten()),title=\"\",axis_title = ['jet veto pt','Events'], binning=[20,0,200])\n",
    "        h1[k].SetLineColor(2)\n",
    "        h1[k].SetLineWidth(2)\n",
    "        h1[k].SetMarkerColor(2)\n",
    "        h1[k].SetMarkerStyle(20)\n",
    "        h1[k].SetMarkerSize(1.2)\n",
    "        if scale and h1[k].Integral()>0:h1[k].Scale(1./h1[k].Integral())\n",
    "        \n",
    "        h0[k] = create_TH1D(np.abs(cscClusterJetVetoPt[k][ cut ][:,1].flatten()),title=\"\",axis_title = ['jet veto pt','Events'], binning=[20,0,200])\n",
    "        h0[k].SetLineColor(1)\n",
    "        h0[k].SetLineWidth(2)\n",
    "        h0[k].SetMarkerColor(1)\n",
    "        h0[k].SetMarkerStyle(20)\n",
    "        h0[k].SetMarkerSize(1.2)\n",
    "        if scale and h0[k].Integral()>0:h0[k].Scale(1./h0[k].Integral())\n",
    "        if not scale:\n",
    "            h0[k].SetMinimum(0.8)\n",
    "            h1[k].SetMinimum(0.8)\n",
    "        if 'data' in k:\n",
    "            h0[k].Draw('PE same')\n",
    "            h1[k].Draw('PE same')\n",
    "            leg.AddEntry(h0[k],\"1st CSC data\",\"PE\")\n",
    "            leg.AddEntry(h1[k],\"2nd CSC data\",\"PE\")\n",
    "        else:\n",
    "            h0[k].Draw('HISTO same')\n",
    "            h1[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h0[k],\"1st CSC signal\",\"L\")\n",
    "            leg.AddEntry(h1[k],\"2nd CSC signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\n",
    "\n",
    "#print(\"??\")\n",
    "leg.Draw()\n",
    "can.SetRightMargin(0.05)\n",
    "drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "can.SetLogy()\n",
    "can.Draw()\n",
    "can.Print(\"plots/V1p19_\"+vers+\"/CscCscJetVetoPt_in_plateau\"+lab+plot_string+\".pdf\")\n",
    "can.Print(\"plots/V1p19_\"+vers+\"/CscCscJetVetoPt_in_plateau\"+lab+plot_string+\".png\")\n",
    "#can.Close()        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6825f525",
   "metadata": {},
   "source": [
    "## Signal 2D plot"
   ]
  },
  {
   "cell_type": "raw",
   "id": "1faa94d4",
   "metadata": {},
   "source": [
    "if category == 2 or category==1:\n",
    "    can = rt.TCanvas('c','c', 1000, 800)\n",
    "    leg = rt.TLegend(0.5,0.65,0.65,0.88)\n",
    "    leg.SetTextSize(0.03)\n",
    "    leg.SetBorderSize(0)\n",
    "    leg.SetEntrySeparation(0.01)\n",
    "    h2 = {}\n",
    "    can.cd()\n",
    "\n",
    "    for k in tree_keys:\n",
    "        cut = sel_ev[k]\n",
    "        x_val = cscClusterSize[k][ cut ][:,0]\n",
    "        y_val = cscClusterSize[k][ cut ][:,1]\n",
    "        h2[k] = create_TH2D(np.vstack((x_val, y_val)).T,title=\"\",axis_title = ['CSC Cluster[0] Size','CSC Cluster[1] Size','Events'], binning=[50,200,1200,50,50,1050])\n",
    "        leg.SetHeader('CSC-CSC, presel.')\n",
    "        #h2[k].SetMaximum(100)\n",
    "        if 'signal' in k:\n",
    "            h2[k].Draw(\"colz\")\n",
    "        \n",
    "    leg.Draw()\n",
    "    can.SetRightMargin(0.15)\n",
    "    # if setlog: \n",
    "    can.SetLogz()\n",
    "    can.Draw()\n",
    "    drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "    can.Print(\"plots/V1p19_\"+vers+\"/CscCscClusterSize_signal_2D\"+plot_string+\".pdf\")\n",
    "    can.Print(\"plots/V1p19_\"+vers+\"/CscCscClusterSize_signal_2D\"+plot_string+\".png\")\n",
    "    #can.Close()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "747c6500",
   "metadata": {},
   "source": [
    "if category==1:\n",
    "\n",
    "    h2 = {}\n",
    "    for k in tree_keys:\n",
    "        print(k)\n",
    "        can = rt.TCanvas('c','c', 1000, 800)\n",
    "        leg = rt.TLegend(0.5,0.65,0.65,0.88)\n",
    "        leg.SetTextSize(0.03)\n",
    "        leg.SetBorderSize(0)\n",
    "        leg.SetEntrySeparation(0.01)\n",
    "        \n",
    "        can.cd()\n",
    "        cut = sel_ev[k] & ( np.abs(dEta_csc_csc[k])>2 )\n",
    "        x_val = np.abs( deltaPhi(  cscClusterPhi[k][cut][:,0].flatten(), cscClusterPhi[k][cut][:,1].flatten() ) )\n",
    "        y_val = cscClusterSize[k][ cut ][:,1]\n",
    "        h2[k] = create_TH2D(np.vstack((x_val, y_val)).T,title=\"\",axis_title = ['#Delta #varphi (CSC,CSC)','CSC Cluster[1] Size','Events'], binning=[25,0,3.2,25,50,550])\n",
    "        leg.SetHeader('CSC-CSC, presel.'+k)\n",
    "        #h2[k].SetMaximum(100)\n",
    "        #if 'signal' in k:\n",
    "        h2[k].Scale(1./h2[k].Integral())\n",
    "        h2[k].Draw(\"colz\")\n",
    "        \n",
    "        leg.Draw()\n",
    "        can.SetRightMargin(0.15)\n",
    "        # if setlog: \n",
    "        can.SetLogz()\n",
    "        can.Draw()\n",
    "        drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "        can.Print(\"plots/V1p19_\"+vers+\"/ABCD_plane_\"+str(k)+plot_string+\".pdf\")\n",
    "        can.Print(\"plots/V1p19_\"+vers+\"/ABCD_plane_\"+str(k)+plot_string+\".png\")\n",
    "        #can.Close()\n",
    "        \n",
    "    can = rt.TCanvas('c','c', 1000, 800)\n",
    "    leg = rt.TLegend(0.5,0.65,0.65,0.88)\n",
    "    leg.SetTextSize(0.03)\n",
    "    leg.SetBorderSize(0)\n",
    "    leg.SetEntrySeparation(0.01)\n",
    "    can.cd()\n",
    "    leg.Draw()\n",
    "    can.SetRightMargin(0.15)\n",
    "    h2['signal'].Divide(h2['data'])\n",
    "    h2[k].Draw(\"colz\")\n",
    "    can.SetLogz()\n",
    "    can.Draw()\n",
    "    drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "    can.Print(\"plots/V1p19_\"+vers+\"/ABCD_plane_ratio\"+plot_string+\".pdf\")\n",
    "    can.Print(\"plots/V1p19_\"+vers+\"/ABCD_plane_ratio\"+plot_string+\".png\")\n",
    "    #can.Close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4d9cbe4",
   "metadata": {},
   "source": [
    "## OOT control region"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eee4cbb0",
   "metadata": {},
   "source": [
    "* Beam Halo clusters are smaller (less hits) --> can't claim IT and OOT have the same shape\n",
    "* Also can't claim small/large dEta have the same shape\n",
    "* small/large dPhi are more similar instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "f3b695df",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Info in <TCanvas::Print>: pdf file plots/V1p19_v6/DeltaPhi_HLT_categories_exactly_2_csc_clusters_ME_veto.pdf has been created\n",
      "Info in <TCanvas::Print>: png file plots/V1p19_v6/DeltaPhi_HLT_categories_exactly_2_csc_clusters_ME_veto.png 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": [
    "can = rt.TCanvas('c','c', 1000, 800)\n",
    "leg = rt.TLegend(0.12+0.4,0.7,0.37+0.5,0.87)\n",
    "leg.SetTextSize(0.03)\n",
    "leg.SetBorderSize(0)\n",
    "leg.SetEntrySeparation(0.01)\n",
    "h0 = {}\n",
    "h1 = {}\n",
    "h2 = {}\n",
    "h3 = {}\n",
    "can.cd()\n",
    "scale=False\n",
    "#scale=True\n",
    "\n",
    "leg.SetHeader(\"First CSC cluster in L1/HLT plateau\")\n",
    "lab = \"\"\n",
    "       \n",
    "for k in tree_keys:\n",
    "        cut = sel_ev[k] & (np.abs(dPhi_csc_csc[k])>0.7) & (np.abs(dEta_csc_csc[k])<1.9) & ((np.abs(dPhi_csc_csc[k])>1.))# & (np.abs(dEta_csc_csc[k])<0.4)) #& (np.abs(cscClusterTime[k][:,1])<50) #& (sel_muonveto_csc[k][:,0]==False) #& (sel_jetveto_csc[k][:,0]==True) #& (dEta_csc_csc[k]<1.9)\n",
    "        h1[k] = create_TH1D( np.abs(dPhi_csc_csc[k][cut & first_in_tr1[k] ]),title=\"\",axis_title = ['|#Delta #varphi| (CSC,CSC)','Events'], binning=[50,0,3.2])\n",
    "        h1[k].SetLineColor(2)\n",
    "        h1[k].SetLineWidth(2)\n",
    "        h1[k].SetMarkerColor(2)\n",
    "        h1[k].SetMarkerStyle(20)\n",
    "        h1[k].SetMarkerSize(1.2)\n",
    "        if scale and h1[k].Integral()>0:h1[k].Scale(1./h1[k].Integral())\n",
    "\n",
    "        h2[k] = create_TH1D(np.abs(dPhi_csc_csc[k][ cut & first_in_tr2[k] ] ),title=\"\",axis_title = ['phi','Events'], binning=[50,0,3.2])\n",
    "        h2[k].SetLineColor(1)\n",
    "        h2[k].SetLineWidth(2)\n",
    "        h2[k].SetMarkerColor(1)\n",
    "        h2[k].SetMarkerStyle(20)\n",
    "        h2[k].SetMarkerSize(1.2)\n",
    "        if scale and h2[k].Integral()>0:h2[k].Scale(1./h2[k].Integral()) \n",
    "        \n",
    "        h3[k] = create_TH1D(np.abs(dPhi_csc_csc[k][ cut & first_in_tr3[k] ] ),title=\"\",axis_title = ['phi','Events'], binning=[50,0,3.2])\n",
    "        h3[k].SetLineColor(4)\n",
    "        h3[k].SetLineWidth(2)\n",
    "        h3[k].SetMarkerColor(4)\n",
    "        h3[k].SetMarkerStyle(20)\n",
    "        h3[k].SetMarkerSize(1.2)\n",
    "        if scale and h3[k].Integral()>0:h3[k].Scale(1./h3[k].Integral())\n",
    "            \n",
    "        if not scale:\n",
    "            h1[k].SetMinimum(0.8)\n",
    "            h1[k].SetMaximum(1.e5)\n",
    "        else:\n",
    "            h1[k].SetMaximum(1)\n",
    "            h1[k].SetMinimum(0.001)\n",
    "        if 'data' in k:\n",
    "            h1[k].Draw('PE same')\n",
    "            h2[k].Draw('PE same')\n",
    "            h3[k].Draw('PE same')\n",
    "            leg.AddEntry(h1[k],\"data |#eta|<1.9, 2 stations, n hits>=100\",\"PE\")\n",
    "            leg.AddEntry(h2[k],\"data |#eta|<1.9, 1 station, n hits>=200\",\"PE\")\n",
    "            leg.AddEntry(h3[k],\"data |#eta|>=1.9, n hits>=500\",\"PE\")\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            h2[k].Draw('HISTO same')\n",
    "            h3[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h2[k],\"same cuts, signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\n",
    "\n",
    "#print(\"??\")\n",
    "leg.Draw()\n",
    "can.SetRightMargin(0.05)\n",
    "drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "can.SetLogy()\n",
    "can.Draw()\n",
    "can.Print(\"plots/V1p19_\"+vers+\"/DeltaPhi_HLT_categories\"+lab+plot_string+\".pdf\")\n",
    "can.Print(\"plots/V1p19_\"+vers+\"/DeltaPhi_HLT_categories\"+lab+plot_string+\".png\")\n",
    "#can.Close()        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "4289cba8",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Info in <TCanvas::Print>: pdf file plots/V1p19_v6/DeltaEta_HLT_categories_exactly_2_csc_clusters_ME_veto.pdf has been created\n",
      "Info in <TCanvas::Print>: png file plots/V1p19_v6/DeltaEta_HLT_categories_exactly_2_csc_clusters_ME_veto.png 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": [
    "can = rt.TCanvas('c','c', 1000, 800)\n",
    "leg = rt.TLegend(0.12+0.4,0.7,0.37+0.5,0.87)\n",
    "leg.SetTextSize(0.03)\n",
    "leg.SetBorderSize(0)\n",
    "leg.SetEntrySeparation(0.01)\n",
    "h0 = {}\n",
    "h1 = {}\n",
    "h2 = {}\n",
    "h3 = {}\n",
    "can.cd()\n",
    "scale=False\n",
    "#scale=True\n",
    "\n",
    "leg.SetHeader(\"First CSC cluster in L1/HLT plateau\")\n",
    "lab = \"\"\n",
    "       \n",
    "for k in tree_keys:\n",
    "        cut = sel_ev[k] & (np.abs(dPhi_csc_csc[k])>0.7) & np.logical_not( (np.abs(dR_csc_csc[k])<1.4))# & (np.abs(dEta_csc_csc[k])<0.4))\n",
    "        h1[k] = create_TH1D( np.abs(dEta_csc_csc[k][cut & first_in_tr1[k] ]),title=\"\",axis_title = ['|#Delta #eta| (CSC,CSC)','Events'], binning=[50,0,5])\n",
    "        h1[k].SetLineColor(2)\n",
    "        h1[k].SetLineWidth(2)\n",
    "        h1[k].SetMarkerColor(2)\n",
    "        h1[k].SetMarkerStyle(20)\n",
    "        h1[k].SetMarkerSize(1.2)\n",
    "        if scale and h1[k].Integral()>0:h1[k].Scale(1./h1[k].Integral())\n",
    "\n",
    "        h2[k] = create_TH1D(np.abs(dEta_csc_csc[k][ cut & first_in_tr2[k] ] ),title=\"\",axis_title = ['phi','Events'], binning=[50,0,5])\n",
    "        h2[k].SetLineColor(1)\n",
    "        h2[k].SetLineWidth(2)\n",
    "        h2[k].SetMarkerColor(1)\n",
    "        h2[k].SetMarkerStyle(20)\n",
    "        h2[k].SetMarkerSize(1.2)\n",
    "        if scale and h2[k].Integral()>0:h2[k].Scale(1./h2[k].Integral()) \n",
    "        \n",
    "        h3[k] = create_TH1D(np.abs(dEta_csc_csc[k][ cut & first_in_tr3[k] ] ),title=\"\",axis_title = ['phi','Events'], binning=[50,0,5])\n",
    "        h3[k].SetLineColor(4)\n",
    "        h3[k].SetLineWidth(2)\n",
    "        h3[k].SetMarkerColor(4)\n",
    "        h3[k].SetMarkerStyle(20)\n",
    "        h3[k].SetMarkerSize(1.2)\n",
    "        if scale and h3[k].Integral()>0:h3[k].Scale(1./h3[k].Integral())\n",
    "            \n",
    "        if not scale:\n",
    "            h1[k].SetMinimum(0.8)\n",
    "            h1[k].SetMaximum(1.e5)\n",
    "        else:\n",
    "            h1[k].SetMaximum(1)\n",
    "            h1[k].SetMinimum(0.001)\n",
    "        if 'data' in k:\n",
    "            h1[k].Draw('PE same')\n",
    "            h2[k].Draw('PE same')\n",
    "            h3[k].Draw('PE same')\n",
    "            leg.AddEntry(h1[k],\"data |#eta|<1.9, 2 stations, n hits>=100\",\"PE\")\n",
    "            leg.AddEntry(h2[k],\"data |#eta|<1.9, 1 station, n hits>=200\",\"PE\")\n",
    "            leg.AddEntry(h3[k],\"data |#eta|>=1.9, n hits>=500\",\"PE\")\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            h2[k].Draw('HISTO same')\n",
    "            h3[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h2[k],\"same cuts, signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\n",
    "\n",
    "#print(\"??\")\n",
    "leg.Draw()\n",
    "can.SetRightMargin(0.05)\n",
    "drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "can.SetLogy()\n",
    "can.Draw()\n",
    "can.Print(\"plots/V1p19_\"+vers+\"/DeltaEta_HLT_categories\"+lab+plot_string+\".pdf\")\n",
    "can.Print(\"plots/V1p19_\"+vers+\"/DeltaEta_HLT_categories\"+lab+plot_string+\".png\")\n",
    "#can.Close()        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "e65d12b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Info in <TCanvas::Print>: pdf file plots/V1p19_v6/DeltaR_HLT_categories_exactly_2_csc_clusters_ME_veto.pdf has been created\n",
      "Info in <TCanvas::Print>: png file plots/V1p19_v6/DeltaR_HLT_categories_exactly_2_csc_clusters_ME_veto.png 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": [
    "can = rt.TCanvas('c','c', 1000, 800)\n",
    "leg = rt.TLegend(0.12+0.4,0.7,0.37+0.5,0.87)\n",
    "leg.SetTextSize(0.03)\n",
    "leg.SetBorderSize(0)\n",
    "leg.SetEntrySeparation(0.01)\n",
    "h0 = {}\n",
    "h1 = {}\n",
    "h2 = {}\n",
    "h3 = {}\n",
    "can.cd()\n",
    "scale=False\n",
    "#scale=True\n",
    "\n",
    "leg.SetHeader(\"First CSC cluster in L1/HLT plateau\")\n",
    "lab = \"\"\n",
    "       \n",
    "for k in tree_keys:\n",
    "        cut = sel_ev[k] & (np.abs(dPhi_csc_csc[k])>0.7) & (np.abs(dEta_csc_csc[k])<1.9) & np.logical_not( (np.abs(dR_csc_csc[k])<1.2))# & (np.abs(dEta_csc_csc[k])<0.5))\n",
    "        h1[k] = create_TH1D( np.abs(dR_csc_csc[k][cut & first_in_tr1[k] ]),title=\"\",axis_title = ['|#Delta R| (CSC,CSC)','Events'], binning=[60,0,6])\n",
    "        h1[k].SetLineColor(2)\n",
    "        h1[k].SetLineWidth(2)\n",
    "        h1[k].SetMarkerColor(2)\n",
    "        h1[k].SetMarkerStyle(20)\n",
    "        h1[k].SetMarkerSize(1.2)\n",
    "        if scale and h1[k].Integral()>0:h1[k].Scale(1./h1[k].Integral())\n",
    "\n",
    "        h2[k] = create_TH1D(np.abs(dR_csc_csc[k][ cut & first_in_tr2[k] ] ),title=\"\",axis_title = ['phi','Events'], binning=[60,0,6])\n",
    "        h2[k].SetLineColor(1)\n",
    "        h2[k].SetLineWidth(2)\n",
    "        h2[k].SetMarkerColor(1)\n",
    "        h2[k].SetMarkerStyle(20)\n",
    "        h2[k].SetMarkerSize(1.2)\n",
    "        if scale and h2[k].Integral()>0:h2[k].Scale(1./h2[k].Integral()) \n",
    "        \n",
    "        h3[k] = create_TH1D(np.abs(dR_csc_csc[k][ cut & first_in_tr3[k] ] ),title=\"\",axis_title = ['phi','Events'], binning=[60,0,6])\n",
    "        h3[k].SetLineColor(4)\n",
    "        h3[k].SetLineWidth(2)\n",
    "        h3[k].SetMarkerColor(4)\n",
    "        h3[k].SetMarkerStyle(20)\n",
    "        h3[k].SetMarkerSize(1.2)\n",
    "        if scale and h3[k].Integral()>0:h3[k].Scale(1./h3[k].Integral())\n",
    "            \n",
    "        if not scale:\n",
    "            h1[k].SetMinimum(0.8)\n",
    "            h1[k].SetMaximum(1.e5)\n",
    "        else:\n",
    "            h1[k].SetMaximum(1)\n",
    "            h1[k].SetMinimum(0.001)\n",
    "        if 'data' in k:\n",
    "            h1[k].Draw('PE same')\n",
    "            h2[k].Draw('PE same')\n",
    "            h3[k].Draw('PE same')\n",
    "            leg.AddEntry(h1[k],\"data |#eta|<1.9, 2 stations, n hits>=100\",\"PE\")\n",
    "            leg.AddEntry(h2[k],\"data |#eta|<1.9, 1 station, n hits>=200\",\"PE\")\n",
    "            leg.AddEntry(h3[k],\"data |#eta|>=1.9, n hits>=500\",\"PE\")\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            h2[k].Draw('HISTO same')\n",
    "            h3[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h2[k],\"same cuts, signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\n",
    "\n",
    "#print(\"??\")\n",
    "leg.Draw()\n",
    "can.SetRightMargin(0.05)\n",
    "drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "can.SetLogy()\n",
    "can.Draw()\n",
    "can.Print(\"plots/V1p19_\"+vers+\"/DeltaR_HLT_categories\"+lab+plot_string+\".pdf\")\n",
    "can.Print(\"plots/V1p19_\"+vers+\"/DeltaR_HLT_categories\"+lab+plot_string+\".png\")\n",
    "#can.Close()        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "42a5a0da",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Info in <TCanvas::Print>: pdf file plots/V1p19_v6/DeltaTime_HLT_categories_exactly_2_csc_clusters_ME_veto.pdf has been created\n",
      "Info in <TCanvas::Print>: png file plots/V1p19_v6/DeltaTime_HLT_categories_exactly_2_csc_clusters_ME_veto.png 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": [
    "can = rt.TCanvas('c','c', 1000, 800)\n",
    "leg = rt.TLegend(0.12+0.4,0.7,0.37+0.5,0.87)\n",
    "leg.SetTextSize(0.03)\n",
    "leg.SetBorderSize(0)\n",
    "leg.SetEntrySeparation(0.01)\n",
    "h0 = {}\n",
    "h1 = {}\n",
    "h2 = {}\n",
    "h3 = {}\n",
    "can.cd()\n",
    "scale=False\n",
    "#scale=True\n",
    "\n",
    "leg.SetHeader(\"First CSC cluster in L1/HLT plateau\")\n",
    "lab = \"\"\n",
    "       \n",
    "for k in tree_keys:\n",
    "        cut = sel_ev[k]\n",
    "        h1[k] = create_TH1D( np.abs(dt_csc_csc[k][sel_ev[k] & first_in_tr1[k] ]),title=\"\",axis_title = ['|#Delta t| (CSC,CSC)','Events'], binning=[50,0,100])\n",
    "        h1[k].SetLineColor(2)\n",
    "        h1[k].SetLineWidth(2)\n",
    "        h1[k].SetMarkerColor(2)\n",
    "        h1[k].SetMarkerStyle(20)\n",
    "        h1[k].SetMarkerSize(1.2)\n",
    "        if scale and h1[k].Integral()>0:h1[k].Scale(1./h1[k].Integral())\n",
    "\n",
    "        h2[k] = create_TH1D(np.abs(dt_csc_csc[k][ sel_ev[k] & first_in_tr2[k] ] ),title=\"\",axis_title = ['phi','Events'], binning=[50,0,100])\n",
    "        h2[k].SetLineColor(1)\n",
    "        h2[k].SetLineWidth(2)\n",
    "        h2[k].SetMarkerColor(1)\n",
    "        h2[k].SetMarkerStyle(20)\n",
    "        h2[k].SetMarkerSize(1.2)\n",
    "        if scale and h2[k].Integral()>0:h2[k].Scale(1./h2[k].Integral()) \n",
    "        \n",
    "        h3[k] = create_TH1D(np.abs(dt_csc_csc[k][ sel_ev[k] & first_in_tr3[k] ] ),title=\"\",axis_title = ['phi','Events'], binning=[50,0,100])\n",
    "        h3[k].SetLineColor(4)\n",
    "        h3[k].SetLineWidth(2)\n",
    "        h3[k].SetMarkerColor(4)\n",
    "        h3[k].SetMarkerStyle(20)\n",
    "        h3[k].SetMarkerSize(1.2)\n",
    "        if scale and h3[k].Integral()>0:h3[k].Scale(1./h3[k].Integral())\n",
    "            \n",
    "        if not scale:\n",
    "            h1[k].SetMinimum(0.8)\n",
    "            h1[k].SetMaximum(1.e5)\n",
    "        else:\n",
    "            h1[k].SetMaximum(1)\n",
    "            h1[k].SetMinimum(0.001)\n",
    "        if 'data' in k:\n",
    "            h1[k].Draw('PE same')\n",
    "            h2[k].Draw('PE same')\n",
    "            h3[k].Draw('PE same')\n",
    "            leg.AddEntry(h1[k],\"data |#eta|<1.9, 2 stations, n hits>=100\",\"PE\")\n",
    "            leg.AddEntry(h2[k],\"data |#eta|<1.9, 1 station, n hits>=200\",\"PE\")\n",
    "            leg.AddEntry(h3[k],\"data |#eta|>=1.9, n hits>=500\",\"PE\")\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            h2[k].Draw('HISTO same')\n",
    "            h3[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h2[k],\"same cuts, signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\n",
    "\n",
    "#print(\"??\")\n",
    "leg.Draw()\n",
    "can.SetRightMargin(0.05)\n",
    "drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "can.SetLogy()\n",
    "can.Draw()\n",
    "can.Print(\"plots/V1p19_\"+vers+\"/DeltaTime_HLT_categories\"+lab+plot_string+\".pdf\")\n",
    "can.Print(\"plots/V1p19_\"+vers+\"/DeltaTime_HLT_categories\"+lab+plot_string+\".png\")\n",
    "#can.Close()        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6e84ad4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "can = rt.TCanvas('c','c', 1000, 800)\n",
    "leg = rt.TLegend(0.12+0.5,0.75,0.37+0.5,0.87)\n",
    "leg.SetTextSize(0.03)\n",
    "leg.SetBorderSize(0)\n",
    "leg.SetEntrySeparation(0.01)\n",
    "h0 = {}\n",
    "h1 = {}\n",
    "h2 = {}\n",
    "can.cd()\n",
    "scale=False\n",
    "scale=True\n",
    "\n",
    "leg.SetHeader(\"First CSC cluster in L1/HLT plateau\")\n",
    "lab = \"\"\n",
    "       \n",
    "for k in tree_keys:\n",
    "        cut = sel_ev[k]\n",
    "        h1[k] = create_TH1D( np.abs(dt_csc_csc[k][sel_ev[k] & (np.abs(dPhi_csc_csc[k])>2) ]),title=\"\",axis_title = ['xxx','Events'], binning=[100,0,100])\n",
    "        h1[k].SetLineColor(2)\n",
    "        h1[k].SetLineWidth(2)\n",
    "        h1[k].SetMarkerColor(2)\n",
    "        h1[k].SetMarkerStyle(20)\n",
    "        h1[k].SetMarkerSize(1.2)\n",
    "        if scale and h1[k].Integral()>0:h1[k].Scale(1./h1[k].Integral())\n",
    "            \n",
    "        h0[k] = create_TH1D( np.abs(dt_csc_csc[k][sel_ev[k] & (np.abs(dPhi_csc_csc[k])<1) ]),title=\"\",axis_title = ['xxx','Events'], binning=[100,0,100])\n",
    "        h0[k].SetLineColor(1)\n",
    "        h0[k].SetLineWidth(2)\n",
    "        h0[k].SetMarkerColor(1)\n",
    "        h0[k].SetMarkerStyle(20)\n",
    "        h0[k].SetMarkerSize(1.2)\n",
    "        if scale and h0[k].Integral()>0:h0[k].Scale(1./h0[k].Integral())\n",
    "\n",
    "        \n",
    "        if not scale:\n",
    "            h1[k].SetMinimum(0.8)\n",
    "            h0[k].SetMinimum(0.8)\n",
    "        else:\n",
    "            h1[k].SetMaximum(1)\n",
    "            h1[k].SetMinimum(0.001)\n",
    "        if 'data' in k:\n",
    "            h1[k].Draw('PE same')\n",
    "            leg.AddEntry(h1[k],\"data\",\"PE\")\n",
    "            h0[k].Draw('PE same')\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h1[k],\"signal\",\"L\")\n",
    "            h0[k].Draw('HISTO same')\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\n",
    "\n",
    "#print(\"??\")\n",
    "leg.Draw()\n",
    "can.SetRightMargin(0.05)\n",
    "drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "can.SetLogy()\n",
    "can.Draw()\n",
    "#can.Print(\"plots/V1p19_\"+vers+\"/test_in_plateau\"+lab+plot_string+\".pdf\")\n",
    "#can.Print(\"plots/V1p19_\"+vers+\"/test_in_plateau\"+lab+plot_string+\".png\")\n",
    "#can.Close()        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "788d3588",
   "metadata": {},
   "source": [
    "### Cut away delta phi turn-on events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "660b961a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:71: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+QAAAMECAIAAAC5e3jEAAAABmJLR0QAAAAAAAD5Q7t/AAAgAElEQVR4nO3dT+w76X0f9pn1T1q1UfUnQv85bYwcUhtwWvngU53uDFdCgaCwD+2h6cFAATc5GSjsnHc5lA49JUKLFAVquIe2QJ1LC6RAWlS7y6Hd+pQCURIBdWLAgOI0QQ1D0lYpZMkSe3j8ezw7/zgk58t5hvN6YbH4/shnhs8Mh+SbDz/zTH4+nzMAACA9byzdAQAAoJ+wDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQDuUlXV0l3gaQnrAAC3q6rqcDgs3QueVn4+n5fuAwDAKtV1vdvtsiwTqHghr5buwDOrqqqu6yzLTqdTuKUoivK1KWsIi/e6uIaRZacsng30Pyw7fRMYfyJakt2rza3odvKDDz6If7/99tsP6VGP8U4CzKssy/j5CC/ozNz2+/2UPb/f78fXczwe71k8BOshx+Nx5HHHl42Korh252zQxJ2Z+I5tbkXrrvfffz/e9e677y7SvaC5DxfsBrARx+Nxv9/HD/2lu8PTUrM+p7qu8zyfWLh2OBzyPL/5lJSL47W3fd0vy3K3201c9nQ63bMJG3HDE5Hgjm39utJ7V++9i5j4hRngHmVZVlVVVVUib308K2Uws4lVa1c5HA51XV9VKRG8xE9veZ7fsNTNm8C4w+GQYLlRtz/NQ1ENDJCgMPYR31HDP5MaEAmqqkrwbf9aV+3Y27a39YRObxm+XF37cMtbemj/SYyXrFzUW9NycZ3jpSzXLnvnwMDFspxtaj0Rx1G948FLb8H5/NGt6B45ifS2ufcW7AY8sf1+Hz8piqIYf9u/qvGU9dy2kubbV1g83nJbf3qFHt65kvAmNvLJfj6fp3zazrXnQ01s3PnjHWsudVV4uK3sc+KysTNxJ9z8iMvyqTaPi8fixSjcfRlcPOJHXoHXPtzIY4WCvFZlXq/5d+v6NffYxDeIiwfG48nBsHEjb/5XfXhdFRyH1nPVSprvwKGrt4X18Q7MEtYvfkyEZ2Gkzciev/ajpDdFTPkUe0xYj92b2Cxu/pRvRAny0TuDoWTc+0105Die3vLiIX7x5dHqWO8mDL0hDnVsdUf/AzR37PT9M+VZeKSRs0uBp9canA5jNyNvC80PqTDKc+c7YVzPzStptr8trO8bhn6avmqFvWu4OKyeTfvo793z0zszsp7bsvXs5+B2h8x79W77Gj/LVtbdBN321b93kemj3RdfexcXbD3Wtf3vXWSNPy29tClP1vhSKYR1TzFs2cUPqeY7Q4xlQyVzE99GumOirc5MWUlvLk+zDGakS60iyaEdOLTHep+mEfGxWp8+I8/s9HVeu+CIi0fCUKAPnUnhs3U6Yf1eV41JN3WXar2Qbg7rUxa8GNYv9j/ZAuuk3LZzmgfVS7yhvP/++1e1f9HOACkbH8LsViOEf/bmwomlC+PruSpqryWsh8W7e7j303woc7/0no933fBB8BJh/eJGjTzo6hKLqRvv1Tsry5Rzjbthd8oEL62leudgad34QtPYrf109QdoPhFXnb/bPBJa+7l6Lb6JH4/Hsizz14bWud/vY5svfOEL4Y+yLJvXM+rVPJi7T3r8Xbi7nrquY2+ba8s/qizL7mE8sdn4YzXX1rqrruvmToumT2oUJm3ormG8n0P9aW5v2MnvNkzpz7XtYaJ4PA+9uFrNgt4PiOmfGiMPGldy8XM2zKsY/27+s/lArRfyIjObhff8WWYp6V3JLHs+ez1Hwkt/+rfe/4feVGMPh/bbyDza4RN5TbPYLf1tYd16c/A9Z0xfbNC6cfw7dO8ivZ28bSuOHVM2fDuah8dtZ0R1X6Hx9g8++ODc98NOd20X09v4b6PjJY/xru7lkFqnpY5/aWyd/XOx2fQ9dv7or6XHS9f8mjLTwsjiI93o3S3dl2fowFtvvRVv+epXvzrepXfeeWd6Y7jK+Jhoc9Qgtu+t6r64quktp4wT937w7T86G8wsJ7A2u3TtUs2uTqlRCd0bahn2/Ej37t/zN5u+2t5nZOhJifd27xr/RejiqbqpEdbv0vupP33x8bA7lOYvPlyrwW1hvduGa912TlUrCzbvao5en/sOv+5bT+8z22uoPyNtml8DuqU1zROSpvyw0LtFE/sZ7x350Twb/mxuGXmyrvqFZHwN4QT0oUe/Kn/Hlm+99dZ4S5jXVdlu6EXaNR4uJ0bPZql38xO29boLXy1adeGPLPkbqoHpmr4Db16wu29nGYmbeJy0npTzpYmDR1Y78UvmDduyiNV0NE3dD9oZv6gNhfVWXBjv1XggiK6a0IaJxp+mXq0nq7XzW+cYdZ+sMNze24HQ4N13333//ffff//97nD7eB1kb4OJg+69h9P4CHdzw7u/FI3stO4HXu+jtA7s1heki+dvNVcSdUfcx4eChjoWmjXD+jvvvNPbn+CqMXiYUXzpjXzwdV8dUz5Titdze/feO/0bQm8mG3/HiHddXPlcpu+Wi3u7qbvnp3cmPET3PermPDDlKbvh1OSR4fOL++rOLXowYf0u3c/aGb+OD4X1ViYYH48PX0+76xlJgUOKohj6cZOu1m6/YZHuUr3xrhXQo1az3pNKW5G922bip1rvBo4fcr1teh+lteHdBuM5oPsQvT0Z+UFjYoNuV0fO0Lq4yV/96ldjg5Gw3mxmWJ1Har45TGkz3rJl5BV0njWsj6z8YYPr0/fM+G5pau356cOIsX33neqe3TLlKRtZ/8hAeO9TORLipzxcgoT1u3SP4xmz7FBY78bx5lLdKD8lrPduy7jijuuibUFrFHy8ce8w88XnaGS1rRQ+8tDj4XJiDh4vPuldtrv+bPh9c/zn6asG+HvX3205fu/Iy7y54Rd3y/iqYpuRFD5x02BeE2v8ugf8xNQ43niusD7U8/G3o3ldVY8xfR/euee7i4yXo1x08Sm7+UnpHY+fcoRMrz5KgdlgbrfUecStE7Fb3Wid/jz9rO3zlXn9dDodDoeJ019sUHOfnE6n7rQhTbvdrjUX0PHSGfdFUYzs9i996Uvx7/Fnthnru/MRNR+i1Z9mAX33m0Zzwf1+P+U4LIpi6KT+5uLdVY1Mo9TaRb1fXK9VFMXEl1W3Wbc/U1b167/+6723v/fee/HvZtkMvJwwd0p40YUwN3IMl2UZ00bIT+HN8GG9vceqP9fu3/P7/b71/h8/SmaZtWZIc2qvpqH2vfMRhSA05RSj1TzLD/5y8EwmjljPu/5w18iT2Lw9vJNe1c8p9TC91vL19GFu240jz05rbsSRhx4/73O8q0N3dUdlxh9lYlcnjs+Nl12OdPKq3zemtxwx3tXxep6h/gztw4k7GWYx8eeyKWuYePC/9Mj60FLT50653wuNrLeMlIP3PsRQf27eMxefsonZo3fbW726OEjfXGrG8wxf1Kspe4fUFEXRO5o4ZabbcfFbbF3XU+Z9j8IX2Rf9wr0F+/1+aB82n47x97XmsPrbb789/dFHxiHGx7NHHmV8bGNkRvmm8RnW49+9kyiP3DvknlmER2b2zT66vRf789Zbbw2NqWcf/UmkWbkOL6Gqqnhsj7xNjYuvrIvDmeEzbugz6DGjoVdN/ZS4+PSFeeVHWg6li6Asy6uCwQ3GP92G5u8PvQpbFw+PZ7oajLB+uwWPg6qqdrtd85/hrfP+sB5XGP6oX8smXLPpcDiEC0/c9qDPpPVEXHzTL1+buM6RT8rmO92777578ZpHEx/x5uKTicfDxEw/Xm8z3snxnoxf+2mKZprJLm3R/Tngy1/+cvjjrbfe+uIXv3jn2mBEXdexrmA8KNd1vdvtLja7aEoovP9FNJRcXzqPvoTw/jPlCXpQh65UluXNQ37xvTeMM06vgcnWE+iF9Zld/No6i6Gy9bnCenMNzZXE7D70XhZeKnc+6BNoXbt0ln0y8fOj2aw5xD5F691tYua+NkBf26zpYhX4kItv3NM7M/EbbHclrUuWjvcny7KiKOLI+nvvvddM5M3NWWOwYF3C2ND0t7LT6TT+UXjx9R6jW+96wjF//wfcnZ2cxbyPcvHdYMqen34W0EsYelLCe+bQO2f3p5iL77Ere+dcug5n3br78wHzrPc+9MiNL1RbP5R+7lztc7iqNHmiiSsceKFP0io9H5ll5f333x9aanzBpolTL4/PQhDvGp96ZXql5lCfe2fsGdF9xIm7JWoWtzQnUJ84qyPM4qrLHp2nTcB3zwWAppdfny/VrPdu1CML1oPpmzO0T87TLth51aOMXCbinqL5i4/bu/Lpk8lMf/qm75AUiFZ36f3wvmrxluZxMx7WWw8dbmzeEo/4lzsR9s7Nf2Kz7+pmNcvQxOrdh75WK3Z3j6WoWTA93oeRrt6Q6Ucea3z+9ZH1t9YzfgJTr+L1JQgmdnVKf87Dofza9cA94sG/H9Vt33rrG4rIzZjVvH0oX468TrsuhvWhB33keYfT5xAc71vcqGv3fOuhh57BodunmBLWh46Eodtbmm+MU56+db2Frqajaeo9E2LisuNZ/GKDi/Opx5ffxbB+7DPLJmzW7DtkYu5sDni/++67dz5o91iKxnN2vGvie+t4s5HHGh87nz6S3VxPd2O7B/l+4Opgs+yW3kXiVOvTr2wKs+ge/72ar4jm7WEcaqjleTSKNVcSvhJMfEV3V95740gnr99PtwvbNT1fDrVsbdfFjZqy57vrue234om/zzQfKA5iTnxSmi0vZpirJuFJwWo6mqbetDrxk/hi0B+Pwt1o3lrh+Hqah/I9A+Q3L/jERoZtbjbxDevaSRtHPKD4pHn0Tmk28oN4726Z/iyMFOSM54zpjzj+feDiCmNY91rjwbJpWgNAQz9GdV9B4+OmveuZPrI7HtaHtm76zpnF9OA4sqNaq2oZr5wZf7+6bc+3TC+m6o1GUz5Jh35AGHmUFU057QTTuwydSD7lNNPuFG9XVcQOnWN6g5snY3Iuaa8bzpu8aGQ6lBfyTGeXXlz/UGda51KfJweX8a7ecFSEM01N18jjTT/sozB9XvNU7JEJr8rG1Xa6muuZMmvWlJU3bzyfz/esfxbxES8mh4vPRdi05hZlnYkiWo0nrufOPTN+YaNuyzhZxfSHHj+QWtY32fRCXxKex9CcoONL9Uau1pe8i0UmI7mt+TV0ShnM+Bqu2oqLSz29q36Mm6JZsD4+EtAMc1PKYEae7pHndPazS0eaPWCAf2Q903+BPV86X/aqVUVvvfVWc6n4dxxoB55AeL96ZKH8lq1xb7+RcZ+hb2Z5nvcO+9V1Ha/VPHFVQ+aac2ro94HxlfSOx0+8CNlzmz639w0rvHimY+9SvZp9G//iN9Kf7uWQJv4IMHFQfGT68/Gx6ttGslstb7gu2NAj3j9N2FVPLrAi4R3D6/oxxmeBTJOwPoOh6q7dbpfneVmW4TedsizzPG9ezGjKSkbMFdazgZB9Op1i/+PPYXFDZvm+wRTN3Dl0/ATN6Hw6nUauiLTf75vPYKsoazzpTvxEGT8IJ2b6my+9NL1Ga5aypTzPJ7a8qpCp2TjOud48xxR4DuFT2GfoA5xOp6IoHl/vdJelh/afxJ0jyuMnf4w8X1Oe1otlMOOrmm5F52q8nOaRMNevbCMHQFcrC/aeZtqslultM17RMbKBjzy7dK6pV0YKcpp7aWhzuq/9O2tymnoL06cvDqxIeE9buhdPbqU72Qmm8wjfhrvnjE5RzHSFyzudz+fpo4Nd+/3ekED2MmeXRlMGZUOdVfznF77whebsV61rvGVZ9v7773dLWUa2ojla/9Jnlz5ggD8bHYMviiI+ym632+/34VSnsEj9+rrW3Y61ThSb8ahwXik8q/DuPf1cTG5wOp1WWa+79LeFp3JDKcvIsOKUkfXe9DZ0QYGmoeG92yYbMaYeTdnJV5l+dmnUPAF03ND0js02rbvGZ4ec9+zSmwf4xxecvp7z5F+celvGldx2dmm3A84rBdggNetzCjMHTfzSFpLBnV+gexe/Z511XV/1lWOWrXhWDz67NHr77bcv5vUwV0x3TL2lezDPcnbpxN+gRgakH3B2aXDx5RC+QWWdTe49H/TOmTedfwawQfl5jmJlusK5mFnn87UoinCO5iK9uko4r7SbD8KZGYvMR8tVPvjggy996UutuF8UxW31WlvWfS30vpCbUyQdj8dZXiCxqOmdd9750pe+dP8KAVgXYR0gUUVRxElgvFcDbJMyGIAUvffee6ZrBMDIOkCKmrP6eKMG2Cwj6wDJaZ6KarpGgC0T1gGS8N5774X/N0vV33nnnS9+8YuL9guAJSmDAVjeu+++++Uvf7l7u7dogI0T1gGW13v9YO/PACiDAUjOO++8I6kDkBlZB0hEqFnPskyROgCRsA4AAIlSBgMAAIkS1gEAIFHCOgAAJEpYBwCARL1augOr0TsLMgBA4pqziXzve59esCfRm29+uMY5Tuq6ruu6LMuyLB/2oI+eDaau691ut9/vq6p65OPeL8/NnAMArEwrwAjrE1VVdTgcmpG1NW77sP6/yMj6SBA/HA4v8YgAAKTgzTc/XLoL9wpJvXlLHEoviuJ0OoVb6rp+QGdmHi0OA+cXmx2Px0f+fDALI+sAwOoYWb9BGETvDqvHBNv654ua+QTTmNSLoiiKIvy93++b/1xjUgcAYAvCeHlRFDGpxxH0mGD3+33z9hc1ZxlM7HH8qhS+dsRNDb8phML8GR8XAABmEQJtM6zG+L5If+YcWQ9bEr5qBK2tqqqqKApl6wAArEXIrktNjvKy86yHLyXN3wi6twAAQCJCWO0OLnfH2h9j/rA+Hs2FdQAAkhVDeVmWVVWFou5mtUhZlmFCmMeMtc8Z1sO2hd43NaO5mA4AQMqOx2OWZafTKY6vxwSb53nIug8rYZ8/rGdZlud5+KoR43vYwrquwzY7wRQAgDSVZXk8HkMcL4oiZPem/X7/sAHo+ecOj5d3CmvuziqfPfCaTzMyzzoAsDrmWV+7+WvWz+fz8XiMc8KEGWBaDWZ/UAAAmEVVVRcHzqe0mcXjRovXPr26kXUAYHWMrN8gz/OiKEayeF3Xu92ueYnTlzPnRZGyLKuqqizL3lAeb6yqaqmJKgEAeFFvvvnh0l24RYzm3T+6HhllZx4tTuqLyLyMrAMAq2NkfaI4IeN0x+PxAWUjM4ysd6N5Il9EAABgiqvCelEUQ7Uks5thtDjZLyLzMrIOAKyOkfUbXCwVeaSZa9an2O/3q0vqAABsRFJh9dE16+sV548fl/LXRABga4ysr93MI+uhgmfedabDUQUAsB3jA9CrqVnfCDXrAMDqGFm/zZSSisdswvxXMA3CJZDKsoybah4YAADSN7H4+THmD+t1Xed5vtvtTqdTc5aYw+GQ57nIDgBAsmLpy/F4PI96TH9mDuvhmkfh7/1+XxRFvCv8fTgc5HUAANIUwno6E8LMHNZDUt/v9+fzuaqq5kbWdb3f77MsOxwO8z4oAAA8pTnDevzVYGjsvKqqML7+lHM7AgCwdmGsOZ2wOn9YD8PnQ1LbfgAAiMqyLIqieeLlsl5qNhgAADbozTc/vPjf0n28IAwrJzIzypxhPYyaj5ekh41PpGA/y7K6rkNtfVmWKTwfAACr9gd/8KmL/y3dxwtiUg2TGQ55TGdmvtBP6Pd+vw/Bt6qqw+EQHyL8M0vmUqC9ezl2vts4kW4DAEzkokg3mBjEH7MJMwfQ1tSNdV2fTqfWJDDH4zGFkfX4NMSpeaqqCvVJvT0U1gGA1WkFmO//k399wc5EH//R3005Vk08u/IxgXb+ANrM611D49YPNjTGX5ZlyOvd3SKsAwCrI6yv3fwnmJZleT6fu1dEipOvz/6INwhfmJo9DBLpHgAAZFn26oXWu4rUm0I1DgAAaaqqKhR1Z6/LLsKUJI/MkC8V1hM3VIpkAngAAGLJdMvpdNrtdkVRPCw0mmf9j4Q5HMOzMn5dJwAAnljMhEVRHI/HZuF0SImn0+lhg+tOmmx/cxqarMYJpgDA6jjB9Abjc5HHyVQeswlG1ttGprIZmRX/Ko/cHAAApovTkAydgVmWZRhrf8wpmsJ6VlXV+Xw+n8/xZ46hPH2eyWO3DwCAqUJYH69yeeQJpsL6HyvLMp4rsIrZbAAAeAnpTDoirLeFwfV0niEAAB4mjJqH6RqHhNMdHzO+vtGwfrF23BTsAAAbFEPgUBq82GBeG51nPajruruXx79IAQDw3M7nc57np9Mpz/OiKEI4bF4gKcuy4/H4mM5sdDrCsiybF6OK4jSO3d1i6kYAYHUeP3Xjx3/0d6c0SzxWhSvwDI3hDs30/RK2G0BjGUy8BFKcbT1Oq9lqv9l9BQCslHnW71G/Fv5ZvvbIPmw3gMYJ7Vt6k3omrAMAKySsr93WA2j329JQS2EdAFgdYf0GZVlWVZXIdCMC6FTCOgCwOsL6DZrF0otfe2ejUzcCAECvcNWdLMsOh0Oe583rZj6esA4AAH+sruvz+bzf70NqP51Ou91uqdSutGMqZTAAwOoog7lfnNo7emR5jAA6lbAOAKyOsD6jVmp/zCYogwEAgMuqqorX53mYVw9+PAAAWJEw03erEiaehPrShHUAAGgbyugPnoJdWAcAgD/WPaO0KIpwpaTHd8ZJk1M5wRQAWB0nmN4gXhQpS+C6SEbWr9B85oakfOQBADDF4hk9EtavIIgDADy9pCKfqRsBAOAKVVW5KFJy1KwDAKvTCjA/+Lt/bsHORK8+//V0YlVd17vdLusMqNd1HSZ+6ebyUBr9mE1QBgMAAD1Op9PSXVAGAwAAqTKyDgDAbF59/utLd+GpCOsAAMzmD7/2kxfbCPTTKYMBAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJTZYAAAICvLsvnPcEWk0+nUuv3BhHUAABi8Xumy1zEV1gEA2K6yLIuiWLoXg4R1AAA2ra7rpbswyAmmAACQKGEdAAASpQzmCnmeX2xzPp8f0BMAALZAWL+CIA4AwCMpgwEAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEvVq6Q4AAPA8Xn3+60t34akI6wAAzOYPv/aTF9sI9NMJ6wAAW/Hd73x66S5wHTXrAACQKGEdAAASpQwGYCuqqgp/lGVZluVIy7qu67qe2DiudkrjOx/uqo5d1XiNwtZdu123LQUsJT+fz0v3YR3yPJ/SzP4EElSW5el0at243++bOTuoqupwOLRuLIoipt6Lqx1q3Gv6w9V1vdvtums4Ho/d3HlV4/UKH0zXfu7cthTrlecfCXv/7Dd/ZsHORJ/8md90EE6kDOYK5wmW7iNAW57nIVLv9/vj8Xg8Hvf7fZZlh8OhlVxjdD4ej+E97Xg8FkVxOp26AxZDqz2dThMDcVmW4eHiGo7HY1hD6+Fi+A4tQ8fCw+12u1ayr6qq2TgoiiI0nrjTiKqqyvN8+hcwYF5G1qdqfTEFWIUw+N07Vh0CcXOweWjMNayk2TLE+pHV9g7bN8X8PfRwzZV3O9BcSbNlXG238UifV+oxI+thvz3ZjxKbYmR97YysAzyzMPjdG0/DyHQz5mZZFkagW0Lsbq4kjIj3rjaMjl8MxDFSd+8KyzYLbMLf3bAYbmm2DF3d7/fdxuGubt3OdBc3qlklP37jvA0umtjzax/ltqWAqzjBFOBpxeQ6cm8r1PZm2bIsW8Pq2UCsD42HHjFqDpn3NuhdQ13X3fbn87kZFkP/hwb1j8fjVckyDipXVdXcM829EUb9z+dzGLHu/iAQl+oO6l9s0Krpv+FngdZDdL8ddev7m48S65FaP4N0T1cw9A4vRGnHVMpggNXpFrpMaV8URVVVI4sMFaVMFzLoxVKZ1iNml6prulUxd2pm5fhDROhJ3PxYtBP+H3dd3Jnhn2E93RzcatDcwOZWNx86fhhdLGiJUTuepRDvCks1TwYoy7Ku61Y3qqoKjxv6Gb/gxVuaS/mUTJMymLUTQKcS1oHVubY6uTXIGtNYK5TfH9bDGqaH9awzJVcIl71V6VetdlzzjNv4WK2vBDFSN/dzb3186+nI83ykQe8Xj9aeH39+R/oQl+qtR2+tttum+7jq2lMmrK+dmnUA/khZlufzeb/fhxKX0+l0OBx2u11rMpChCvIbHm564zg1Tfhn7NhcuXxEHPwOuoXyWae8pLemP7TpngAQNWcViwPbzQZhqYmbHPrQatzqZ6vAaaIwIc9ViwA3U7MOwEfEeBfOHQyZb7fbxRHrUPLRW0E+sragORw+cQ3NZUNajec1hq8TrXMcZz/fsdvJ/X4fHrdZud5dsNWT2PmskfjzPO/9lSB+GehuzlXnyHZ/FRn65/SzRZvPYPh/d7J8YC5G1gGe3Ej8ulibXlVVGGvPPlrxPC6stpnkorjmi32OaxjqWF3XcV72ZgK+uNq5BuMv5trdR4XNj1H7fD6HHwrirwTd/u86Zul5U5hGPc/z2MOLwm4Mi0xfCriNsA7wtFqTM3YdDoeYHUP86m3WHR3v3thdbWhW13XzynHxpMxsNP3vdrvYsZAmex+ufD3zTGu4emi1rUld7nTxu8HFy+eFndO8nlTrKXjpC/CVjetShTVf/AYSiunDKQfx4lkX5/8BbiasAzytEHCHMnHvDIxTqiDGJyy/oY5ivFkM/RdXm73enKEvErdV23cfeuJAfu+q4triH/EXjND5enjC+9YabtBaNp4aO/3XhrCGMJ2l00nhAYR1gGcWMl9vqGqdgBj+6C206KbDMJLaOxIfpwIc71ioYNntdt2Vh97GtBrHy3tDatiKuIHx+8nIaluF2uP9zPuzzsEAACAASURBVDpfS+rXUyiOCJvf/UUi7t6qqna7Xe9PFrFB1nniwlIjfW7eFfrQXUNrkWu/rY08C8BLENYBnln9+mqgoZIkjMuGwpLso8m1LMuQ21otY8RsTiQSM1+otO6u9uJIbXy43W4Xa9DDGrpXXY3JPrYc2YoQUqesNmTfKcPDcZ+ERbKBa6+29s/hcIi9LV/P8NgsImo2iNNENn9PCNVErQZD+7a1OfEHkLiGsnMlo9Cg+YVtqCy++TtA9nr+9eyjZwnfM+QPDBqqh6PFvgLWq7emIpYpNw2NiMfq5IuNe1c7pHcNRVF0Ww6F496H623cXW149N6HazbodrL5oGHf9i4+3oHeTrb2c/eJazYIt4xvTrfnzQ53+9CcH7PbprdXRVHENiM7k6W0js/v/B//dgr/Db1q6HKhn6lcFAlYu1ju3J0ocKjlVY0vtlywY9lALVAc2O5dQ/NaP3Fw+qptvLhp9zeY2IeRxbsN4lh+bNOa9z32qnXLzZ3k5bgo0toJoFMJ6wDPp/faQ817XZiTtRPW185FkQDYqJDFJQYgZU4wBWCjwoSJS/cCYIywDgD94pQ1AEtRhz3V0IX9WuxPACAdatbXTs36FRxVAAA8kjIYAABIlLAOAACJEtYBACBRwjoAACRKWAcAgESZDQYAYCt+/3ufWboLXMfIOgAAJEpYBwCARK2+DKZ+Lcuy8rWJC1ZV1XtXWZZDdwEAMOLHdn9r6S48lXzVV+Usy/J0OrVuLIoiZPdxVVUdDoehe7u7pXW1XgCA9LUCzDfqf2/BzkQ/tvtbYtVEKx5Zj0m9KIowEF7X9eFwOJ1OZVlezOuhQVEU3ZH4iWPzAADwotY6WlzX9W63y7LseDw2s/XQ7V15nk9p1my/0n0FAGyWkfW1W+sJpnHgvBW1y7IsiiLLsolF5wbRAQBI1rrDesjlLfI3AADPYa0161VV1XXdm8unnF3abBNWlZkEBgCAxDxbHfbEmvWRqWD2+31vZFezDgCsjpr1tVtrGUyvmNR753gZst/vj8fjfr8P/zwcDsbXAQBIwfOMFjfnXL+4UaFxd0b2uJLeedbn6urT7HMAIHFG1tfuGUbWq6rK8zyE7P1+P+W5r+v6fD53q9vjLb2D6+eZ3Le5AABsxVpPMI3igPfEC5deVBRF96qoAADweOseWY9J/Xg8zpLUo3nXBgAAN1jxyHpI6rcNqMe5GocamKwdAIDFrXVkPdaU3zYEvtvtdrtd77KhBkZYBwBgcWudDSYMq+/3+6FU3bw9XkEpRvyhWV/GZ4NZ6b4CADbLbDBrt9YAenEixWZ5TG8Ej2tozrAe/ui9oJKwDgCsjrC+diuuWb/T8XgMV1BqXcp0/NKnAADwMFsfLa7rujkAPxLTjawDAKtjZH3tBNCphHUAYHWE9bVb62wwAADw9IR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEvVq6Q6sSZ7nF9uY4R8ASNY3v//ppbvAdYT1KwjiAAA8kjIYAABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABI1KulO7AmeZ5fbHM+nx/QEwAAtkBYv4IgDgDAIymDAQCARAnrAACQKGEdAAASJawDAECihHUAAFagLMuqqkYa1HVdVVVZlhdbrojZYAAASF1d16fTaaRBVVWHwyH+83Q6HQ6H4/FYluWLd+4lGVkHACB1u91u5N6Y1IuiOB6P+/1+ylKrIKwDAJCoUNly8cKUIanv9/u6rkMNTLw8ztrrYYR1AABSVFXVbrdrFrcMNWv9EYTx9YuLJ07NOgAAKWqWm4/UrNd1nWVZURSt21tV7CslrAMAbMU33vjk0l24QpjXJfxdVdVQWA+3j5xIGmpjZu/eYyiDAQDgmYWh95US1gEAWL3esfNubczqKIMBAGCSn/viryzdhc0R1gEAmORvvveXZlmP0D+dMhgAAFavtzB9/KKnqyCsAwDwzNY7FUwmrAMAsGrhLNJVT/kyQli/Qj7B0n0EANiWcOHSbsVLvKCpkfWtOE+wdB8BALYlZvFWKA+XL93v9w/v0ZyEdQAA1u14PGZZdjqdyrKs67qqqljvEMfXV0pYBwBg3cqyDCPop9Npt9uFMfUsy56g6iF/gm14jDy3rwCAlWkFmP/5/b/80o84cQ71F4pVzTr1VZeqRwLoVMI6ALA6jw/rU/zcF39FrJpIGQwAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACTq1dIdAADgefzcF39l6S48FWEdAIDZ/M33/tLFNgL9dMpgAAAgUcI6AAAkShnMFfI8v9jmfD4/oCcAAGyBsH4FQRwAgEdSBgMAAIkS1gEAIFHKYAAAtuIbb3xy6S5wHSPrAACQKGEdAAASJawDAECi1KwDADCbX3z7K0t34akI6wAAzOavf/BLF9sI9NMpgwEAgERtfWS9fi3LsvK1hfsEAABZlm08rJdleTqd4j9Pp9PhcCiKImR3AABY1nbLYGJSL4rieDwej8f9fp9l2el0MrgOAEAKNjqyXtd1SOrH4zFG81ADs9vtTqdTXdciOwAAy9royHosdGkl8rIsi6LIsqyqqkf3CQAAPmrTYT3k8hYD6gAAJGKjZTBVVQ0Vuji7FACARGw0rA9N0Rhr2ZXBAACwuI2G9V51Xe92uyzLiqLojfJ5ns/yQOfzeZb1AADw3IT1P9Kcc32oEkbIBgDgkYT1rKqqw+EQ/t7v9wpgAABu9otvf2XpLjyVrYf1WNniwqUAAPf76x/80sU2Av10G526MYhJ/Xg8SuoAAKRmuyPrIakbUAcAIFkbHVmPhemSOgAAydroyHo4o3S/3w+FddcxBQBgcfk2pyO8OGN6tzwmzze6rwCA9WoFmP/y+MsLdib6xbe/IlZNtNEyGAAASN9Gy2B8mQMAIH1G1gEAIFHCOgAAJEpYBwCARAnrAACQKGEdAAAStdHZYAAANuh3zp9eugtcx8g6AAAkSlgHAIBEKYMBAGA2f/UL1dJdeCrC+hXyPL/YxrVRAYAt+yvvVxfbCPTTCetXEMQBAHgkNesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJCoV0t3YE3yPL/Y5nw+P6AnAABp+qtfqJbuwlMR1q8giAMAjPsr71cX2wj00ymDAQCARAnrAACQKGEdAAASJawDAECihHUAAEiUsA4AAIkydSMAwFb8zg8+u3QXuI6RdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiXq1dAfWJM/zi23O5/MDegIAwBYI61cQxAEAeCRlMAAAkChhHQAAEiWsAwBAooR1AABIlBNMAQCYzf/47/6nS3fhqQjrAADM5t//3/7zi20E+umUwQAAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUa+W7sCa5Hl+sc35fH5ATwAAbvAPf/Anl+4C1xHWryCIAwDwSMpgAAAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiXqeiyKVZVmWZVVVE9vXdT3U+Kr1AADAC3mSsF7X9el0mmuR0+kkrAMAsLgnCeu73e7aReq6zrKsKIqyLFt3dW8BAIDHW3dYr+u6ruvD4XDDsmFYvaoq0RwAgDStOKxXVXVbTG+S1AEASNaKw3ozZ99Qsw4AAIlbd1iPeb2qqqvCeihYj8uGf5oEBgCApKw4rN8jhvU8z+ONp9PpcDjs93uRHQCAFLgoUrbf74/H436/D/88HA7COgAAKdhoWI/zNp7P5zAhTFVV5/O5KIosy4bOW81n8sgtBQBgvbYb1s/nc7NyPd4e/ugdXD/P5GW3DQCAZ7HRsD4iDK4DAMDihPV+3UF3AAB4sE3PBjNyRSQXSwIAuMHf+ws/v3QXnspGw/put8uy7Hg8dkN5mK9dWAcAuMG/+b/8dxfbCPTTbaIMJs73Em8JhekhsjfFjC6sAwCwuE2MrNd1fTqdTqdTzOt1XYcpFPM8b86wHv44Ho9LdBMAAD5iE2G91/F4DCPrrVnVe2tjAADg8fKNT/td13Wc+KUsy5GYnudb31cAwOq0Asy/9b/+9wt2Jvp7f+HnxaqJtjuyHowHdAAAWNDWwzoAwHZ867ufWboLXGcTs8EAAMAaCesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUeZZv0Ke5xfbuBwXAABzEdavIIgDAPBIymAAACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRr5buwJrkeX6xzfl8fkBPAADYAmH9CoI4AACPpAwGAAASJawDAECilMEAAGzFt7776aW7wHWMrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYf0K+QRL9xEA4DmVZVlV1dK9eLRXS3dgTc7n89JdAADYorquT6fT0r1YgJF1AABSt9vtlu7CMoR1AAASVdd1VVVbrjRWBgMAQIqqqjocDkv3YmHCOgAAKSrLMv692Zp1YR0AgBSVZRnzelVV2wzratYBACBRRtYBAJjk//2P3lq6C5sjrAMAMMm/8D/8+izrEfqnUwYDAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkCizwQAAbMX3/79/fukucB0j6wAAkCgj6wAAzOa7v/DTS3fhqeTn83npPqxDnttXAMDKtALMP/ff/J8Ldib67i/8tFg1kZH1K+R5frGNIw8AgLkI61cQxAEAeCQnmAIAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAo86wDADCb7/7CTy/dhacirAMAMJtP/OrfvthGoJ9OGUyPsiyrqlq6FwAAbJ2R9ba6rk+n09K9AAAAI+sdu91u6S4AAECWCetRXddVVeV5vnRHAADgjyiDybIsq6rqcDgs3QsAAPgIYT3Lsqwsy/i3mnUAABIhrGdZlpVlGfN6VVXCOgAAKVCzDgAAiTKyfoW5Tj89n8+zrAcAgOcmrF9ByAYA4JGEdQAAZvPdX/jppbvwVIR1AABm84lf/dsX2wj00znBFAAAEiWsAwBAooR1AABIlLAOAACJcoIpAMBWfPzbSWS/7y7dgRUxsg4AAInKXehnojy3rwCAlWkFmE9/5WsLdib68Jd/SqyayMg6AAAkSlgHAIBECesAAJAoYR0AABKVxPQ9AAA8hw9/+aeW7sJTEdYBAJjNp/7a37nYRqCfThkMAAAkSlgHAIBECesAAJAoNetXyPP8YhuX4wIAYC7C+hUEcQAAHkkZDAAAJEpYBwCARAnrAACQKGEdAAASJawDAECihHUAAEiUsA4AAIkS1gEAIFHCOgAAJEpYBwCARL1augMAADyPD3/5p5buwlMR1gEAmM2n/trfudhGoJ9OGQwAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAoswGc4U8zy+2OZ/PD+gJAMANPvbhx5buAtcR1q8giAMA8EjKYAAAIFHCOgAAJEpYBwCARAnrAACQKGEdAAASJawDAECihHUAAEiUsA4AAIkS1gEAIFHCOgAAJEpYBwCARL1augMAADyP369+cukuPBVhHQCA2Xyu+vrFNgL9dMpgAAAgUcI6AAAkSlgHAIBECesAAJAoJ5heIc/zi23O5/MDegIAwBYI61cQxAEAeCRlMAAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEvVq6Q4AAPAgP/z2jyzdBa5jZB0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkytSNAADM5ptf+Ymlu/BUhPUr5Hl+sc35fH5ATwAA0vTZX/q/LrYR6KcT1q8giAMA8Ehq1gEAIFHCOgAAJEpYBwCARAnrAACQKGEdAAASJawDAECihHUAAEiUsA4AAIla/UWR6teyLCvLsqqq6QsONb5qPQAA8ELyVV+Vs6qqw+HQuvF4PJZleduyUXe35Pm69xUAsEGtAPMnf/m3FuxM9M2v/IRYNdGKR9brug5puyiKqqriP3e73ZSnPwzGF0XRTfZTsj4AALy0FY8W53meZVlRFCF2j9w4svjEYfjMyDoAsEJG1tdurSeYxizeCuXH4zHLstPpNHE9BtEBAEjW6sN6SwzfF0fWAQAgcesO6/v9frzBlHurqirL0gwwAACkZq0nmI4UuhRFcbEMJob1ULke13k4HPb7vdQOAEAK1jqyftH0Mpj9fn88HuMg/eFwENYBAEjBusP6zaeHxnkbz+dzKIOpqup8PhdFkWXZ0Pzr+Uxu3FoAADZm3WH95rNI67o+n8/dxeMtvYPr55nc1mcAALZm3WH9JYTBdQAAWNxaw/pIpA5nl945gbqZHwEAWNxaZ4MpyzJM3jJ0Muh4WA9ZfKSNiyUBAM/n/OGPLN0FrrPWkfWhMB1HxMfT9m632+12vcPnswzMAwDA/VYf1luperfbZZ0imTjfS7wlNAiNp6wWAAAeL1/v5CR1XcdoXlVVXddxysXWRoWamdbtcQrF5gzr4Y/j8dgN63m+4n0FAGxTK8B89j/57QU7E33rV/+sWDXRugNozOtN3ajdG9Z7l+1dPBDWAYDVEdbX7hkCaKxvKcvy2vKVuq6bZe4jiwvrAMDqCOtrJ4BOJawDAKsjrK/dWk8wBQCApyesAwBAooR1AABIlLAOAACJEtYBACBRr5buANzuU7/2G90b//K/9MH0NfzODz7bvfE/fuPv9zY+5X+qe2Nx/se9jX/2C//19G4AAPQS1gEAmM23fvXPLt2FpyKsAwAwm8/8wj+82Eagn05Yv0Ke5xfbmOEfAIC5COtXEMQBAHgks8EAAECijKyzYv/Zv/w/dW/883/4T6ev4bMf+3b3xq/9oGfWlyzL/kze0/iU9Tf+2emdAAAYYGQdAAASJawDAECihHUAAEiUsA4AAIkS1gEAIFFmg2HFfjb/rZ5bP9bf+Jvf/3T3xt6JX/70D7/Tu4ZvvPHJ7o29U8QAAMzCyDoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlKkbWYFP/dpv9N7+9/+Vnhs/9/Fv9Tbunbqx12c/1j8b4+/88Me7N/78D/qmjwSAJH38m2YcXhkj6wAAkChhHQAAEqUM5gp5nl9scz6fH9ATAAC2QFi/giAOAMAjKYMBAIBEGVlnBX7jc/9V7+29E7/8/vc+09v4G298snvj53/kH0/vRu/EL//7q74pabLs89PXCwAwwMg6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKLMBsMKfPZj3+69vXfil94pYrIsezvruf23/9mPTe/G0MQvAAAvxMg6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKLMBsMK/Ks//nd7b3/j9z49fSXf/U5P46F5Znr9+e/33PiNNz45fQ0AAFcxsg4AAIkS1gEAIFHCOgAAJEpYBwCARDnB9Ap5nl9scz6fH9ATAAC2QFi/giD+AP/BV/+L7o2/9uce2oev/eBP9d7+9p/4evfGz37vMy/cHQBgu5TBAABAooR1AABIlLAOAACJEtYBACBRwjoAACTKbDCk5b/9E3+je+P5cx/2Nv7hNWv+RN+Nn/tOz42f/94Vq/3m9z/de/ufvmIdAPAgn/m93166C1mWZf/P0h1YESPrAACQKGEdAAASJawDAECWZVld11OuWP9IwjoAAGRZlu12u6W70CasAwCwaWFAPbUx9UBYBwBg08qy3O/3+/1+6Y70MHUjafnEJ7/dvfEH16zhjd/rn0ux18f/zDe6N37ud/ob//73PtO98bMf6+kwALAuVVVlWVbX9el0WrovH2FkHQCAFSjLMkTqIXVdV1VVluXFlitiZB0AgNRdHPOuqupwOMR/nk6nw+FwPB7Lsnzxzr0kI+sAAKRufJ6WmNSLojgej7H6PC6VD3vpnt9JWAcAIFGhsuVipA5Jfb/f13UdamDO53O4K9TDnIe98BbcS1i/wsh3srV8OQMAWIuqqna7XbO4ZahZ648gjK9fXDxxatavkP53ryfwg5/4R9Mbnz/3YffGHw407p0lpvfG3hlpsiz73Hemdw0AuFez3HykZr2u6yzLiqJo3d6qYl8pYZ275HnuO0wve6aX3TLEnullt/SyW4bYMw/wD37jLz7y4cK8LuHvqqqGwnq4feRE0lAbM3v3HkNYBwBgkn/j3/m1Wdbz4NA/PayHQfqkqFkHAGD1euN4tzZmdYR1AABIlLAOAACJUrPOs+md4AUAeG69henjFz1dBSPrAAA8s/VOBZMJ6wAArFo4izTBiVxmsfWwHq5hG2bxbF31CgCA9IUI1614idFu1SPrm65Zb13X6nQ6HQ6H4/E47zN62zUabr6yw+MXvM3ND/fmmx/+wR986oYFX33+63/4tZ98zFL3cMDM+3Br2Z+3Wcvz/vhL1azleX/uA8ZumXfBFV3y6cFzqGeNLF6WZXN8PcS8/X7/4P7Ma7thva7r8BQWRVFVVfznbrdby4sBACA1Uy6cNHugPx6Pu93udDqFWomY67LG+PpKbTes73a7LMuKogjfwMJTm+d51vlaxrr84Cf+0dBdP/wXvz1lDUPzyXzikz2Lf/c7Jp8BgIWVZbnf7w+Hw+l0ChkveIIR2NX8pDKvuq7DE9na/KHbs/X82rX2fn7vexey781lMG+++eH3/u9/bUrLZli/WAYzFNY/+TO/ueon4oUW1M95F9TPeRfUz3kX1M95F5zr4X78rb9xw0pm9w9+4y++UARt1qmvulQ92ujI+tDAeXxSe6fqBAAgZWsveuna6GwwIayPnHCgDAYAgMVtNKyPXM4qTNUJAACL22hYv8jIOgAAi9tozXpwbVV6mCvmBrct+OCHu3nBx/fzzTc/vG3Bj//o705r+JFmrz7/9dse7umfCP1MYUH9nHdB/Zx3Qf2cd8GbH67pt379P7x/JffL80fPxb5emw7rV51Fus1pcwAAZidWTacMBgAAErXRsD5yFmk499S8jQAALG6jYT1k8Xgd2qEGAACwoE2H9a44CYywDgDA4rYe1luhfLfbZaZaBwAgDRsN61mWHY/HLMtOp1NZlnVdV1UVZ0QyyToAACnItzx1Tl3XYSi96Xg8Nofb69eyLCvLsqqqx/VvUTdvePjm03vXpnZgUJbl1rb62k3e+AHTeqEFC/fpIW7e8C0fMJv9PMp8JN2tqqqwKzbyDvNszpu3f+14PHbv6u6xbrPnc8+G9y67zeMt/HpTFMXSHXmcGzZ5ywdMb8XdFg6YezZ8swdM7/bu9/ul+/UI92z7Zg+YpvDOvJ0D5vls+qJIwdAX67quw3QxRVGEr6Thn7vd7vzUP0fcueFh5KMoiu7X9619oe/+bvP0btjkzR4wZVmGiWLDCy17/dKLtXnLdu/l3Lnh2zxgYpXmfr8Pm1lV1el0OhwOT/9rzJ3bvs0DpmWDH0bPZulvC+kK+6c12NN745O5c8NDyy38/jDkeDw2x3Ke+2gJ7tnkbR4wcaCrteFDtz+N+zf8ufdPr/jiat0ef6BYpFePcf+2b/CAaWn+kGVkfaWe+UV+j/jJMfH2p3H/hj/3/rmo+5Pr04f1Ozd5mwfMUAQ5v/5kfdbD5v4N3+ABM7Rnnv7z6DzHtj/9LhoXd5SwvmrKYPoN/RQbfzWr6/opf0Hb7IbPpXV2cvi5/7ltcJPvF3+a794Vq0Se0mY3/H5bfuPd8rbfKRTAnM/nWE3EGgnr/cInysiJKc+aWe/c8GbWD/Xu2cbOuG/WUIbCykW78wj3bPJmD5iwsb0vpSeuVs/u3vBtHjBDe+a5D5Xgzm3f5gEThRfa+Cm2rMPSQ/uJCjun9wejMCb0rL8l3bnhI28Kz7rHRoS98az1DL2u3WQHTMvT16wPmbjhDpigeZbIpjb8fOW2b/mAab0bb2Srn5WR9RttYUij1/QND2fux8lkwv83Mp7BDRww9esrP/TOXPHEbtvwbR4wVVWFLQ1aFwZ5bndu+6YOmLiZm80qz2bpbwuJCjund4znuU//unPDh9psYdaCLiPrFzlgomYZ99J9eairNtwB0x0qXrpHj3PDtm/2gOl+lIdbjKyv1BvXx/sN2exX0ps3vK7r8/ncXTze8qzDGNzGAZNlWVVVeZ6HWv/wUbp0jx7khg13wFRVFT68j8djSJzbOXHwhm3f5gETS9W386vL01MGw4MURbGFsy2Zy0YOmJg2iqLY1OjA7Bu+kQMmChUdYTdWVfWUoXPILNv+rAdMnJJr6BJj8Szbh3aL+wjr/UZexvFl8NAOPcpLb/im4gj3e+4DJgbWTVUeZy+54c99wHSFd+ytbXUwy7Y/8a7rvWrp4XAItezb+QXvOSiD6Rc+P5rnsvQ2eD53bnhd1+Pvfc+637jNlg+YEFhDNe0Tb2bXPRu+zQMmz/Pxeo+n3Orgzm3f5gFT9Gndu2D3uMVDK+TXwxVMJ97eEtr0np86ctezcoLpRZs9YEYu5Pnc7tzwk/UV0gAAAqxJREFUbR4wF7f6ic8avHPbt3nA9Hr6Q+W5be6jYrpwZLdiR++NT2b6hu/3+6Iomi/+oVPsn/7U+17CevdeB0wQPziPA5bu4Eu5asMdMMHQ1m3hK99V2+6AGSGsr9qGjtRrxbHkoiiaV2F4+pf39A3vfb+LjfevxVueOIL0EtZbHDBRdsmzHjZXbbgDJhrZ6qePX9O33QEzYiNHy7N68tx5pxhbm7bw8p644b3vjL3LbmS/tQjrLQ6YqHeTm571sLlqwx0w0dBWbyF7Td92B8yI7RwwTyk/OyP4kjgtVFmWT3kyypB7Nrx5Ws/W9hs3cMBwlW0eMNvc6uDObd/yruMJCOsAAJAoUzcCAECihHUAAEiUsA4AAIkS1gEAIFHCOgAAJEpYBwCARAnrAACQqFdLdwAAgCvEazx1ueTT83FRJACANcnzfLxBURQjgZ51EdYBANbkYlgPZLznoGYdAGB99vv9uc9+vw8NlMQ8B2EdAOB5VFVVFEWWZafTaem+MANhHQDgqRhTfybCOgAAJEpYBwB4KmEqmFAMw9oJ6wAAz6OqqlCtXlXV0n1hBqZuBABYkylTNx6PR5Xrz8HIOgAAJMrIOgDAmoSR9e5lSsM/d7td+KeM9xyMrAMArE+3yqUsy7IsY0ZXs/4chHUAgKcS5oFpjbuzUsI6AMBTcWrpMxHWAQAgUcI6AMATCrOts3bCOgAAJEpYBwB4KnEeGMXrT8A86wAAkCgj6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACTq/wflIrtHiKT4FwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "skip = 'data'\n",
    "skip = \"signal\"\n",
    "if category==1:\n",
    "\n",
    "    h2 = {}\n",
    "    for k in tree_keys:\n",
    "        if skip in k:\n",
    "            continue\n",
    "        can = rt.TCanvas('c','c', 1000, 800)\n",
    "        leg = rt.TLegend(0.5,0.65,0.65,0.88)\n",
    "        leg.SetTextSize(0.03)\n",
    "        leg.SetBorderSize(0)\n",
    "        leg.SetEntrySeparation(0.01)\n",
    "        \n",
    "        can.cd()\n",
    "        cut = sel_ev[k] & ( np.abs(dR_csc_csc[k])<1 ) & ( np.abs(dEta_csc_csc[k])<0.4 ) #& ( np.abs(dPhi_csc_csc[k])<1 )\n",
    "        x_val = np.abs( dR_csc_csc[k][cut] )\n",
    "        y_val = np.abs( dEta_csc_csc[k][cut] )\n",
    "        h2[k] = create_TH2D(np.vstack((x_val, y_val)).T,title=\"\",axis_title = ['R','eta','Events'], binning=[100,0,4,100,0,3.2])\n",
    "        leg.SetHeader('CSC-CSC, presel.'+k)\n",
    "        #h2[k].SetMaximum(100)\n",
    "        #if 'signal' in k:\n",
    "        #h2[k].Scale(1./h2[k].Integral())\n",
    "        h2[k].Draw(\"colz\")\n",
    "        \n",
    "        leg.Draw()\n",
    "        can.SetRightMargin(0.15)\n",
    "        # if setlog: \n",
    "        can.SetLogz()\n",
    "        can.Draw()\n",
    "        drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "        #can.Print(\"plots/V1p19_\"+vers+\"/ABCD_plane_\"+str(k)+plot_string+\".pdf\")\n",
    "        #can.Print(\"plots/V1p19_\"+vers+\"/ABCD_plane_\"+str(k)+plot_string+\".png\")\n",
    "        #can.Close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "6a4943b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:71: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "skip = 'data'\n",
    "#skip = \"signal\"\n",
    "if category==1:\n",
    "\n",
    "    h2 = {}\n",
    "    for k in tree_keys:\n",
    "        if skip in k:\n",
    "            continue\n",
    "        can = rt.TCanvas('c','c', 1000, 800)\n",
    "        leg = rt.TLegend(0.5,0.65,0.65,0.88)\n",
    "        leg.SetTextSize(0.03)\n",
    "        leg.SetBorderSize(0)\n",
    "        leg.SetEntrySeparation(0.01)\n",
    "        \n",
    "        can.cd()\n",
    "        cut = sel_ev[k] & ( np.abs(dR_csc_csc[k])<1 ) & ( np.abs(dEta_csc_csc[k])<0.4 ) #& ( np.abs(dPhi_csc_csc[k])<1 )\n",
    "        x_val = np.abs( dPhi_csc_csc[k][cut] )\n",
    "        y_val = np.abs( dEta_csc_csc[k][cut] )\n",
    "        h2[k] = create_TH2D(np.vstack((x_val, y_val)).T,title=\"\",axis_title = ['R','eta','Events'], binning=[100,0,4,100,0,3.2])\n",
    "        leg.SetHeader('CSC-CSC, presel.'+k)\n",
    "        #h2[k].SetMaximum(100)\n",
    "        #if 'signal' in k:\n",
    "        #h2[k].Scale(1./h2[k].Integral())\n",
    "        h2[k].Draw(\"colz\")\n",
    "        \n",
    "        leg.Draw()\n",
    "        can.SetRightMargin(0.15)\n",
    "        # if setlog: \n",
    "        can.SetLogz()\n",
    "        can.Draw()\n",
    "        drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "        #can.Print(\"plots/V1p19_\"+vers+\"/ABCD_plane_\"+str(k)+plot_string+\".pdf\")\n",
    "        #can.Print(\"plots/V1p19_\"+vers+\"/ABCD_plane_\"+str(k)+plot_string+\".png\")\n",
    "        #can.Close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "adfcfc1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "base\n",
      "S 1981\n",
      "B 14724\n",
      "S/sqrt B 16.325690958600813\n",
      "---\n",
      "eta>0.7\n",
      "S 456\n",
      "B 6920\n",
      "S/sqrt B 5.481656219911533\n",
      "---\n",
      "phi>1.\n",
      "S 1960\n",
      "B 9751\n",
      "S/sqrt B 19.848673740233405\n",
      "---\n",
      "phi>1.2\n",
      "S 1936\n",
      "B 7595\n",
      "S/sqrt B 22.214751725074827\n",
      "---\n",
      "R>1.2\n",
      "S 1952\n",
      "B 10052\n",
      "S/sqrt B 19.469445078975596\n",
      "---\n",
      "R>1.4\n",
      "S 1932\n",
      "B 7617\n",
      "S/sqrt B 22.136815441096726\n",
      "---\n"
     ]
    }
   ],
   "source": [
    "if category==1:\n",
    "\n",
    "    pass_ev = {}\n",
    "    pass_ev[\"signal\"] = {}\n",
    "    pass_ev[\"data\"] = {}\n",
    "    pass_ev[\"sb\"] = {}\n",
    "    cut_set = {}\n",
    "    for k in tree_keys:\n",
    "        if 'data' in k:\n",
    "            cut_set[\"base\"] = ( np.abs(dPhi_csc_csc[k])>0.7 ) & ( np.abs(dEta_csc_csc[k])<1.9 ) & ( np.abs(dPhi_csc_csc[k])<2. )\n",
    "        else:\n",
    "            cut_set[\"base\"] = ( np.abs(dPhi_csc_csc[k])>0.7 ) & ( np.abs(dEta_csc_csc[k])<1.9 )\n",
    "        cut_set[\"eta>0.7\"] = cut_set[\"base\"] & ( np.abs(dEta_csc_csc[k])>0.7 )\n",
    "        cut_set[\"phi>1.\"] = cut_set[\"base\"] & ( np.abs(dPhi_csc_csc[k])>1. )\n",
    "        cut_set[\"phi>1.2\"] = cut_set[\"base\"] & ( np.abs(dPhi_csc_csc[k])>1.2 )\n",
    "        cut_set[\"R>1.2\"] = cut_set[\"base\"] & ( np.abs(dR_csc_csc[k])>1.2 )\n",
    "        cut_set[\"R>1.4\"] = cut_set[\"base\"] & ( np.abs(dR_csc_csc[k])>1.4 )\n",
    "        #cut_set[\"eta>0.7 or R>1.4\"] = cut_set[\"base\"] & ( ( np.abs(dEta_csc_csc[k])>0.7 ) | ( np.abs(dR_csc_csc[k])>1.4 ) )\n",
    "        for c in cut_set.keys():\n",
    "            cut = sel_ev[k] & cut_set[c]\n",
    "            pass_ev[k][c] = cut[cut==True].sum()\n",
    "    for c in cut_set.keys():\n",
    "        pass_ev[\"sb\"][c] = pass_ev[\"signal\"][c] / math.sqrt(pass_ev[\"data\"][c])\n",
    "        print(c)\n",
    "        print(\"S\",pass_ev[\"signal\"][c])\n",
    "        print(\"B\",pass_ev[\"data\"][c])\n",
    "        print(\"S/sqrt B\",pass_ev[\"sb\"][c])\n",
    "        print(\"---\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3674353",
   "metadata": {},
   "source": [
    "## ABCD based on delta phi\n",
    "\n",
    "Decided to drop it because of too much beam halo"
   ]
  },
  {
   "cell_type": "raw",
   "id": "2cde132e",
   "metadata": {},
   "source": [
    "if category == 1:\n",
    "    can = rt.TCanvas('c','c', 1000, 800)\n",
    "    leg = rt.TLegend(0.5,0.65,0.65,0.88)\n",
    "    leg.SetTextSize(0.03)\n",
    "    leg.SetBorderSize(0)\n",
    "    leg.SetEntrySeparation(0.01)\n",
    "    h = {}\n",
    "    hnot = {}\n",
    "    hunbl = {}\n",
    "    hpred= {}\n",
    "    can.cd()\n",
    "    \n",
    "    x_min = 50\n",
    "    x_max = 100#1050\n",
    "    n_bins = 10\n",
    "    \n",
    "    #f1 = rt.TF1(\"f1\",\"expo(-x/([0]+[1]*x))\",50,1000)\n",
    "    #f1 = rt.TF1(\"f1\",\"expo(-x/(100+50000*x))\",50,1000)\n",
    "    #f1 = rt.TF1(\"f1\",\"exp(-x/(0*100 + 0*x))\",50,1000)\n",
    "    #f1 = rt.TF1(\"f1\",\"exp(-1.7*x/(100.) + 0.01/x)\",50,550)\n",
    "    f1 = rt.TF1(\"f1\",\"exp([0]*x + [1]/(x))/[2]\",x_min,x_max)\n",
    "    #f1 = rt.TF1(\"f1\",\"exp(-x/([0] + [1]*x))\",50,550)\n",
    "    f1.SetParameter(0,-0.03)\n",
    "    f1.SetParameter(1,200)\n",
    "    f1.SetParameter(2,74)\n",
    "    foot = rt.TF1(\"foot\",\"exp([0]*x + [1]/(x))/[2]\",x_min,x_max)\n",
    "    foot.SetParameter(0,-0.0069210997892010535)\n",
    "    foot.SetParameter(1,426.659535750436)\n",
    "    foot.SetParameter(2,195.1699385925665)\n",
    "    #e^{-x/(a+bx)\n",
    "    bins = np.array([  50. , 130. , 210. , 290. , 370. , 450. , 530. , 610. , 690. , 770. , 850. , 930. , 1010. , 1090. , \n",
    "                     1170. , 1250. , 1330. , 1410. , 1490. , 1570. , 1650. , 1730. , 1810. , 1890. , 1970. , 2050.])\n",
    "    #bins = np.array([  50. , 150. , 200. , 250., 300., 400. , 450. , 550. , 700. , 900. , 1500. , 2050.])\n",
    "    bins = np.linspace(x_min,x_max,n_bins+1)\n",
    "    bins_center = bins[0:-1]+0.5*(x_max-x_min)/n_bins\n",
    "    print(bins)\n",
    "    print(bins_center)\n",
    "    \n",
    "    blinding_bin = 2\n",
    "    \n",
    "    scale = True\n",
    "    scale = False\n",
    "    do_blind = True\n",
    "    \n",
    "    x_pred = []\n",
    "    x_pred_unc = []\n",
    "    y_pred = []\n",
    "    y_pred_up = []\n",
    "    y_pred_down = []\n",
    "    y_pred_unc = []\n",
    "\n",
    "    for k in tree_keys:\n",
    "        tmp_dphi = np.abs( deltaPhi(  cscClusterPhi[k][:,0].flatten(), cscClusterPhi[k][:,1].flatten() ) )\n",
    "        tmp_deta = np.abs(  cscClusterEta[k][:,0].flatten() - cscClusterEta[k][:,1].flatten() )\n",
    "        tmp_dt = np.abs( cscClusterTime[k][:,0].flatten() - cscClusterTime[k][:,1].flatten() )\n",
    "        cut_t = (np.abs(cscClusterTime[k][:,1])>=0)#50)\n",
    "        cut_phi = (tmp_dphi<0.4) & (tmp_dphi<0.2)\n",
    "        cut_phi_not = (tmp_dphi<0.4) & (tmp_dphi>=0.2)\n",
    "        cut_eta = (tmp_deta>=1.2)\n",
    "        cut_dt = (tmp_dt>=10)\n",
    "        blind = (cscClusterSize[k][:,1] < bins[blinding_bin] if do_blind else 100000 )\n",
    "        unblind = (cscClusterSize[k][:,1] >= bins[blinding_bin])\n",
    "        cut = cut_phi & cut_t==True\n",
    "        cut_not = (cut_phi==False) & cut_t==True\n",
    "        csc_size_2 = cscClusterSize[k][ sel_ev[k] & cut ][:,1]\n",
    "        csc_size_2_not = cscClusterSize[k][ sel_ev[k] & cut_not & blind ][:,1]\n",
    "        csc_size_2_unbl = cscClusterSize[k][ sel_ev[k] & cut_not & unblind ][:,1]\n",
    "        h[k] = create_TH1D(csc_size_2.flatten(),title=\"\",axis_title = ['CSC Cluster[1] Size','Events'], binning=bins)\n",
    "        #addOverflow(h[k])\n",
    "        leg.SetHeader('CSC-CSC, presel.')\n",
    "        h[k].SetLineColor(1)\n",
    "        h[k].SetLineWidth(2)\n",
    "        h[k].SetMarkerColor(1)\n",
    "        h[k].SetMarkerStyle(20)\n",
    "        h[k].SetMarkerSize(1.2)\n",
    "        \n",
    "        #hpred[k] = TH1F(\"pred_\"+k,\"pred_\"+k,len(bins)-1, array('f',bins))\n",
    "        #hpred[k].Sumw2()\n",
    "        \n",
    "        hnot[k] = create_TH1D(csc_size_2_not.flatten(),title=\"\",axis_title = ['CSC Cluster[1] Size','Events'], binning=bins)\n",
    "        hnot[k].SetLineColor(800)\n",
    "        hnot[k].SetLineWidth(2)\n",
    "        hnot[k].SetMarkerColor(800)\n",
    "        hnot[k].SetMarkerStyle(20)\n",
    "        hnot[k].SetMarkerSize(1.2)\n",
    "        \n",
    "        hunbl[k] = create_TH1D(csc_size_2_unbl.flatten(),title=\"\",axis_title = ['CSC Cluster[1] Size','Events'], binning=bins)\n",
    "        hunbl[k].SetLineColor(8)\n",
    "        hunbl[k].SetLineWidth(2)\n",
    "        hunbl[k].SetMarkerColor(8)\n",
    "        hunbl[k].SetMarkerStyle(21)\n",
    "        hunbl[k].SetMarkerSize(1.2)\n",
    "        if scale:\n",
    "            h[k].Scale(1./h[k].Integral() if h[k].Integral()>0 else 1.)\n",
    "            hnot[k].Scale(1./hnot[k].Integral() if hnot[k].Integral()>0 else 1.)\n",
    "            hunbl[k].Scale(1./hunbl[k].Integral() if hunbl[k].Integral()>0 else 1.)\n",
    "            \n",
    "        h[k].SetMaximum(  5*max(1. if scale else 1.9, max(h[k].GetMaximum(),hnot[k].GetMaximum()) )  )        \n",
    "        min_y = max(max(h[k].GetMinimum(),1.e-500 if scale else 0.9), max(hnot[k].GetMinimum(),1.e-500 if scale else 0.9))\n",
    "        h[k].SetMinimum(min_y*0.1)        \n",
    "        \n",
    "        if 'data' in k:\n",
    "            \n",
    "            h[k].Fit('f1', 'LRSQ+', '', x_min,x_max)\n",
    "            my_f1 = h[k].GetFunction(\"f1\")            \n",
    "            h[k].GetListOfFunctions().Remove(h[k].GetFunction(\"f1\"))\n",
    "            print(my_f1.GetParameter(0),my_f1.GetParError(0))\n",
    "            print(my_f1.GetParameter(1),my_f1.GetParError(0))\n",
    "            print(my_f1.GetParameter(2),my_f1.GetParError(0))\n",
    "            my_f1_up = my_f1.Clone(\"my_f1_up\")\n",
    "            my_f1_down = my_f1.Clone(\"my_f1_down\")\n",
    "            my_f1_up.SetParameter(0,  my_f1.GetParameter(0) + my_f1.GetParError(0) )\n",
    "            my_f1_up.SetParameter(1,  my_f1.GetParameter(1) + my_f1.GetParError(1) )\n",
    "            my_f1_up.SetParameter(2,  my_f1.GetParameter(2) + my_f1.GetParError(2) )\n",
    "            my_f1_down.SetParameter(0,  my_f1.GetParameter(0) - my_f1.GetParError(0) )\n",
    "            my_f1_down.SetParameter(1,  my_f1.GetParameter(1) - my_f1.GetParError(1) )\n",
    "            my_f1_down.SetParameter(2,  my_f1.GetParameter(2) - my_f1.GetParError(2) )\n",
    "            #print(foot.GetParameter(0))\n",
    "            #print(foot.GetParameter(1))\n",
    "            #print(foot.GetParameter(2))\n",
    "            h[k].Draw(\"PE same\")\n",
    "            hnot[k].Draw(\"PE same\")\n",
    "            my_f1.SetLineStyle(2)\n",
    "            my_f1.Draw('L same')\n",
    "            \n",
    "            leg.AddEntry(h[k],\"#Delta #varphi(CSC,CSC)<0.2\",\"PE\")\n",
    "            leg.AddEntry(my_f1,\"Fit\",\"L\")\n",
    "            leg.AddEntry(hnot[k],\"0.2<#Delta #varphi(CSC,CSC)<0.4\",\"PE\")\n",
    "            \n",
    "            if not do_blind:\n",
    "                hnot[k].Fit('foot', 'LRSQ+', '', x_min,x_max)\n",
    "                my_foot = hnot[k].GetFunction(\"foot\")\n",
    "                hnot[k].GetListOfFunctions().Remove(hnot[k].GetFunction(\"foot\"))\n",
    "                my_foot.SetLineColor(4)\n",
    "                my_foot.Draw('L same')\n",
    "                leg.AddEntry(my_foot,\"Fit\",\"L\")\n",
    "                \n",
    "            else:\n",
    "                ratio = hnot[k].Integral(1,blinding_bin)/h[k].Integral(1,blinding_bin)\n",
    "                #print(\"hnot \",ratio)\n",
    "                #print(\"prediction:\")\n",
    "                my_f1_up.SetLineColor(4)\n",
    "                my_f1_down.SetLineColor(1)\n",
    "                #my_f1_up.Draw(\"L same\")\n",
    "                #my_f1_down.Draw(\"L same\")\n",
    "                for b in bins_center[blinding_bin:]:\n",
    "                    print(\"x \", \"pred \", \"up\", \"down\", \"true \")\n",
    "                    print(b,ratio*my_f1.Eval(b), ratio*my_f1_up.Eval(b), ratio*my_f1_down.Eval(b),  hunbl[k].GetBinContent(hunbl[k].FindBin(b)))\n",
    "                    x_pred.append(b)\n",
    "                    x_pred_unc.append(0.5*(x_max-x_min)/n_bins)\n",
    "                    y_pred.append(ratio*my_f1.Eval(b))\n",
    "                    y_pred_up.append(ratio*my_f1_up.Eval(b))\n",
    "                    y_pred_down.append(ratio*my_f1_down.Eval(b))\n",
    "                    y_pred_unc.append(max( abs(ratio*my_f1.Eval(b) - ratio*my_f1_up.Eval(b)) , abs(ratio*my_f1.Eval(b) - ratio*my_f1_down.Eval(b)) ))\n",
    "                \n",
    "                gr = create_TGraph(x_pred,y_pred,ex=x_pred_unc,ey=y_pred_unc, axis_title = ['',''])\n",
    "                #print(gr.Print())\n",
    "                gr.SetFillColorAlpha(861,0.3)\n",
    "                gr.SetLineColor(861)\n",
    "                gr.SetLineWidth(0)\n",
    "                gr.SetMarkerStyle(21)\n",
    "                gr.SetMarkerColor(861)\n",
    "\n",
    "                gr.Draw('PE2 same')\n",
    "                leg.AddEntry(gr,\"Prediction\",\"PF\")\n",
    "                hunbl[k].Draw('PE same')\n",
    "                leg.AddEntry(hunbl[k],\"True values\",\"PE\")\n",
    "                \n",
    "        #if 'signal' in k:\n",
    "        #    h[k].Draw(\"HISTO same\")\n",
    "        #    hnot[k].Draw(\"HISTO same\")            \n",
    "            \n",
    "    leg.Draw()\n",
    "    can.SetRightMargin(0.15)\n",
    "    # if setlog: \n",
    "    can.SetLogy()\n",
    "    can.Draw()\n",
    "    drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "    can.Print(\"plots/V1p19_\"+vers+\"/CscCscClusterSize_fit\"+plot_string+\".pdf\")\n",
    "    can.Print(\"plots/V1p19_\"+vers+\"/CscCscClusterSize_fit\"+plot_string+\".png\")\n",
    "    #can.Close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afd1b5f2",
   "metadata": {},
   "source": [
    "## ABCD based on time/eta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8492d52b",
   "metadata": {},
   "source": [
    "Large eta\n",
    "* At large eta (>2) we have stuff mostly OOT or with a large delay. \n",
    "* At eta >2, we can validate based on large/small time delay (20). The shapes agree with each othe, can be used as validation.\n",
    "* At eta>2, phi is flat. Can use that as well as validation. Works well with phi 1.7, 2, 2.7. Very good\n",
    "\n",
    "Small eta, small phi\n",
    "* At small eta (<2) and phi<2 must be careful with unblinding\n",
    "* Time windows agree up to ~30 ns. Beyond that, beam halo components start to dominate\n",
    "\n",
    "Small eta, very small phi\n",
    "* At small eta (<2) and even smaller phi<1 can choose in time\n",
    "* 0-10 and 10-20 agree well\n",
    "\n",
    "Explore eta feature at 0.3 (probably trigger clustering)\n",
    "* At 0.3<eta<2 and phi<1, tiny bit of signal left\n",
    "* Time windows agree up to ~30 ns. Beyond that, beam halo components start to dominate\n",
    "\n",
    "Explore eta feature < 0.3 (probably trigger clustering)\n",
    "* At eta<0.3 and phi<1, not much signal left\n",
    "* Time windows are a bit more unstable, probably not very good for closure. Works only for smaller multiplicities\n",
    "\n",
    "Invert jet veto on cluster 1\n",
    "* Negligible amount of signal\n",
    "* Works well, stat is low, need to study delta eta in this case\n",
    "\n",
    "When we compare small/large phi, different slope\n",
    "* They have a different shape, large phi has a much steeper slope, we overpredict\n",
    "* Large phi seems a lot more like OOT\n",
    "\n",
    "New study: split in HLT categories\n",
    "* Start with category 1\n",
    "* The issue seems to come from the part of the delta phi spectrum that is not flat\n",
    "* If we cut it away, it seems to close decently also being inclusive in trigger category\n",
    "\n",
    "Delta Phi step when deta<1.9 and in time\n",
    "* Still a slope due to events with small deta < 0.7\n",
    "* Need to tune that based on R to not reject signal, perhaps deta<0.7 and dR<0.7? or when dR is the same as deta? because dphi in signal is never zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "b076e92d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 50.  70.  90. 110. 130. 150. 170. 190. 210. 230. 250.]\n",
      "[ 60.  80. 100. 120. 140. 160. 180. 200. 220. 240.]\n",
      "-0.014442027921336803 0.00758370267957865\n",
      "256.2947852994646 0.00758370267957865\n",
      "0.22692211803066673 0.00758370267957865\n",
      "x  pred  up down true \n",
      "100.0 19.430951257238494 31.74921460744283 -10.222990492914148 26.0\n",
      "x  pred  up down true \n",
      "120.0 9.49598128461308 16.237898136601984 -4.77389327853679 9.0\n",
      "x  pred  up down true \n",
      "140.0 5.243112383732425 9.671801133429113 -2.4433956362009703 5.0\n",
      "x  pred  up down true \n",
      "160.0 3.1243932370982166 6.336476861488472 -1.3243608793330521 3.0\n",
      "x  pred  up down true \n",
      "180.0 1.958966526905998 4.423475723470096 -0.7457842389618488 1.0\n",
      "x  pred  up down true \n",
      "200.0 1.272763475858469 3.228361450412329 -0.43135622901332926 2.0\n",
      "x  pred  up down true \n",
      "220.0 0.8486166835002309 2.4335428169296924 -0.2543940550393811 2.0\n",
      "x  pred  up down true \n",
      "240.0 0.5769096544134189 1.8794231917726225 -0.15223476831836066 0.0\n",
      "\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "/nfs/dust/cms/user/lbenato/anaconda3/envs/run3/lib/python3.7/site-packages/root_numpy/_hist.py:76: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  ROOT.AsCObject(hist), array, weights, return_indices)\n",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n",
      "Info in <TCanvas::Print>: pdf file plots/V1p19_v6/CscCscClusterSize_fit_test_exactly_2_csc_clusters_ME_veto.pdf has been created\n",
      "Info in <TCanvas::Print>: png file plots/V1p19_v6/CscCscClusterSize_fit_test_exactly_2_csc_clusters_ME_veto.png 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": [
    "if category == 1:\n",
    "    can = rt.TCanvas('c','c', 1000, 800)\n",
    "    leg = rt.TLegend(0.5,0.65,0.65,0.88)\n",
    "    leg.SetTextSize(0.03)\n",
    "    leg.SetBorderSize(0)\n",
    "    leg.SetEntrySeparation(0.01)\n",
    "    h = {}\n",
    "    hnot = {}\n",
    "    hunbl = {}\n",
    "    hpred= {}\n",
    "    can.cd()\n",
    "    \n",
    "    PHI_MIN = 0.7\n",
    "    PHI_CUT = 1.5\n",
    "    PHI_MAX = 2.\n",
    "    \n",
    "    x_min = 50\n",
    "    x_max = 100#1050\n",
    "    n_bins = 10\n",
    "\n",
    "    #x_max = 200\n",
    "    #n_bins = 10\n",
    "    #blinding_bin = 2\n",
    "    #blinding_bin = 1\n",
    "    #n_bins = 15#3\n",
    "    \n",
    "    #Tune\n",
    "    x_max = 250\n",
    "    n_bins = 10\n",
    "    blinding_bin = 2\n",
    "    blinding_bin = 2\n",
    "    \n",
    "    N_MIN = x_min\n",
    "    N_MAX = x_max\n",
    "    N_CUT = bins[blinding_bin]\n",
    "    \n",
    "    #n_bins = 4\n",
    "    \n",
    "    #x_max = 300\n",
    "    #n_bins = 10\n",
    "    #blinding_bin = 2\n",
    "    #blinding_bin = 1\n",
    "    \n",
    "    #n_bins = 5\n",
    "    \n",
    "    #Tune\n",
    "    #x_max = 550\n",
    "    #n_bins = 10\n",
    "    \n",
    "\n",
    "    #Tune\n",
    "    #x_max = 1050\n",
    "    #n_bins = 10\n",
    "    \n",
    "    #f1 = rt.TF1(\"f1\",\"expo(-x/([0]+[1]*x))\",50,1000)\n",
    "    #f1 = rt.TF1(\"f1\",\"expo(-x/(100+50000*x))\",50,1000)\n",
    "    #f1 = rt.TF1(\"f1\",\"exp(-x/(0*100 + 0*x))\",50,1000)\n",
    "    #f1 = rt.TF1(\"f1\",\"exp(-1.7*x/(100.) + 0.01/x)\",50,550)\n",
    "    f1 = rt.TF1(\"f1\",\"exp([0]*x + [1]/(x))/[2]\",x_min,x_max)\n",
    "    #f1 = rt.TF1(\"f1\",\"exp(-x/([0] + [1]*x))\",50,550)\n",
    "    f1.SetParameter(0,-0.03)\n",
    "    f1.SetParameter(1,200)\n",
    "    f1.SetParameter(2,74)\n",
    "    foot = rt.TF1(\"foot\",\"exp([0]*x + [1]/(x))/[2]\",x_min,x_max)\n",
    "    foot.SetParameter(0,-0.0069210997892010535)\n",
    "    foot.SetParameter(1,426.659535750436)\n",
    "    foot.SetParameter(2,195.1699385925665)\n",
    "    #e^{-x/(a+bx)\n",
    "    bins = np.array([  50. , 130. , 210. , 290. , 370. , 450. , 530. , 610. , 690. , 770. , 850. , 930. , 1010. , 1090. , \n",
    "                     1170. , 1250. , 1330. , 1410. , 1490. , 1570. , 1650. , 1730. , 1810. , 1890. , 1970. , 2050.])\n",
    "    #bins = np.array([  50. , 150. , 200. , 250., 300., 400. , 450. , 550. , 700. , 900. , 1500. , 2050.])\n",
    "    bins = np.linspace(x_min,x_max,n_bins+1)\n",
    "    bins_center = bins[0:-1]+0.5*(x_max-x_min)/n_bins\n",
    "    print(bins)\n",
    "    print(bins_center)\n",
    "    \n",
    "    \n",
    "    \n",
    "    scale = True\n",
    "    scale = False\n",
    "    do_blind = True\n",
    "    \n",
    "    x_pred = []\n",
    "    x_pred_unc = []\n",
    "    y_pred = []\n",
    "    y_pred_up = []\n",
    "    y_pred_down = []\n",
    "    y_pred_unc = []\n",
    "\n",
    "    for k in tree_keys:\n",
    "        tmp_dphi = np.abs( dPhi_csc_csc[k] )\n",
    "        tmp_deta = np.abs(  dEta_csc_csc[k] )\n",
    "        tmp_dt = np.abs( dt_csc_csc[k] )\n",
    "        tmp_t2 = (cscClusterTime[k][:,1])\n",
    "        \n",
    "        #cut_t = #(np.abs(cscClusterTime[k][:,1])>=0)#50)\n",
    "        cut_phi = (tmp_dphi<2.)\n",
    "        #cut_phi_not = (tmp_dphi<0.4) & (tmp_dphi>=0.2)\n",
    "        #cut_eta = (tmp_deta>=1.2)\n",
    "        cut_dt = (tmp_dt>=20)\n",
    "        blind = (cscClusterSize[k][:,1] < bins[blinding_bin] if do_blind else 100000 )\n",
    "        unblind = (cscClusterSize[k][:,1] >= bins[blinding_bin])\n",
    "        \n",
    "        #Works very well:\n",
    "        '''\n",
    "        leg.SetHeader('CSC-CSC, presel., |#Delta #eta|>2')\n",
    "        pre_cut = sel_ev[k] & (tmp_deta>2)\n",
    "        cut = (cut_dt==True)\n",
    "        cut_label = \"#Delta t (CSC,CSC) #geq 20 ns\"\n",
    "        cut_not = (cut_dt==False)\n",
    "        cut_not_label = \"#Delta t (CSC,CSC) < 20 ns\"\n",
    "        '''\n",
    "        \n",
    "        #Works very well:\n",
    "        '''\n",
    "        leg.SetHeader('CSC-CSC, presel., |#Delta #eta|>1.9')\n",
    "        pre_cut = sel_ev[k] & (tmp_deta>1.9)\n",
    "        cut = (tmp_dphi<2.5)\n",
    "        cut_label = \"0.65 < #Delta #varphi (CSC,CSC) < 2.\"\n",
    "        cut_not = (tmp_dphi>=2.5)\n",
    "        cut_not_label = \"#Delta #varphi (CSC,CSC) > 2.\"\n",
    "        '''\n",
    "        \n",
    "        #Works with care, beyond dt~30 s distribution shape changes\n",
    "        '''\n",
    "        leg.SetHeader('CSC-CSC, presel., |#Delta #eta|<2, |#Delta #varphi|<2')\n",
    "        pre_cut = sel_ev[k] & (tmp_deta<2.) & (tmp_dphi<2.)\n",
    "        cut_dt_small = (tmp_dt>=0) & (tmp_dt<10)\n",
    "        cut_dt_large = (tmp_dt>=10) & (tmp_dt<20) \n",
    "        cut = (cut_dt_large==True)\n",
    "        cut_label = \"#Delta t (CSC,CSC) > 20\"\n",
    "        cut_not = (cut_dt_small==True)\n",
    "        cut_not_label = \"15<#Delta t (CSC,CSC)<20\"  \n",
    "        '''\n",
    "\n",
    "        #Works with care, beyond dt~30 s distribution shape changes\n",
    "        '''\n",
    "        leg.SetHeader('CSC-CSC, presel., |#Delta #eta|<2, |#Delta #varphi|<1')\n",
    "        pre_cut = sel_ev[k] & (tmp_deta<2.) & (tmp_dphi<1.)\n",
    "        cut_dt_small = (tmp_dt>=0) & (tmp_dt<10)\n",
    "        cut_dt_large = (tmp_dt>=10) & (tmp_dt<15) \n",
    "        cut = (cut_dt_large==True)\n",
    "        cut_label = \"#Delta t (CSC,CSC) > 15\"\n",
    "        cut_not = (cut_dt_small==True)\n",
    "        cut_not_label = \"15<#Delta t (CSC,CSC)<15\"  \n",
    "        '''\n",
    "\n",
    "        '''\n",
    "        leg.SetHeader('CSC-CSC, presel., 0.3<|#Delta #eta|<2, |#Delta #varphi|<1')\n",
    "        pre_cut = sel_ev[k] & (tmp_deta>=0.3) & (tmp_deta<2.) & (tmp_dphi<1.)\n",
    "        cut_dt_small = (tmp_dt>=0) & (tmp_dt<10)\n",
    "        cut_dt_large = (tmp_dt>=10) & (tmp_dt<25) \n",
    "        cut = (cut_dt_large==True)\n",
    "        cut_label = \"#Delta t (CSC,CSC) > 20\"\n",
    "        cut_not = (cut_dt_small==True)\n",
    "        cut_not_label = \"15<#Delta t (CSC,CSC)<20\"\n",
    "        '''\n",
    "\n",
    "        '''\n",
    "        leg.SetHeader('CSC-CSC, presel., |#Delta #eta|<0.3, |#Delta #varphi|<1')\n",
    "        pre_cut = sel_ev[k] & (tmp_deta<0.3) & (tmp_dphi<1.)\n",
    "        cut_dt_small = (tmp_dt>=0) & (tmp_dt<10)\n",
    "        cut_dt_large = (tmp_dt>=10) & (tmp_dt<15) \n",
    "        cut = (cut_dt_large==True)\n",
    "        cut_label = \"#Delta t (CSC,CSC) > 20\"\n",
    "        cut_not = (cut_dt_small==True)\n",
    "        cut_not_label = \"15<#Delta t (CSC,CSC)<20\" \n",
    "        '''\n",
    "\n",
    "        '''\n",
    "        leg.SetHeader('CSC-CSC, presel., |#Delta #eta|<0.3, |#Delta #varphi|<1')\n",
    "        pre_cut = sel_ev[k] & (tmp_deta<0.3) & (tmp_dphi<1.)\n",
    "        cut_phi_small = (tmp_dphi>=0.65) & (tmp_dphi<0.8)\n",
    "        cut_phi_large = (tmp_dphi>=0.8) & (tmp_dphi<1.) \n",
    "        cut = (cut_phi_small==True)\n",
    "        cut_label = \"0.65 < #Delta #varphi (CSC,CSC) < 0.8\"\n",
    "        cut_not = (cut_phi_large==True)\n",
    "        cut_not_label = \"0.65 < #Delta #varphi (CSC,CSC) < 1\"\n",
    "        '''\n",
    "        \n",
    "        #Low stat but works also great\n",
    "        '''\n",
    "        leg.SetHeader('CSC-CSC, presel., invert jet veto')\n",
    "        pre_cut = sel_ev[k] & (sel_jetveto_csc[k][:,0]==False)\n",
    "        cut_phi_small = (tmp_dphi>=0.65) & (tmp_dphi<2)\n",
    "        cut_phi_large = (tmp_dphi>=2) & (tmp_dphi<5) \n",
    "        cut = (cut_phi_small==True)\n",
    "        cut_label = \"0.65 < #Delta #varphi (CSC,CSC) < 2\"\n",
    "        cut_not = (cut_phi_large==True)\n",
    "        cut_not_label = \"2 < #Delta #varphi (CSC,CSC) < #pi\"\n",
    "        '''\n",
    "        \n",
    "        #Does not work well: high phi has a different slope in the very first bins...\n",
    "        \n",
    "        leg.SetHeader('CSC-CSC, presel., |#Delta #eta|<0.3, invert jet veto')\n",
    "        pre_cut = sel_ev[k] & (tmp_deta<1.9) & first_in_tr1[k] & (np.abs(dPhi_csc_csc[k])>1.2)# & (np.abs(dEta_csc_csc[k])<0.4))#(tmp_deta>0.7)# & (np.abs(tmp_t2)<50) # & (sel_jetveto_csc[k][:,0]==True)#& (tmp_deta<0.3) \n",
    "        cut_phi_small = (tmp_dphi>=0.7) & (tmp_dphi<1.5)\n",
    "        cut_phi_large = (tmp_dphi>=1.5) & (tmp_dphi<2) \n",
    "        cut = (cut_phi_small==True)\n",
    "        cut_label = \"1 < #Delta #varphi (CSC,CSC) < 1.2\"\n",
    "        cut_not = (cut_phi_large==True)\n",
    "        cut_not_label = \"1.2 < #Delta #varphi (CSC,CSC) < 1.5\"\n",
    "        \n",
    "\n",
    "        #Avoiding bumpy structures in phi seems to work\n",
    "        '''\n",
    "        leg.SetHeader('CSC-CSC, presel., |#Delta #eta|<0.3, invert jet veto')\n",
    "        pre_cut = sel_ev[k] & (tmp_deta<1.9) #& first_in_tr1[k]#(sel_jetveto_csc[k][:,0]==True)#& (tmp_deta<0.3) \n",
    "        cut_small = (tmp_dphi>=1.) & (tmp_dphi<1.5) \n",
    "        cut_large = (tmp_dphi>=1.) & (tmp_dphi>1.5) & (tmp_dphi<2) #& (tmp_dt>50) \n",
    "        cut = (cut_small==True)\n",
    "        cut_label = \"0.65 < #Delta #varphi (CSC,CSC) < 2\"\n",
    "        cut_not = (cut_large==True)\n",
    "        cut_not_label = \"2 < #Delta #varphi (CSC,CSC) < #pi\"\n",
    "        '''\n",
    "              \n",
    "        csc_size_2 = cscClusterSize[k][ pre_cut & cut ][:,1]\n",
    "        csc_size_2_not = cscClusterSize[k][ pre_cut & cut_not & blind ][:,1]\n",
    "        csc_size_2_unbl = cscClusterSize[k][ pre_cut & cut_not & unblind ][:,1]\n",
    "        h[k] = create_TH1D(csc_size_2.flatten(),title=\"\",axis_title = ['CSC Cluster[1] Size','Events'], binning=bins,bin_list=True)\n",
    "        #addOverflow(h[k])\n",
    "        \n",
    "        h[k].SetLineColor(1)\n",
    "        h[k].SetLineWidth(2)\n",
    "        h[k].SetMarkerColor(1)\n",
    "        h[k].SetMarkerStyle(20)\n",
    "        h[k].SetMarkerSize(1.2)\n",
    "        \n",
    "        #hpred[k] = TH1F(\"pred_\"+k,\"pred_\"+k,len(bins)-1, array('f',bins))\n",
    "        #hpred[k].Sumw2()\n",
    "        \n",
    "        hnot[k] = create_TH1D(csc_size_2_not.flatten(),title=\"\",axis_title = ['CSC Cluster[1] Size','Events'], binning=bins,bin_list=True)\n",
    "        hnot[k].SetLineColor(800)\n",
    "        hnot[k].SetLineWidth(2)\n",
    "        hnot[k].SetMarkerColor(800)\n",
    "        hnot[k].SetMarkerStyle(20)\n",
    "        hnot[k].SetMarkerSize(1.2)\n",
    "        \n",
    "        hunbl[k] = create_TH1D(csc_size_2_unbl.flatten(),title=\"\",axis_title = ['CSC Cluster[1] Size','Events'], binning=bins,bin_list=True)\n",
    "        hunbl[k].SetLineColor(8)\n",
    "        hunbl[k].SetLineWidth(2)\n",
    "        hunbl[k].SetMarkerColor(8)\n",
    "        hunbl[k].SetMarkerStyle(21)\n",
    "        hunbl[k].SetMarkerSize(1.2)\n",
    "        if scale:\n",
    "            h[k].Scale(1./h[k].Integral() if h[k].Integral()>0 else 1.)\n",
    "            hnot[k].Scale(1./hnot[k].Integral() if hnot[k].Integral()>0 else 1.)\n",
    "            hunbl[k].Scale(1./hunbl[k].Integral() if hunbl[k].Integral()>0 else 1.)\n",
    "            \n",
    "        h[k].SetMaximum(  5*max(1. if scale else 1.9, max(h[k].GetMaximum(),hnot[k].GetMaximum()) )  )        \n",
    "        min_y = max(max(h[k].GetMinimum(),1.e-500 if scale else 0.9), max(hnot[k].GetMinimum(),1.e-500 if scale else 0.9))\n",
    "        h[k].SetMinimum(min(min_y*0.1,0.6 if min_y==0 else 1000))        \n",
    "        \n",
    "        if 'data' in k:\n",
    "            \n",
    "            h[k].Fit('f1', 'LRSQ+', '', x_min,x_max)\n",
    "            my_f1 = h[k].GetFunction(\"f1\")            \n",
    "            h[k].GetListOfFunctions().Remove(h[k].GetFunction(\"f1\"))\n",
    "            print(my_f1.GetParameter(0),my_f1.GetParError(0))\n",
    "            print(my_f1.GetParameter(1),my_f1.GetParError(0))\n",
    "            print(my_f1.GetParameter(2),my_f1.GetParError(0))\n",
    "            my_f1_up = my_f1.Clone(\"my_f1_up\")\n",
    "            my_f1_down = my_f1.Clone(\"my_f1_down\")\n",
    "            my_f1_up.SetParameter(0,  my_f1.GetParameter(0) + my_f1.GetParError(0) )\n",
    "            my_f1_up.SetParameter(1,  my_f1.GetParameter(1) + my_f1.GetParError(1) )\n",
    "            my_f1_up.SetParameter(2,  my_f1.GetParameter(2) + my_f1.GetParError(2) )\n",
    "            my_f1_down.SetParameter(0,  my_f1.GetParameter(0) - my_f1.GetParError(0) )\n",
    "            my_f1_down.SetParameter(1,  my_f1.GetParameter(1) - my_f1.GetParError(1) )\n",
    "            my_f1_down.SetParameter(2,  my_f1.GetParameter(2) - my_f1.GetParError(2) )\n",
    "            #print(foot.GetParameter(0))\n",
    "            #print(foot.GetParameter(1))\n",
    "            #print(foot.GetParameter(2))\n",
    "            h[k].Draw(\"PE same\")\n",
    "            hnot[k].Draw(\"PE same\")\n",
    "            my_f1.SetLineStyle(2)\n",
    "            my_f1.Draw('L same')\n",
    "            \n",
    "            leg.AddEntry(h[k],cut_label,\"PE\")\n",
    "            leg.AddEntry(my_f1,\"Fit\",\"L\")\n",
    "            leg.AddEntry(hnot[k],cut_not_label,\"PE\")\n",
    "            \n",
    "            if not do_blind:\n",
    "                hnot[k].Fit('foot', 'LRSQ+', '', x_min,x_max)\n",
    "                my_foot = hnot[k].GetFunction(\"foot\")\n",
    "                hnot[k].GetListOfFunctions().Remove(hnot[k].GetFunction(\"foot\"))\n",
    "                my_foot.SetLineColor(4)\n",
    "                my_foot.Draw('L same')\n",
    "                leg.AddEntry(my_foot,\"Fit\",\"L\")\n",
    "                \n",
    "            else:\n",
    "                ratio = hnot[k].Integral(1,blinding_bin)/h[k].Integral(1,blinding_bin)\n",
    "                #print(\"hnot \",ratio)\n",
    "                #print(\"prediction:\")\n",
    "                my_f1_up.SetLineColor(4)\n",
    "                my_f1_down.SetLineColor(1)\n",
    "                #my_f1_up.Draw(\"L same\")\n",
    "                #my_f1_down.Draw(\"L same\")\n",
    "                for b in bins_center[blinding_bin:]:\n",
    "                    print(\"x \", \"pred \", \"up\", \"down\", \"true \")\n",
    "                    print(b,ratio*my_f1.Eval(b), ratio*my_f1_up.Eval(b), ratio*my_f1_down.Eval(b),  hunbl[k].GetBinContent(hunbl[k].FindBin(b)))\n",
    "                    x_pred.append(b)\n",
    "                    x_pred_unc.append(0.5*(x_max-x_min)/n_bins)\n",
    "                    y_pred.append(ratio*my_f1.Eval(b))\n",
    "                    y_pred_up.append(ratio*my_f1_up.Eval(b))\n",
    "                    y_pred_down.append(ratio*my_f1_down.Eval(b))\n",
    "                    y_pred_unc.append(max( abs(ratio*my_f1.Eval(b) - ratio*my_f1_up.Eval(b)) , abs(ratio*my_f1.Eval(b) - ratio*my_f1_down.Eval(b)) ))\n",
    "                \n",
    "                \n",
    "                gr = create_TGraph(x_pred,y_pred,ex=x_pred_unc,ey=y_pred_unc, axis_title = ['',''])\n",
    "                #print(gr.Print())\n",
    "                gr.SetFillColorAlpha(861,0.3)\n",
    "                gr.SetLineColor(861)\n",
    "                gr.SetLineWidth(0)\n",
    "                gr.SetMarkerStyle(21)\n",
    "                gr.SetMarkerColor(861)\n",
    "\n",
    "                gr.Draw('PE2 same')\n",
    "                leg.AddEntry(gr,\"Prediction\",\"PF\")\n",
    "                hunbl[k].Draw('PE same')\n",
    "                leg.AddEntry(hunbl[k],\"True values\",\"PE\")\n",
    "                \n",
    "        #if 'signal' in k:\n",
    "        #    h[k].Draw(\"HISTO same\")\n",
    "        #    hnot[k].Draw(\"HISTO same\")            \n",
    "            \n",
    "    leg.Draw()\n",
    "    can.SetRightMargin(0.15)\n",
    "    # if setlog: \n",
    "    can.SetLogy()\n",
    "    can.Draw()\n",
    "    drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "    can.Print(\"plots/V1p19_\"+vers+\"/CscCscClusterSize_fit_test\"+plot_string+\".pdf\")\n",
    "    can.Print(\"plots/V1p19_\"+vers+\"/CscCscClusterSize_fit_test\"+plot_string+\".png\")\n",
    "    print(\"\\n\")\n",
    "    \n",
    "    print(\"\\n\")\n",
    "    #can.Close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93bbe57d",
   "metadata": {},
   "source": [
    "# ABCD based on histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "cb5b4ddb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B\t C\t D\t A pred (B*D/C)\t Graph \t\t A true\t\t diff abcd\t diff graph\n",
      "242\t 168\t 28\t 40.33 +- 8.63 41.95 +- 34.31 48 +- 6.9\t -7.67 \t -6.05\n"
     ]
    }
   ],
   "source": [
    "#PHI_MIN = min_dphi\n",
    "#PHI_CUT = 2\n",
    "#MIN_N = 90\n",
    "#MAX_N = 250\n",
    "a = {}\n",
    "b = {}\n",
    "c = {}\n",
    "d = {}\n",
    "if category==1:\n",
    "    for k in tree_keys:\n",
    "        if 'data' in k:\n",
    "            #A: SR\n",
    "            #C: all low, black first bins\n",
    "            #B: yellow\n",
    "            #D: black high bins\n",
    "            d[k] = h[k].Integral(blinding_bin+1,n_bins)\n",
    "            b[k] = hnot[k].Integral(0,blinding_bin)\n",
    "            c[k] = h[k].Integral(0,blinding_bin)\n",
    "            a[k] = hunbl[k].Integral()\n",
    "    \n",
    "            pred = (b[k]*d[k])/c[k]\n",
    "            unc_pred = (1./b[k] + 1./d[k] + 1./c[k])**0.5*pred\n",
    "            print(\"B\\t\", \"C\\t\", \"D\\t\", \"A pred (B*D/C)\\t\", \"Graph \\t\\t\", \"A true\\t\\t\",\"diff abcd\\t\",\"diff graph\")\n",
    "            print( (\"%i\\t %i\\t %i\\t %.2f +- %.2f %.2f +- %.2f %i +- %.1f\\t %.2f \\t %.2f\") % (b[k],c[k],d[k],pred,unc_pred,np.sum(y_pred),np.sqrt( np.sum(np.array(y_pred_unc)**2)),a[k],math.sqrt(a[k]),pred-a[k], np.sum(y_pred)-a[k]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18a616e6",
   "metadata": {},
   "source": [
    "# ABCD standalone"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "b4ccefd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7\n",
      "2.0\n",
      "1.5\n",
      "50\n",
      "250\n",
      "90.0\n"
     ]
    }
   ],
   "source": [
    "print(PHI_MIN)\n",
    "print(PHI_MAX)\n",
    "print(PHI_CUT)\n",
    "\n",
    "print(N_MIN)\n",
    "print(N_MAX)\n",
    "print(N_CUT)\n",
    "\n",
    "a = {}\n",
    "b = {}\n",
    "c = {}\n",
    "d = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb4bd1e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d76c36a0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "raw",
   "id": "2a812427",
   "metadata": {},
   "source": [
    "if category == 2:\n",
    "    can = rt.TCanvas('c','c', 1000, 800)\n",
    "    leg = rt.TLegend(0.5,0.65,0.65,0.88)\n",
    "    leg.SetTextSize(0.03)\n",
    "    leg.SetBorderSize(0)\n",
    "    leg.SetEntrySeparation(0.01)\n",
    "    h = {}\n",
    "    can.cd()\n",
    "    #f1 = rt.TF1(\"f1\",\"expo(-x/([0]+[1]*x))\",50,1000)\n",
    "    #f1 = rt.TF1(\"f1\",\"expo(-x/(100+50000*x))\",50,1000)\n",
    "    f1 = rt.TF1(\"f1\",\"exp(-x/(0*100 + 0*x))\",50,1000)\n",
    "    f1 = rt.TF1(\"f1\",\"exp(-1.7*x/(100.) + 0.01/x)\",50,1050)\n",
    "    f1 = rt.TF1(\"f1\",\"exp([0]*x + [1]/(x))/[2]\",50,550)\n",
    "    #f1 = rt.TF1(\"f1\",\"exp(-x/([0] + [1]*x))\",50,550)\n",
    "    f1.SetParameter(0,-0.01)\n",
    "    f1.SetParameter(1,57)\n",
    "    f1.SetParameter(2,2)\n",
    "    foot = rt.TF1(\"foot\",\"exp([0]*x + [1]/(x))/[2]\",50,550)\n",
    "    foot.SetParameter(0,-0.010827820255988841)\n",
    "    foot.SetParameter(1,57)\n",
    "    foot.SetParameter(2,2)\n",
    "    #e^{-x/(a+bx)\n",
    "\n",
    "    for k in tree_keys:\n",
    "        cut = sel_ev[k] & (np.abs(dtClusterTime[k][:,0])==0)\n",
    "        dt_size_2 = dtClusterSize[k][ cut ][:,0]\n",
    "        h[k] = create_TH1D(dt_size_2.flatten(),title=\"\",axis_title = ['DT Cluster[0] Size','Events'], binning=[20,50,550])\n",
    "        leg.SetHeader('CSC-DT, presel., OOT')\n",
    "        h[k].SetLineColor(1)\n",
    "        h[k].SetLineWidth(2)\n",
    "        h[k].SetMarkerColor(1)\n",
    "        h[k].SetMarkerStyle(20)\n",
    "        h[k].SetMarkerSize(1.2)\n",
    "        \n",
    "        if 'data' in k:\n",
    "            h[k].Scale(1./h[k].Integral())\n",
    "            h[k].SetMaximum(1)\n",
    "            h[k].Draw(\"PE same\")\n",
    "            h[k].Fit('f1', 'LRSQ+', '', 0,1050)\n",
    "            #f1.Draw('L same')\n",
    "            foot.SetLineColor(4)\n",
    "            #foot.Draw('L same')\n",
    "            h[k].Draw(\"PE same\")\n",
    "            print(f1.GetParameter(0))\n",
    "            print(f1.GetParameter(1))\n",
    "            print(f1.GetParameter(2))\n",
    "        \n",
    "    leg.Draw()\n",
    "    can.SetRightMargin(0.15)\n",
    "    # if setlog: \n",
    "    can.SetLogy()\n",
    "    can.Draw()\n",
    "    drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "    can.Print(\"plots/V1p19_\"+vers+\"/CscDtClusterSize_fit\"+plot_string+\".pdf\")\n",
    "    can.Print(\"plots/V1p19_\"+vers+\"/CscDtClusterSize_fit\"+plot_string+\".png\")\n",
    "    #can.Close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e340112",
   "metadata": {},
   "source": [
    "## Effect of CSC being in more than one station\n",
    "\n",
    "Look at smoothness of DT"
   ]
  },
  {
   "cell_type": "raw",
   "id": "983eb4b1",
   "metadata": {},
   "source": [
    "dict_ME = {}\n",
    "dict_ME[\"ME11\"] = first_in_plateau_ME11\n",
    "dict_ME[\"ME12\"] = first_in_plateau_ME12\n",
    "dict_ME[\"ME13\"] = first_in_plateau_ME13\n",
    "dict_ME[\"ME21\"] = first_in_plateau_ME21\n",
    "dict_ME[\"ME22\"] = first_in_plateau_ME22\n",
    "dict_ME[\"ME31\"] = first_in_plateau_ME31\n",
    "dict_ME[\"ME32\"] = first_in_plateau_ME32\n",
    "dict_ME[\"ME41\"] = first_in_plateau_ME41\n",
    "dict_ME[\"ME42\"] = first_in_plateau_ME42\n",
    "dict_ME[\"all\"]  = first_in_plateau"
   ]
  },
  {
   "cell_type": "raw",
   "id": "f26cc822",
   "metadata": {},
   "source": [
    "for m in dict_ME.keys():\n",
    "        \n",
    "    can = rt.TCanvas('c','c', 1000, 800)\n",
    "    leg = rt.TLegend(0.12,0.75,0.37,0.87)\n",
    "    leg.SetTextSize(0.03)\n",
    "    leg.SetBorderSize(0)\n",
    "    leg.SetEntrySeparation(0.01)\n",
    "    h0 = {}\n",
    "    h1 = {}\n",
    "    h2 = {}\n",
    "    can.cd()\n",
    "    scale=False\n",
    "       \n",
    "    if m!=\"all\":\n",
    "        leg.SetHeader(\"First CSC cluster in \"+m+\" L1/HLT plateau\")\n",
    "        lab = \"_\"+m\n",
    "    else:\n",
    "        leg.SetHeader(\"First CSC cluster in L1/HLT plateau\")\n",
    "        lab = \"\"\n",
    "        \n",
    "    for k in tree_keys:\n",
    "        cut = dict_ME[m][k]\n",
    "        h1[k] = create_TH1D(cscClusterTime[k][ cut ][:,1].flatten(),title=\"\",axis_title = ['Cluster time','Events'], binning=[100,-100,150])\n",
    "        h1[k].SetLineColor(2)\n",
    "        h1[k].SetLineWidth(2)\n",
    "        h1[k].SetMarkerColor(2)\n",
    "        h1[k].SetMarkerStyle(20)\n",
    "        h1[k].SetMarkerSize(1.2)\n",
    "        if scale and h1[k].Integral()>0:h1[k].Scale(1./h1[k].Integral())\n",
    "        \n",
    "        h0[k] = create_TH1D(cscClusterTime[k][ cut ][:,0].flatten(),title=\"\",axis_title = ['Cluster time','Events'], binning=[100,-100,150])\n",
    "        h0[k].SetLineColor(1)\n",
    "        h0[k].SetLineWidth(2)\n",
    "        h0[k].SetMarkerColor(1)\n",
    "        h0[k].SetMarkerStyle(20)\n",
    "        h0[k].SetMarkerSize(1.2)\n",
    "        if scale and h0[k].Integral()>0:h0[k].Scale(1./h0[k].Integral())            \n",
    "        if 'data' in k:\n",
    "            h0[k].Draw('PE same')\n",
    "            h1[k].Draw('PE same')\n",
    "            leg.AddEntry(h0[k],\"1st CSC data\",\"PE\")\n",
    "            leg.AddEntry(h1[k],\"2nd CSC data\",\"PE\")\n",
    "        else:\n",
    "            h0[k].Draw('HISTO same')\n",
    "            h1[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h0[k],\"1st CSC signal\",\"L\")\n",
    "            leg.AddEntry(h1[k],\"2nd CSC signal\",\"L\")\n",
    "\n",
    "    leg.Draw()\n",
    "    can.SetRightMargin(0.05)\n",
    "    drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.96,top_marg_lumi=0.965)\n",
    "\n",
    "    # if setlog: \n",
    "    can.SetLogy()\n",
    "    can.Draw()\n",
    "    can.Print(\"plots/V1p19_\"+vers+\"/CscCscTime_in_plateau\"+lab+plot_string+\".pdf\")\n",
    "    can.Print(\"plots/V1p19_\"+vers+\"/CscCscTime_in_plateau\"+lab+plot_string+\".png\")\n",
    "    can.Close()        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f19059a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bcdf59db",
   "metadata": {},
   "source": [
    "* Check if HLT bit is correct\n",
    "* Split in different CSC categories --> there are kinks..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8830b46",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cea40991",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "run3",
   "language": "python",
   "name": "run3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}