bkg_levels_CSC_DT_v2.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",
    "from scipy.stats import norm\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": "2b61ffff",
   "metadata": {},
   "source": [
    "## Load ntuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1e98fbbb",
   "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_Pedro_newDNN_skim'\n",
    "#vers = 'v6_Pedro_newDNN'\n",
    "\n",
    "data_label = {}\n",
    "\n",
    "data_path = '/nfs/dust/cms/group/cms-llp/muon_system_run3/'+tag+'/Data'+str(data_year)+'/'+vers+'/'\n",
    "#plot_folder = \"v6_ME1_newDNN_skim\"\n",
    "plot_folder = \"v6_ME1_newDNN\"\n",
    "lumi = 23.02*1000\n",
    "xsec = 48.\n",
    "\n",
    "if data_year == 2022:\n",
    "    fpath['data'] = data_path + 'data.root'#'DisplacedJet-EXOCSCCluster_Run2022EFG-PromptReco-v1_goodLumi.root'\n",
    "    fpath['signal'] = data_path + 'mc.root'#'ggH_HToSSTobbbb_MH-125_MS-15_CTau1000_13p6TeV_1pb_weighted.root'\n",
    "    data_label['data'] = 'Data'\n",
    "    data_label['signal'] = 'Signal'\n",
    "    \n",
    "NEvents = {}\n",
    "for k,v in fpath.items():\n",
    "    root_dir = uproot.open(v)\n",
    "    tree[k] = root_dir['MuonSystem']    \n",
    "    #Hardcoded!!! Branch currently missing!!\n",
    "    NEvents[k] = root_dir['NEvents'][1]   \n",
    "    data_weight = np.zeros(100)\n",
    "    signal_gen_weight = np.zeros(100)\n",
    "    if k=='signal':\n",
    "        #This has some selections applied... not sure it's a good denominator...\n",
    "        signal_gen_weight = tree[k][\"weight\"].array()\n",
    "    else:\n",
    "        data_weight = tree[k][\"weight\"].array()\n",
    "\n",
    "        \n",
    "#Hardcoded!!! Branch currently missing!!\n",
    "signal_gen_yield = np.sum(signal_gen_weight)*lumi/NEvents['signal']*48.58\n",
    "data_all_yield = np.sum(data_weight)\n",
    "\n",
    "#print(signal_gen_weight.sum()*lumi)\n",
    "#print(signal_gen_weight.sum()*lumi/NEvents['signal']*48.58)\n",
    "\n",
    "for k, T in tree.items():\n",
    "    branch_names = T.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35a82e5c",
   "metadata": {},
   "source": [
    "## Load variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "058dfe0f",
   "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",
    "all_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",
    "sel_ev_post = {}\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",
    "cscClusterNStation = {}\n",
    "cscClusterAvgStation = {}\n",
    "cscClusterMaxStation = {}\n",
    "cscClusterDphi = {}\n",
    "cscClusterDNN = {}\n",
    "\n",
    "tr_cscClusterMuonVetoPt = {}\n",
    "tr_cscClusterJetVetoPt = {}\n",
    "tr_cscClusterPhi = {}\n",
    "tr_cscClusterEta = {}\n",
    "tr_cscClusterEta2 = {}\n",
    "tr_cscClusterEta3 = {}\n",
    "tr_cscClusterR = {}\n",
    "tr_cscClusterZ = {}\n",
    "tr_cscClusterSize = {}\n",
    "tr_cscClusterSize2 = {}\n",
    "tr_cscClusterSize3 = {}\n",
    "tr_cscClusterTimeSpread = {}\n",
    "tr_cscClusterTime = {}\n",
    "tr_cscClusterTime2 = {}\n",
    "tr_cscClusterTime3 = {}\n",
    "tr_cscClusterMet_dPhi = {}\n",
    "tr_cscClusterNStation = {}\n",
    "tr_cscClusterAvgStation = {}\n",
    "tr_cscClusterMaxStation = {}\n",
    "tr_cscClusterDphi = {}\n",
    "tr_cscClusterDNN = {}\n",
    "\n",
    "nCscClusters = {}\n",
    "\n",
    "#cscClusterNRechitMinus11 = {}\n",
    "#cscClusterNRechitPlus11 = {}\n",
    "#cscClusterNRechitMinus12 = {}\n",
    "#cscClusterNRechitPlus12 = {}\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",
    "dtClusterDNN = {}\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",
    "ME11_veto = {}\n",
    "ME12_veto = {}\n",
    "ME1_veto = {}\n",
    "MB1_veto = {}\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",
    "#L1 plateau - global, non positional\n",
    "cl_in_ME11 = {}\n",
    "cl_in_ME12 = {}\n",
    "cl_in_ME13 = {}\n",
    "cl_in_ME21 = {}\n",
    "cl_in_ME22 = {}\n",
    "cl_in_ME31 = {}\n",
    "cl_in_ME32 = {}\n",
    "cl_in_ME41 = {}\n",
    "cl_in_ME42 = {}\n",
    "\n",
    "cl_in_plateau_ME11 = {}\n",
    "cl_in_plateau_ME12 = {}\n",
    "cl_in_plateau_ME13 = {}\n",
    "cl_in_plateau_ME21 = {}\n",
    "cl_in_plateau_ME22 = {}\n",
    "cl_in_plateau_ME31 = {}\n",
    "cl_in_plateau_ME32 = {}\n",
    "cl_in_plateau_ME41 = {}\n",
    "cl_in_plateau_ME42 = {}\n",
    "cl_in_plateau = {}\n",
    "\n",
    "\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": "cf9657ba",
   "metadata": {},
   "source": [
    "## Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d1a22f21",
   "metadata": {},
   "outputs": [],
   "source": [
    "category = 0#-1#0\n",
    "category = 2\n",
    "#-1: at least 1csc\n",
    "#0: exactly 1 csc\n",
    "#1: 2csc,\n",
    "#2: 1csc+1dt, \n",
    "\n",
    "do_jet_veto = True\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 = True\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 = True\n",
    "do_csc_in_time_cut = True\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 = \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a9ec00bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "data\n",
      "n_at_least_1_cluster[k]:  3212559.0\n",
      "n_at_least_2_cluster[k]:  2408687.0\n",
      "n_at_least_1_dt_cluster[k]:  1010755.0\n",
      "start awkward\n",
      "done!\n",
      "\n",
      "\n",
      "signal\n",
      "n_at_least_1_cluster[k]:  1746070.6\n",
      "n_at_least_2_cluster[k]:  619905.1\n",
      "n_at_least_1_dt_cluster[k]:  1980101.6\n",
      "start awkward\n",
      "done!\n"
     ]
    }
   ],
   "source": [
    "n_1CSC = {}\n",
    "n_2CSC = {}\n",
    "n_1DT = {}\n",
    "\n",
    "n_1CSC_ME1 = {}\n",
    "n_1CSC_ME1_old = {}\n",
    "n_2CSC_ME1 = {}\n",
    "n_2CSC_ME1_old = {}\n",
    "\n",
    "n_1CSC_ME1_plateau = {}\n",
    "n_2CSC_ME1_plateau = {}\n",
    "\n",
    "n_1CSC_ME1_plateau_0lep = {}\n",
    "n_2CSC_ME1_plateau_0lep = {}\n",
    "\n",
    "n_2CSC_ME1_plateau_0lep_hlt = {}\n",
    "n_2CSC_ME1_plateau_0lep_hlt_dphi = {}\n",
    "\n",
    "for k, T in tree.items():\n",
    "    \n",
    "    print(\"\\n\")\n",
    "    print(k)\n",
    "    tree_keys.append(k)\n",
    "    \n",
    "    #If needed to look at a smaller number of events:\n",
    "    ev_num = (T.array('evtNum')>-1)\n",
    "    #ev_num = (T.array('evtNum')<5000)\n",
    "    \n",
    "    pre_sel_csccluster = (T.array('cscRechitClusterSize') >= 0)[ev_num]\n",
    "    n_pre_cl = pre_sel_csccluster.sum()\n",
    "\n",
    "    pre_sel_dtcluster = (T.array('dtRechitClusterSize') >= 0)[ev_num]\n",
    "    n_pre_dtcl = pre_sel_dtcluster.sum()\n",
    "    \n",
    "   \n",
    "    n_1CSC[k] = T.array('weight')[ev_num][n_pre_cl>0].sum()\n",
    "    print(\"n_at_least_1_cluster[k]: \", n_1CSC[k])\n",
    "    n_2CSC[k] = T.array('weight')[ev_num][n_pre_cl>1].sum()\n",
    "    print(\"n_at_least_2_cluster[k]: \", n_2CSC[k])\n",
    "    n_1DT[k] = T.array('weight')[ev_num][n_pre_dtcl>0].sum()\n",
    "    print(\"n_at_least_1_dt_cluster[k]: \", n_1DT[k])\n",
    "    \n",
    "    ###############################################\n",
    "    #ME1 veto and L1/HLT plateau on trigger cluster\n",
    "    ME11_veto[k] = np.logical_and(\n",
    "        T.array('cscRechitCluster' + cluster_index + 'NRechitChamberMinus11')[ev_num]==0  ,\n",
    "        T.array('cscRechitCluster' + cluster_index + 'NRechitChamberPlus11')[ev_num]==0\n",
    "    )  \n",
    "\n",
    "    ME12_veto[k] = np.logical_and(\n",
    "        T.array('cscRechitCluster' + cluster_index + 'NRechitChamberMinus12')[ev_num]==0  ,\n",
    "        T.array('cscRechitCluster' + cluster_index + 'NRechitChamberPlus12')[ev_num]==0\n",
    "    )      \n",
    "\n",
    "    ME1_veto[k] = ( ME11_veto[k] & ME12_veto[k] )\n",
    "        \n",
    "    #ME1_veto applied to all clusters\n",
    "    sel_csccluster_me1 = np.logical_and(pre_sel_csccluster,\n",
    "                                    np.logical_and(ME11_veto[k],ME12_veto[k])\n",
    "                                   )\n",
    "    \n",
    "    n_me1_cl = sel_csccluster_me1.sum()\n",
    "    \n",
    "    n_1CSC_ME1_old[k] = T.array('weight')[ev_num][n_me1_cl>0].sum()\n",
    "    n_2CSC_ME1_old[k] = T.array('weight')[ev_num][n_me1_cl>1].sum()\n",
    "        \n",
    "    #tmp variables to identify trigger cluster\n",
    "    tmp_cscClusterR = np.sqrt(  T.array('cscRechitCluster' + cluster_index + 'X')[ev_num][:,:]**2 + T.array('cscRechitCluster' + cluster_index + 'Y')[ev_num][:,:]**2 )\n",
    "    tmp_cscClusterZ = T.array('cscRechitCluster' + cluster_index + 'Z')[ev_num][:,:]\n",
    "    tmp_cscClusterSize =  T.array('cscRechitCluster' + cluster_index + 'Size')[ev_num][:,:]\n",
    "    \n",
    "    cl_in_ME11[k] = (tmp_cscClusterR>100)&(tmp_cscClusterR<275) &(abs(tmp_cscClusterZ)>580)&(abs(tmp_cscClusterZ)<632) \n",
    "    cl_in_ME12[k] = (tmp_cscClusterR>275)&(tmp_cscClusterR<465) &(abs(tmp_cscClusterZ)>668)&(abs(tmp_cscClusterZ)<724)\n",
    "    cl_in_ME13[k] = (tmp_cscClusterR>505)&(tmp_cscClusterR<700) &(abs(tmp_cscClusterZ)>668)&(abs(tmp_cscClusterZ)<724)\n",
    "\n",
    "    cl_in_ME21[k] = (tmp_cscClusterR>139)&(tmp_cscClusterR<345) &(abs(tmp_cscClusterZ)>789)&(abs(tmp_cscClusterZ)<850)\n",
    "    cl_in_ME22[k] = (tmp_cscClusterR>357)&(tmp_cscClusterR<700) &(abs(tmp_cscClusterZ)>791)&(abs(tmp_cscClusterZ)<850)\n",
    "\n",
    "    cl_in_ME31[k] = (tmp_cscClusterR>160)&(tmp_cscClusterR<345) &(abs(tmp_cscClusterZ)>915)&(abs(tmp_cscClusterZ)<970)\n",
    "    cl_in_ME32[k] = (tmp_cscClusterR>357)&(tmp_cscClusterR<700) &(abs(tmp_cscClusterZ)>911)&(abs(tmp_cscClusterZ)<970)\n",
    "\n",
    "    cl_in_ME41[k] = (tmp_cscClusterR>178)&(tmp_cscClusterR<345) &(abs(tmp_cscClusterZ)>1002)&(abs(tmp_cscClusterZ)<1063)\n",
    "    cl_in_ME42[k] = (tmp_cscClusterR>357)&(tmp_cscClusterR<700) &(abs(tmp_cscClusterZ)>1002)&(abs(tmp_cscClusterZ)<1063)\n",
    "    \n",
    "    cl_in_plateau_ME11[k] = cl_in_ME11[k] & (tmp_cscClusterSize>=500)\n",
    "    cl_in_plateau_ME21[k] = cl_in_ME21[k] & (tmp_cscClusterSize>=500)\n",
    "    cl_in_plateau_ME31[k] = cl_in_ME31[k] & (tmp_cscClusterSize>=500)\n",
    "    cl_in_plateau_ME41[k] = cl_in_ME41[k] & (tmp_cscClusterSize>=500)\n",
    "\n",
    "    cl_in_plateau_ME12[k] = cl_in_ME12[k] & (tmp_cscClusterSize>=200)\n",
    "    cl_in_plateau_ME13[k] = cl_in_ME13[k] & (tmp_cscClusterSize>=200)\n",
    "    cl_in_plateau_ME22[k] = cl_in_ME22[k] & (tmp_cscClusterSize>=200)\n",
    "    cl_in_plateau_ME32[k] = cl_in_ME32[k] & (tmp_cscClusterSize>=200)\n",
    "    cl_in_plateau_ME42[k] = cl_in_ME42[k] & (tmp_cscClusterSize>=200)    \n",
    "    \n",
    "    cl_in_plateau[k] = cl_in_plateau_ME11[k] | cl_in_plateau_ME12[k] | cl_in_plateau_ME13[k] | cl_in_plateau_ME21[k] | cl_in_plateau_ME22[k] | cl_in_plateau_ME31[k] | cl_in_plateau_ME32[k] | cl_in_plateau_ME41[k] | cl_in_plateau_ME42[k]\n",
    "\n",
    "    #event level selection: at least 1 cluster fulfilling the condition\n",
    "    sel_ev_me1 = (ME1_veto[k]).any()==True\n",
    "    sel_ev_me1_pl = (ME1_veto[k] & cl_in_plateau[k]).any()==True\n",
    "    \n",
    "    #now counting the clusters\n",
    "    sel_csccluster_me1 = sel_csccluster_me1  & sel_ev_me1\n",
    "    sel_csccluster_me1_pl = sel_csccluster_me1  & sel_ev_me1_pl\n",
    "    \n",
    "    n_cl_me1 = sel_csccluster_me1.sum()\n",
    "    n_cl_me1_pl = sel_csccluster_me1_pl.sum()    \n",
    "   \n",
    "    n_1CSC_ME1[k] = T.array('weight')[ev_num][n_cl_me1>0].sum()\n",
    "    n_2CSC_ME1[k] = T.array('weight')[ev_num][n_cl_me1>1].sum()\n",
    "    \n",
    "    n_1CSC_ME1_plateau[k] = T.array('weight')[ev_num][n_cl_me1_pl>0].sum()\n",
    "    n_2CSC_ME1_plateau[k] = T.array('weight')[ev_num][n_cl_me1_pl>1].sum()    \n",
    "    #From now: ask at least 1 cluster!\n",
    "    \n",
    "    #Remove trigger clusters\n",
    "    tr_cluster_mask = (ME1_veto[k] & cl_in_plateau[k] )#[ n_new_cl_me1_pl>1 ]\n",
    "    #no cuts on multiplicity will raise exceptions here\n",
    "    tag_tr_cluster = tmp_cscClusterSize[ tr_cluster_mask==True ][ n_cl_me1_pl>0 ][:,0]\n",
    "    new_tmp_cscClusterSize = tmp_cscClusterSize[ n_cl_me1_pl>0 ]\n",
    "    tag_tr_cluster_mask = (new_tmp_cscClusterSize == tag_tr_cluster)\n",
    "\n",
    "    sel_csccluster = sel_csccluster_me1_pl[ n_cl_me1_pl>0 ] & (tag_tr_cluster_mask==False)\n",
    "    sel_tr_csccluster = sel_csccluster_me1_pl[ n_cl_me1_pl>0 ] & (tag_tr_cluster_mask==True)\n",
    "    \n",
    "    \n",
    "    MB1_veto[k] = T.array('dtRechitClusterNHitStation1') == 0\n",
    "    \n",
    "\n",
    "    sel_dtcluster = pre_sel_dtcluster[ n_cl_me1_pl>0 ]\n",
    "    if do_MB_veto:\n",
    "        sel_dtcluster = np.logical_and(sel_dtcluster, MB1_veto[k][ n_cl_me1_pl>0 ])\n",
    "    ####### Selections only to non-trigger clusters\n",
    "\n",
    "    ### Jet and muon veto\n",
    "    jet_veto_csc = T.array('cscRechitCluster' + cluster_index + 'JetVetoPt')[ev_num][ n_cl_me1_pl>0 ]<30\n",
    "    muon_veto_csc = np.logical_not(\n",
    "        np.logical_and(T.array('cscRechitClusterMuonVetoPt')[ev_num][ n_cl_me1_pl>0 ] >= 30, \n",
    "                       T.array('cscRechitClusterMuonVetoGlobal')[ev_num][ n_cl_me1_pl>0 ])\n",
    "    )\n",
    "\n",
    "    jet_veto_dt = np.abs(T.array('dtRechitClusterJetVetoPt'))[ev_num] < 50\n",
    "    muon_veto_dt = np.logical_not(np.logical_and(T.array('dtRechitClusterMuonVetoPt')[ev_num] >= 10, T.array('dtRechitClusterMuonVetoLooseId')[ev_num]))\n",
    "\n",
    "    if do_muon_veto:\n",
    "        sel_dtcluster = np.logical_and(sel_dtcluster, muon_veto_dt[ n_cl_me1_pl>0 ])\n",
    "    if do_jet_veto:\n",
    "        sel_dtcluster = np.logical_and(sel_dtcluster, jet_veto_dt[ n_cl_me1_pl>0 ])\n",
    "    \n",
    "    if do_jet_veto:\n",
    "        sel_csccluster = sel_csccluster & jet_veto_csc\n",
    "    if do_muon_veto:\n",
    "        sel_csccluster = sel_csccluster & muon_veto_csc\n",
    "\n",
    "    ### Time spread cut\n",
    "    if do_csc_time_spread_cut:\n",
    "        #Run2:\n",
    "        sel_csccluster = np.logical_and(\n",
    "            sel_csccluster, \n",
    "            T.array('cscRechitCluster' + cluster_index + 'TimeSpreadWeightedAll')[ev_num][ n_cl_me1_pl>0 ]<20)\n",
    "        #sel_csccluster = np.logical_and(sel_csccluster, T.array('cscRechitCluster' + cluster_index + 'TimeSpreadWeightedAll')[ev_num][ n_cl_me1_pl>0 ]<30)\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')[ev_num][ n_cl_me1_pl>0 ]< 12.5, \n",
    "            T.array('cscRechitCluster' + cluster_index + 'TimeWeighted')[ev_num][ n_cl_me1_pl>0 ] > -5))    \n",
    "        \n",
    "        \n",
    "        \n",
    "    sel_ev_0lep = (T.array('nLeptons')[ev_num][ n_cl_me1_pl>0 ] == 0)\n",
    "    sel_ev[k] = sel_ev_0lep\n",
    "\n",
    "    n_1CSC_ME1_plateau_0lep[k] = T.array('weight')[ev_num][ n_cl_me1_pl>0 ][sel_ev_0lep].sum()\n",
    "\n",
    "    ########### SELECTION: EVENTS ############\n",
    "    hlt = T['HLTDecision'].array()[ev_num][ n_cl_me1_pl>0 ]    \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",
    "    n_2CSC_ME1_plateau_0lep[k] = T.array('weight')[ev_num][ n_cl_me1_pl>1][ (T.array('nLeptons')[ev_num][ n_cl_me1_pl>1 ] == 0) ].sum()   \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",
    "    if k == 'data': \n",
    "        sel_ev[k] = np.logical_and(sel_ev[k],hlt_sel_ev[k])\n",
    "    if k == 'data': \n",
    "        sel_ev[k] = np.logical_and(sel_ev[k], (T.array('runNum')[ev_num][ n_cl_me1_pl>0 ] >=360019))\n",
    "\n",
    "    \n",
    "    if category == 1:\n",
    "        #sel_csccluster includes ONLY the non trigger clusters!!!\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 == 2:\n",
    "        #sel_csccluster includes ONLY the non trigger clusters!!!\n",
    "        sel_ev[k]  = np.logical_and(sel_ev[k],sel_csccluster.sum() >= 0)\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",
    "    n_2CSC_ME1_plateau_0lep_hlt[k] = T.array('weight')[ev_num][ n_cl_me1_pl>0 ][ sel_ev[k] ].sum()\n",
    "    \n",
    "        \n",
    "    ########### BRANCHES ############    \n",
    "    \n",
    "    sel_dtcluster = sel_dtcluster & sel_ev[k]\n",
    "    sel_csccluster = sel_csccluster & sel_ev[k]\n",
    "    sel_tr_csccluster = sel_tr_csccluster & sel_ev[k]\n",
    "       \n",
    "    #dtClusterMuonVetoPt[k] = T.array('dtRechitClusterMuonVetoPt')[ev_num][sel_dtcluster][ sel_ev[k] ]\n",
    "    #dtClusterJetVetoPt[k] = T.array('dtRechitClusterJetVetoPt')[ev_num][sel_dtcluster][ sel_ev[k] ]\n",
    "    dtClusterPhi[k] = T.array('dtRechitClusterPhi')[ev_num][ n_cl_me1_pl>0 ][sel_dtcluster][ sel_ev[k] ]\n",
    "    dtClusterEta[k] = T.array('dtRechitClusterEta')[ev_num][ n_cl_me1_pl>0 ][sel_dtcluster][ sel_ev[k] ]\n",
    "    dtClusterSize[k] =  T.array('dtRechitClusterSize')[ev_num][ n_cl_me1_pl>0 ][sel_dtcluster][ sel_ev[k] ]\n",
    "    dtClusterTime[k] =  T.array('dtRechitCluster_match_RPCBx_dPhi0p5')[ev_num][ n_cl_me1_pl>0 ][sel_dtcluster][ sel_ev[k] ]\n",
    "    dtClusterNStation[k] =  T.array('dtRechitClusterNStation10')[ev_num][ n_cl_me1_pl>0 ][sel_dtcluster][ sel_ev[k] ]\n",
    "    dtClusterNHitStation1[k] = T.array('dtRechitClusterNHitStation1')[ev_num][ n_cl_me1_pl>0 ][sel_dtcluster][ sel_ev[k] ]\n",
    "    dtCluster_match_MB1hits_0p4[k] = T.array('dtRechitCluster_match_MB1hits_0p4')[ev_num][ n_cl_me1_pl>0 ][sel_dtcluster][ sel_ev[k] ]\n",
    "    dtCluster_match_MB1hits_0p5[k] = T.array('dtRechitCluster_match_MB1hits_0p5')[ev_num][ n_cl_me1_pl>0 ][sel_dtcluster][ sel_ev[k] ]\n",
    "    dtClusterMet_dPhi[k] =  T.array('dtRechitCluster' + cluster_index + 'Met_dPhi')[ev_num][ n_cl_me1_pl>0 ][sel_dtcluster][ sel_ev[k] ]\n",
    "    dtClusterMaxStationRatio[k] = T.array('dtRechitCluster' + cluster_index + 'MaxStationRatio')[ev_num][ n_cl_me1_pl>0 ][sel_dtcluster][ sel_ev[k] ]\n",
    "        \n",
    "    #cscClusterMuonVetoPt[k] = T.array('cscRechitCluster' + cluster_index + 'MuonVetoPt')[sel_ev_tmp][sel_csccluster][ sel_ev[k] ]\n",
    "    #cscClusterJetVetoPt[k] = T.array('cscRechitCluster' + cluster_index + 'JetVetoPt')[sel_ev_tmp][sel_csccluster][ sel_ev[k] ]\n",
    "    cscClusterPhi[k] = T.array('cscRechitCluster' + cluster_index + 'Phi')[ev_num][ n_cl_me1_pl>0 ][sel_csccluster][ sel_ev[k] ]\n",
    "    cscClusterEta[k] = T.array('cscRechitCluster' + cluster_index + 'Eta')[ev_num][ n_cl_me1_pl>0 ][sel_csccluster][ sel_ev[k] ]\n",
    "    cscClusterR[k] = np.sqrt(  T.array('cscRechitCluster' + cluster_index + 'X')[ev_num][ n_cl_me1_pl>0 ][sel_csccluster]**2 + T.array('cscRechitCluster' + cluster_index + 'Y')[ev_num][ n_cl_me1_pl>0 ][sel_csccluster]**2 )[ sel_ev[k] ]\n",
    "    cscClusterZ[k] = T.array('cscRechitCluster' + cluster_index + 'Z')[ev_num][ n_cl_me1_pl>0 ][sel_csccluster][ sel_ev[k] ]\n",
    "    cscClusterSize[k] =  T.array('cscRechitCluster' + cluster_index + 'Size')[ev_num][ n_cl_me1_pl>0 ][sel_csccluster][ sel_ev[k] ]\n",
    "    cscClusterTime[k] =  T.array('cscRechitCluster' + cluster_index + 'TimeWeighted')[ev_num][ n_cl_me1_pl>0 ][sel_csccluster][ sel_ev[k] ]\n",
    "    cscClusterTimeSpread[k] =  T.array('cscRechitCluster' + cluster_index + 'TimeSpreadWeightedAll')[ev_num][ n_cl_me1_pl>0 ][sel_csccluster][ sel_ev[k] ]\n",
    "    cscClusterNStation[k] =  T.array('cscRechitCluster' + cluster_index + 'NStation10')[ev_num][ n_cl_me1_pl>0 ][sel_csccluster][ sel_ev[k] ]\n",
    "    cscClusterAvgStation[k] =  T.array('cscRechitCluster' + cluster_index + 'AvgStation10')[ev_num][ n_cl_me1_pl>0 ][sel_csccluster][ sel_ev[k] ]\n",
    "    cscClusterMaxStation[k] =  T.array('cscRechitCluster' + cluster_index + 'MaxStation')[ev_num][ n_cl_me1_pl>0 ][sel_csccluster][ sel_ev[k] ]\n",
    "    cscClusterMet_dPhi[k] =  T.array('cscRechitCluster' + cluster_index + 'Met_dPhi')[ev_num][ n_cl_me1_pl>0 ][sel_csccluster][ sel_ev[k] ]\n",
    "    \n",
    "    #convert numpy.darrays to awkward\n",
    "    print(\"start awkward\")\n",
    "    #pre_DNN_padded = awkward.fromiter(T.array('cscRechitCluster' + cluster_index + 'DNN')[ev_num][ n_new_cl_me1_pl>0 ])\n",
    "    pre_DNN_padded_csc = awkward.JaggedArray.fromregular(T.array('cscRechitCluster' + cluster_index + 'DNN')[ev_num][ n_cl_me1_pl>0 ])\n",
    "    pre_DNN_padded_dt = awkward.JaggedArray.fromregular(T.array('dtRechitCluster' + cluster_index + 'DNN')[ev_num][ n_cl_me1_pl>0 ])\n",
    "    \n",
    "    #mask invalid DNN scores of zero padded stuff\n",
    "    print(\"done!\")\n",
    "    pre_DNN_padded_mask_csc = pre_DNN_padded_csc > -.999\n",
    "    DNN_padded_csc = pre_DNN_padded_csc[pre_DNN_padded_mask_csc]\n",
    "    pre_DNN_padded_mask_dt = pre_DNN_padded_dt > -.999\n",
    "    DNN_padded_dt = pre_DNN_padded_dt[pre_DNN_padded_mask_dt]\n",
    "    \n",
    "    #apply selections\n",
    "    dtClusterDNN[k] = DNN_padded_dt[sel_dtcluster][ sel_ev[k] ]\n",
    "    \n",
    "    cscClusterDNN[k] = DNN_padded_csc[sel_csccluster][ sel_ev[k] ]\n",
    "    nCscClusters[k] = sel_csccluster[ sel_ev[k] ].sum()#[sel_ev[k]]\n",
    "    \n",
    "    tr_cscClusterPhi[k] = T.array('cscRechitCluster' + cluster_index + 'Phi')[ev_num][ n_cl_me1_pl>0 ][sel_tr_csccluster][ sel_ev[k] ]\n",
    "    tr_cscClusterEta[k] = T.array('cscRechitCluster' + cluster_index + 'Eta')[ev_num][ n_cl_me1_pl>0 ][sel_tr_csccluster][ sel_ev[k] ]\n",
    "    tr_cscClusterR[k] = np.sqrt(  T.array('cscRechitCluster' + cluster_index + 'X')[ev_num][ n_cl_me1_pl>0 ][sel_tr_csccluster]**2 + T.array('cscRechitCluster' + cluster_index + 'Y')[ev_num][ n_cl_me1_pl>0 ][sel_tr_csccluster]**2 )[ sel_ev[k] ]\n",
    "    tr_cscClusterZ[k] = T.array('cscRechitCluster' + cluster_index + 'Z')[ev_num][ n_cl_me1_pl>0 ][sel_tr_csccluster][ sel_ev[k] ]\n",
    "    tr_cscClusterSize[k] =  T.array('cscRechitCluster' + cluster_index + 'Size')[ev_num][ n_cl_me1_pl>0 ][sel_tr_csccluster][ sel_ev[k] ]\n",
    "    tr_cscClusterTime[k] =  T.array('cscRechitCluster' + cluster_index + 'TimeWeighted')[ev_num][ n_cl_me1_pl>0 ][sel_tr_csccluster][ sel_ev[k] ]\n",
    "    tr_cscClusterTimeSpread[k] =  T.array('cscRechitCluster' + cluster_index + 'TimeSpreadWeightedAll')[ev_num][ n_cl_me1_pl>0 ][sel_tr_csccluster][ sel_ev[k] ]\n",
    "    tr_cscClusterNStation[k] =  T.array('cscRechitCluster' + cluster_index + 'NStation10')[ev_num][ n_cl_me1_pl>0 ][sel_tr_csccluster][ sel_ev[k] ]\n",
    "    tr_cscClusterAvgStation[k] =  T.array('cscRechitCluster' + cluster_index + 'AvgStation10')[ev_num][ n_cl_me1_pl>0 ][sel_tr_csccluster][ sel_ev[k] ]\n",
    "    tr_cscClusterMaxStation[k] =  T.array('cscRechitCluster' + cluster_index + 'MaxStation')[ev_num][ n_cl_me1_pl>0 ][sel_tr_csccluster][ sel_ev[k] ]\n",
    "    tr_cscClusterMet_dPhi[k] =  T.array('cscRechitCluster' + cluster_index + 'Met_dPhi')[ev_num][ n_cl_me1_pl>0 ][sel_tr_csccluster][ sel_ev[k] ]\n",
    "    tr_cscClusterDNN[k] = DNN_padded_csc[sel_tr_csccluster][ sel_ev[k] ]    \n",
    "    \n",
    "    weight[k] = T.array('weight')[ev_num][ n_cl_me1_pl>0 ][ sel_ev[k] ]  \n",
    "    all_weight[k] = T.array('weight')\n",
    "    \n",
    "    if category==1:\n",
    "        dPhi_csc_csc[k] = ( deltaPhi(  cscClusterPhi[k][:,0].flatten(), tr_cscClusterPhi[k][:,0].flatten() ) )\n",
    "        dEta_csc_csc[k] = (  cscClusterEta[k][:,0].flatten() - tr_cscClusterEta[k][:,0].flatten() )\n",
    "        dR_csc_csc[k]   = deltaR( cscClusterEta[k][:,0].flatten(), cscClusterPhi[k][:,0].flatten(), tr_cscClusterEta[k][:,0].flatten(), tr_cscClusterPhi[k][:,0].flatten() )\n",
    "        dt_csc_csc[k]   = (  cscClusterTime[k][:,0].flatten() - tr_cscClusterTime[k][:,0].flatten() )\n",
    "        n_2CSC_ME1_plateau_0lep_hlt_dphi[k] = T.array('weight')[ev_num][ n_cl_me1_pl>0 ][ sel_ev[k]][(  np.abs(dPhi_csc_csc[k])>1.8 ) ].sum()   \n",
    "    if category==2:        \n",
    "        dPhi_csc_dt[k] = ( deltaPhi(  dtClusterPhi[k][:,0].flatten(), tr_cscClusterPhi[k][:,0].flatten() ) )\n",
    "        dEta_csc_dt[k] = (  dtClusterEta[k][:,0].flatten() - tr_cscClusterEta[k][:,0].flatten() )\n",
    "        dR_csc_dt[k] =  deltaR( dtClusterEta[k][:,0].flatten(), dtClusterPhi[k][:,0].flatten(), tr_cscClusterEta[k][:,0].flatten(), tr_cscClusterPhi[k][:,0].flatten() )   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fa51702d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.0957105 3.0489295 3.0390828 ... 3.102813  1.4574707 3.074588 ]\n"
     ]
    }
   ],
   "source": [
    "print(dPhi_csc_dt['signal'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c19776b",
   "metadata": {},
   "source": [
    "### Does the dPhi minimum cut change the slope of the DT size distribution?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "13a95cd4",
   "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",
      "/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",
      "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.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",
    "h4 = {}\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",
    "        if k=='data':\n",
    "            #Select OOT DT clusters to avoid unblinding\n",
    "            #cut = (dtClusterTime[k][:,0].flatten()!=-999999)#!=0)\n",
    "            cut = (dtClusterTime[k][:,0].flatten()==0)\n",
    "        if k=='signal':\n",
    "            cut = (dtClusterTime[k][:,0].flatten()!=-999999)\n",
    "            \n",
    "        dphi_var_sel = np.abs(dPhi_csc_dt[k][cut])\n",
    "        bins = [20,50,450]\n",
    "        h0[k] = create_TH1D( dtClusterSize[k][cut][:,0],title=\"\",axis_title = ['DT cluster size','Events'], binning=bins)\n",
    "        h0[k].SetLineColor(2)\n",
    "        h0[k].SetLineWidth(2)\n",
    "        h0[k].SetMarkerColor(2)\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",
    "        h1[k] = create_TH1D( dtClusterSize[k][cut][dphi_var_sel>0.4][:,0],title=\"\",axis_title = ['DT cluster size','Events'], binning=bins)\n",
    "        h1[k].SetLineColor(1)\n",
    "        h1[k].SetLineWidth(2)\n",
    "        h1[k].SetMarkerColor(1)\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( dtClusterSize[k][cut][dphi_var_sel>0.8][:,0],title=\"\",axis_title = ['DT cluster size','Events'], binning=bins)\n",
    "        h2[k].SetLineColor(803)\n",
    "        h2[k].SetLineWidth(2)\n",
    "        h2[k].SetMarkerColor(803)\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( dtClusterSize[k][cut][dphi_var_sel>1.0][:,0],title=\"\",axis_title = ['DT cluster size','Events'], binning=bins)\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",
    "        h4[k] = create_TH1D( dtClusterSize[k][cut][dphi_var_sel>1.2][:,0],title=\"\",axis_title = ['DT cluster size','Events'], binning=bins)\n",
    "        h4[k].SetLineColor(8)\n",
    "        h4[k].SetLineWidth(2)\n",
    "        h4[k].SetMarkerColor(8)\n",
    "        h4[k].SetMarkerStyle(20)\n",
    "        h4[k].SetMarkerSize(1.2)\n",
    "        if scale and h4[k].Integral()>0:h4[k].Scale(1./h4[k].Integral())\n",
    "            \n",
    "        if not scale:\n",
    "            h0[k].SetMinimum(0.8)\n",
    "            h0[k].SetMaximum(1.e5)\n",
    "        else:\n",
    "            h0[k].SetMaximum(1)\n",
    "            h0[k].SetMinimum(0.00001)\n",
    "        if 'data' in k:\n",
    "            h0[k].Draw('PE same')\n",
    "            h1[k].Draw('PE same')\n",
    "            h2[k].Draw('PE same')\n",
    "            h3[k].Draw('PE same')\n",
    "            h4[k].Draw('PE same')\n",
    "            leg.AddEntry(h0[k],\"data, DT OOT\",\"PE\")\n",
    "            leg.AddEntry(h1[k],\"+|#Delta #varphi|>0.4\",\"PE\")\n",
    "            leg.AddEntry(h2[k],\"+|#Delta #varphi|>0.8\",\"PE\")\n",
    "            leg.AddEntry(h3[k],\"+|#Delta #varphi|>1\",\"PE\")\n",
    "            leg.AddEntry(h4[k],\"+|#Delta #varphi|>1.2\",\"PE\")\n",
    "        #else:\n",
    "        #    h0[k].Draw('HISTO same')\n",
    "        #    h1[k].Draw('HISTO same')\n",
    "        #    h2[k].Draw('HISTO same')\n",
    "        #    h3[k].Draw('HISTO same')\n",
    "        #    h4[k].Draw('HISTO same')\n",
    "        #    leg.AddEntry(h0[k],\"signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\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",
    "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": 59,
   "id": "fcbe0b1e",
   "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",
      "/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",
      "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.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",
    "h4 = {}\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",
    "        if k=='data':\n",
    "            #Select OOT DT clusters to avoid unblinding\n",
    "            #cut = (dtClusterTime[k][:,0].flatten()!=-999999)#!=0)\n",
    "            cut = (dtClusterTime[k][:,0].flatten()==0)\n",
    "        if k=='signal':\n",
    "            cut = (dtClusterTime[k][:,0].flatten()!=-999999)\n",
    "            \n",
    "        dphi_var_sel = np.abs(dPhi_csc_dt[k][cut])\n",
    "        bins = [50,200,1200]\n",
    "        h0[k] = create_TH1D( tr_cscClusterSize[k][cut][:,0],title=\"\",axis_title = ['CSC cluster size','Events'], binning=bins)\n",
    "        h0[k].SetLineColor(2)\n",
    "        h0[k].SetLineWidth(2)\n",
    "        h0[k].SetMarkerColor(2)\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",
    "        h1[k] = create_TH1D( tr_cscClusterSize[k][cut][dphi_var_sel>0.4][:,0],title=\"\",axis_title = ['CSC cluster size','Events'], binning=bins)\n",
    "        h1[k].SetLineColor(1)\n",
    "        h1[k].SetLineWidth(2)\n",
    "        h1[k].SetMarkerColor(1)\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( tr_cscClusterSize[k][cut][dphi_var_sel>0.8][:,0],title=\"\",axis_title = ['CSC cluster size','Events'], binning=bins)\n",
    "        h2[k].SetLineColor(803)\n",
    "        h2[k].SetLineWidth(2)\n",
    "        h2[k].SetMarkerColor(803)\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( tr_cscClusterSize[k][cut][dphi_var_sel>1.0][:,0],title=\"\",axis_title = ['CSC cluster size','Events'], binning=bins)\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",
    "        h4[k] = create_TH1D( tr_cscClusterSize[k][cut][dphi_var_sel>1.2][:,0],title=\"\",axis_title = ['CSC cluster size','Events'], binning=bins)\n",
    "        h4[k].SetLineColor(8)\n",
    "        h4[k].SetLineWidth(2)\n",
    "        h4[k].SetMarkerColor(8)\n",
    "        h4[k].SetMarkerStyle(20)\n",
    "        h4[k].SetMarkerSize(1.2)\n",
    "        if scale and h4[k].Integral()>0:h4[k].Scale(1./h4[k].Integral())\n",
    "            \n",
    "        if not scale:\n",
    "            h0[k].SetMinimum(0.8)\n",
    "            h0[k].SetMaximum(1.e5)\n",
    "        else:\n",
    "            h0[k].SetMaximum(1)\n",
    "            h0[k].SetMinimum(0.00001)\n",
    "        if 'data' in k:\n",
    "            h0[k].Draw('PE same')\n",
    "            h1[k].Draw('PE same')\n",
    "            h2[k].Draw('PE same')\n",
    "            h3[k].Draw('PE same')\n",
    "            h4[k].Draw('PE same')\n",
    "            leg.AddEntry(h0[k],\"data, DT OOT\",\"PE\")\n",
    "            leg.AddEntry(h1[k],\"+|#Delta #varphi|>0.4\",\"PE\")\n",
    "            leg.AddEntry(h2[k],\"+|#Delta #varphi|>0.8\",\"PE\")\n",
    "            leg.AddEntry(h3[k],\"+|#Delta #varphi|>1\",\"PE\")\n",
    "            leg.AddEntry(h4[k],\"+|#Delta #varphi|>1.2\",\"PE\")\n",
    "        #else:\n",
    "        #    h0[k].Draw('HISTO same')\n",
    "        #    h1[k].Draw('HISTO same')\n",
    "        #    h2[k].Draw('HISTO same')\n",
    "        #    h3[k].Draw('HISTO same')\n",
    "        #    h4[k].Draw('HISTO same')\n",
    "        #    leg.AddEntry(h0[k],\"signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\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",
    "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": "markdown",
   "id": "f17b7ca1",
   "metadata": {},
   "source": [
    "### Angular variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "1d8e7968",
   "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",
      "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"
     ]
    },
    {
     "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",
    "        if k=='data':\n",
    "            #Select OOT DT clusters to avoid unblinding\n",
    "            #cut = (dtClusterTime[k][:,0].flatten()!=-999999)#!=0)\n",
    "            cut = (dtClusterTime[k][:,0].flatten()==0)\n",
    "        if k=='signal':\n",
    "            cut = (dtClusterTime[k][:,0].flatten()!=-999999)\n",
    "        h1[k] = create_TH1D( dtClusterEta[k][cut],title=\"\",axis_title = ['DT Cluster #eta','Events'], binning=[50,-1.4,1.4])\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",
    "        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",
    "            leg.AddEntry(h1[k],\"data, DT OOT\",\"PE\")\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h1[k],\"signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\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",
    "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": 61,
   "id": "02dc2d14",
   "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",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\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.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",
    "        if k=='data':\n",
    "            #Select OOT DT clusters to avoid unblinding\n",
    "            #cut = (dtClusterTime[k][:,0].flatten()!=-999999)#!=0)\n",
    "            cut = (dtClusterTime[k][:,0].flatten()==0)\n",
    "        if k=='signal':\n",
    "            cut = (dtClusterTime[k][:,0].flatten()!=-999999)\n",
    "        h1[k] = create_TH1D( tr_cscClusterEta[k][cut],title=\"\",axis_title = ['CSC Cluster #eta','Events'], binning=[50,-4,4])\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",
    "        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",
    "            leg.AddEntry(h1[k],\"data, DT OOT\",\"PE\")\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h1[k],\"signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\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",
    "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": 62,
   "id": "a08fbfbd",
   "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",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+QAAAMECAIAAAC5e3jEAAAABmJLR0QAAAAAAAD5Q7t/AAAgAElEQVR4nOzdTbLbxsE/6sYtT13Hnisur8Qk82Zy70IcWVrAjVwVEycZ2BuwldJWXjsk/wtJua7P3NIGjDtoCYFAEARIEGiAz1OplMyDj8YX8UOzu5EVRREAAID0/F9TFwAAAGgmrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQCAq+R5PnURWCxhHQDgcnmePz4+Tl0KFisrimLqMgAAzNJ+v99sNiEEgYob+WTqAixZnuf7/T6EcDgc4ier1Wr9QZclxNkbnV1Cy7xdZg8nyh/n7b4JtB+ImmT3anUrjgv573//u/z3n//851FK1KC9kADDWq/X5f0RbqhgaNvttsue32637cvZ7XbXzB6D9Sm73a5lve3zllarVd+dc4c67szEd2x1K2p/+uWXX8o/fffdd5MUL6ruwwmLAdyJ3W633W7Lm/7UxWGxtFkf0n6/z7KsY8O1x8fHLMsu7pJytr72ssf99Xq92Ww6zns4HK7ZhDtxwYFIcMfWfl1p/FPjXyfR8YEZ4Brr9TrP8zzPE/nqY6k0gxlM2Wqtl8fHx/1+36ulRHSLn96yLLtgros3gXaPj48JNjc6Lk/1VNQGBkhQrPsov1HjfyZVIRLleZ7g135fvXbsZdtbO6Ddp4wPV31XN72pq/YXor3JylmNbVrOLrO9KUvfea+sGDjbLOc+1Q7ErlVjffDUW1AUH2/F8ZmTSGmre2/CYsCCbbfb8k6xWq3av/Z7TdxlOZctpPr1FWcvP7msPI1iCa9cSPwSa7mzF0XR5W471J6PbWLLnd9esOpcvcLDZc0+O85bFqbcCRevcVruasM4ey6ejcLHl8HZM77lCuy7upZ1xQZ5tZZ5jYbfrfNX3WMdvyDOnhjjk4PhzrV8+fe6efUKjqeW02sh1W/gWNTLwnp7AQYJ62dvE/EotEzTsuf73koaU0SXu9g4Yb0sXsfJys3v8kSUILfeAZxKxo1Poi3ncfcpz57iZy+PWsEaN+HUF+Kpgs3u7B9Bdcd23z9djsKYWnqXAotXq5yOdTctXwvVm1Ss5bnym7BczsULqU5/WVjfVpz6abrXAhuXcLZaPXS79Tfu+e6FaVnOZdl68D64x1XmjRq3fY73spkVN0GXPfo3ztK9tvvstXd2xtq6+pa/cZY5/rR0a10OVvtcKYR1hxju2dmbVPWboYxlp5rMdfwaOa4TrRWmy0Iac3mazWBailRrJHlqB57aY42HqUW5rtrdp+XIdl9m3xlbnD0TTgX6WJgU7q3dCevX6lUnXXU8V+1Cujisd5nxbFg/W/5kG1gn5bKdUz2pbvGF8ssvv/Sa/qaFAVLWXoV53Boh/mdjLuzYdKF9Ob2i9lzCepz9eA833s1PZe5b7/nyTxfcCG4R1s9uVMtKZ5dYDN14rcZRWbr0NT4Ou10GeKnN1TgGS+3DGw1jN/fu6iOoHohe/XerZ0JtP+cflF/iu91uvV5nH5xa5na7Laf5n//5n/iP9XpdfZ9Ro+rJfHzQy9+Fj5ez3+/L0laXln1svV4fn8YdJ2tfV3VptT/t9/vqTit1H9QoDtpwvIT2cp4qT3V7407+rqJLefpODx2V5/Opi6s2WdR4g+h+12hZabmQs/fZOK5i+e/qf1ZXVLuQJxnZLH7nDzJKSeNCBtnz4cMYCbe++9e+/099qZYlPLXfWsbRjnfkOY1iN/XTwrw15uBrekyfnaD2YfszdOMsjYW8bCt2R7ps+P2onh6X9Yg6vkLLz//9738XTT/sHC/tbHpr/220vclj+afj1yHVuqW2PzTWev+cnaz7His+/rV0d+6dX11GWmiZvaUYjbvl+PKMBfjqq6/KT/73f/+3vUh///vfu08MvbTXiVZrDcrpG1t1n11U9ym71BM33vi2H48GM0gH1mqR+s5VLWqXNiqxeKemjHu+pXjX7/mLdV9s4xE5dVDKvx7/qf0XobNddVMjrF+l8a7fffb2sHsqzZ9dXW2Cy8L68TT0dVmfqloWrP6pWntdNJ1+x189jUe20anytExTfQw4blpT7ZDU5YeFxi3qWM7yry0/mofT9+aaloPV6xeS9iXEDuin1t4rf5dTfvXVV+1TwrB6ZbtTF+mx9nDZMXpWm3pX77C16y4+WtTahY/Z5O9UG5hj3XfgxTMe79tBauI6nie1g1KcGzi4ZbEdHzIv2JZJzKagaTq+0Q74oHYqrNfiQnup2gNBqdeANnTUfpga1Q5WbefX+hgdH6xY3d5YgDjBd99998svv/zyyy/H1e3t7SAbJ+hY6d54OrXXcFc3/PiXopaddnzDa1xL7cSuPSCd7b9VXUjpuMa9vSroVMHiZNWw/ve//72xPFGvOngYUHnptdz4jq+OLveU1YexvRv/2v0JoTGTtX9jlH86u/ChdN8tZ/d21fGe716YuIrj76iL80CXQ3ZB1+SW6vOz++rKLRqZsH6V43vtgI/jp8J6LRO018fHx9Pj5bSkwFNWq9WpHzc5VtvtF8xyPFdjvKsF9FJtssZOpbXIfjxNx7ta4wa2n3KN0zSupbbhxxO054DjVTSWpOUHjY4THBe1pYfW2U3+3//933KClrBenUy1OmOqfjl0maZ9ypqWK6gYNKy3LHy0yvXue6Z9t1TV9nz3asRy+uNvqmt2S5dD1rL8lorwxkPZEuK7rC5BwvpVjs/jAbPsqbB+HMercx1H+S5hvXFb2q2ueC/aPajVgrdP3FjNfPYYtSy2lsJbVt0eLjvm4PbGJ43zHi8/nP7ebP95ulcFf+Pyj6ds/2vLZV7d8LO7pX1R5TQtKbzjpsGwOrbxOz7hO6bG9omHCuunSt7+dTSsXu0xuu/DK/f88SztzVHOOnvILj4ojfXxXc6Q7q2PUmA0mMtN1Y+41hG7Voxa9+fuvbaLnnn9cDg8Pj52HP7iDlX3yeFwOB42pGqz2dTGAtqd63G/Wq1advs//vGP8t/tR7Ya64/HI6quolaeagP64yeN6ozb7bbLebharU516q/OfryolmGUaruo8cG1r9Vq1fGyOp7suDxdFvV//s//afz8559/Lv9dbTYDtxPHTokXXQxzLefwer0u00bMT/HLcLTSXmPW97Xr9/x2u619/5e3kkFGrTmlOrRX1anpG8cjikGoSxej2RzlkR8OlqRjjfWwy49/ajmI1c/jN2mvcnZpD9NoLo+no7lsN7YcndrYiC2rbu/32V7UU386rpVpX0vHonasn2tvdtlSyF6/b3SfskV7Udvb85wqz6l92HEnwyA6/lzWZQkdT/5b16yfmqv72CnXu1HNek1Lc/DGVZwqz8V75uwh65g9Gre9VqqzlfTVuQbsZ3hTn3TZO6RmtVo11iZ2Gem2XfkUu9/vu4z7XooPsjd94L4H2+321D6sHo7277Vqtfqf//zn7mtvqYdor89uWUt73UbLiPJV7SOsl/9uHES55a+nXDOKcMvIvuHj7T1bnq+++upUnXr4+CeRast1uIU8z8tzu+Vrql15ZZ2tzoz3uFP3oHFqQ3sN/ZS48vDFceVbpjyVLqL1et0rGFyg/e52avz+WKq4deXpsaS3wQjrl5vwPMjzfLPZVP8zfnVeH9bLBcZ/7D8IHd7Z9Pj4GF88cdlKl6R2IM5+6a8/6LjMljtl9Zvuu+++O/vOo45rvLjxScfzoWOmb29v017I9pK0v/upi2qaCee26Poc8M9//jP+46uvvvrLX/5y5dKgxX6/L9sVtAfl/X6/2WzOTnZWl1B4/UV0KrneOo/eQvz+6XKARipQT+v1+uIqv/K7N9Yzdm8DE+YT6IX1gZ19bB3EqWbrQ4X16hKqCymz+6nvsnipXLnSBai9u3SQfdLx/lGdrFrF3kXt261j5u4boPtOVnW2FfgpZ7+4uxem4xPs8UJqryxtL08IYbValTXrP//8czWRVzdnjsGCeYl1Q92/yg6HQ/ut8Oz1Xka3xuXEc/76G9yVhRzEsGs5+23QZc937wV0C6cOSvzOPPXNefxTzNnv2Jl9c07dDmfejvfnCOOsN6665cMbta0/lX6uXOwy9Gqa3FHHBZ640DupNT1vGWXll19+OTVX+4xVHYdebh+FoPxT+9Ar3Vtqnipz44g9LY7X2HG3lKqNW6oDqHcc1REG0eu1R0W3AfiueQFQ9+bXxbk2640bNWaD9aj75pzaJ0W3F3b2WkvLayKuaTR/dr2NC+8+mEz3w9d9h6RAtLpK48271+w11fOmPazXVh0/rH5SnvG36wh75eYv2OC7utqa5dTA6ser7qsWu4/PpVK1wXR7GVqKekGmb1lX+/jrLcuvLae9A1Oj1YdXEHQsapfyFKdDed/lwDXKk3/b6nj62lffqYhcjVnVz0/ly5br9NjZsH5qpWP2O+w+hmB72cqN6rvna6s+dQRPfd5Fl7B+6kw49XlN9Yuxy+Gb11fobAqapsaeEB3nbc/iZyc4O556efmdDeu7JoNswt0afId0zJ3VCu/vvvvuypUen0ul9pxd/qnjd2v7ZC3raq87716TXV3O8cYen+TbE28HG2S3NM5SDrXe/c2mMIjj879R9Yqofh7roU5NWbRGsepC4iNBxyv6eOGNH7YUsv9+ulzcru758tSUte06u1Fd9vzxci77rbjj7zPVFZWVmB0PSnXKsxmm1yA8KZhNQdPUmFY73onPBv32KHwczWsLbF9O9VS+poL84hkXrKXa5mIdv7D6DtrYYoTGJ9Wzt8tkLT+IN+6W7kehpUFOe87ovsb254GzCyzDumuNkYVuahVAp36MOr6C2utNG5fTvWa3Payf2rruO2cQ3YNjy46qLaqmveVM+/fVZXu+pntjqsZo1OVOeuoHhJa1zGjIaR1Mr3KqI3mXbqbHQ7z1ahF7qo/pBS4ejElf0kYX9Js8q2U4lBtZUu/Ss8s/VZhaX+qic3BpL+oFZ0XsaWq4RsbX/bQvxeHzql2xWwa8WlfetnOsupwuo2Z1WXj1w6Iorln+IMo1nk0OZ49F3LTqFoWjgSJqE3dczpV7pv3FRsdTloNVdF91+4lUM7/Bpid6SFiOU2OCts/VGLlqD3lnG5m05LbqY2iXZjDtS+i1FWfnWrxeP8Z1UW2w3l4TUA1zXZrBtBzulmM6eO/SlslGqOBvWU73X2CLc/1ley2q9NVXX1XnKv9dVrQDCxC/r8ZsKH/P5ri3/6/AdU49mWVZ1ljtt9/vy3c1d1zUKUONOXXq94H2hTTWx3d8CdmydR/b+4IFnu3p2DhXo2rZ2h/8Wspz/Dqkjj8CdKwUbxn+vL2u+rKa7NqUF7wX7NQarx8mrNfBBWYkfmO4rsfRPgpkmoT1AZxq3bXZbLIsW6/X8Ted9XqdZVn1ZUZdFtJiqLAeToTsw+FQlr/8OazckEGeN+iimjtPnT9RNTofDoeWNyJtt9vqEaw1ympPuh3vKO0nYcdMf/Grl7q30Rqk2VKWZR2n7NWQqTpxOeZ6tY8psAzxLuweOoLD4bBarcZv73SVqav2F+LKGuX2zh8tx6vLYT3bDKZ9Ud3NqK/G7VTPhKF+ZWs5AY7VsmBjN9Nqa5nGadpbdLRs4Ji9S4caeqWlQU51L53anONr/8o2OVWNDdO7zw7MSPxOm7oUCzfTnayD6TDi0/Bxn9EuVgO94fJKRVF0rx08tt1uVQmE2/QuLXWplI3trMr//J//+Z/q6Fe1d7yFEH755ZfjpiwtW1Gtrb9179IRKvhDax38arUq17LZbLbbbezqFGfZf3iv9XHBah3FBjwr9CuFpYrf3t37YnKBw+Ewy/a6Uz8tLMoFTVlaqhW71Kw3prdTLxSoOlW9d9lgI+rUS112ci/de5eWqh1A250a3rE6Te1P7aNDDtu79OIK/vYZuy+n6PyLU+OU5UIu6116XAD9SgHukDbrQ4ojB3V8aIvJ4MoH6MbZr1nmfr/v9cgxyFYs1ci9S0t//vOfz+b1OFbMcZ16zfHJPEjv0o6/QbVUSI/QuzQ6eznEJ6hwtMmN/UGvHHlT/zOAO5QVQzRW5ljsixmO7q+r1Sr20ZykVL3EfqXH+SD2zJhkPFp6+fe///2Pf/yjFvdXq9Vl7bXu2fG10HghV4dI2u12g1wgZaOmv//97//4xz+uXyAA8yKsAyRqtVqVg8D4rga4T5rBAKTo559/NlwjAPdbs77f74+HrL7bvQGkpjqqj68mgLt170M3znIEH2Dpql1RDdcIcM/uN6zH8SIMYwIk4ueff/7LX/7y888///Of/6w2gPnLX/4ybcEAmND9NoOJ4zbc7eYDSfnuu+/++c9/Hn/uOwrgzt17B9P1ep1lWXxn2NRlAe6XpA5Ao/sN6+VwyNvtNo48Xe3OBTChv//975I6AGHWzWDiS3laasT3H8SJa1PGF5qUby2Jg8Nst1tV7MAkfv755/gPjdQBKM01rMdsvVqtqu8Vr8rz/Pg1je3vFMyyrGWBAAAwsrk2gzkeIr2qTOqr1Wq325XjM7bPBQAASZlZWN/v93men21cHpP6drvd7/exAUz5A0Js5bLf77MsO65Eb6l3BwCAkc2pGcxxy5bGVivlZLVNq30eE3/ZMMZIjgAApGZOL0WqVnvv9/tyOJeaGN+r7/+Lall/t9ttNptqw5jdbjdcYQEA4GrFjcUm47vdbtjFxmboq9Xq+E9xu7bb7ak/VQuz++DsGic7QgAAjOLSZHpDQ9asx6rr6uiHZePyxnYpU4kN2eO/ezVST6T8AAAMLs1X7gzWwfS4QXmZg8sWKWN232xc13HbGAAASNZgYb0cgKWsVo9tyne73X6/j3XSh8PBKOYAANDRMGG97NNZJvUylJc13LGVubAOAAAdDRnWa6O1hEmbnTQ+FZwaQKajrINrlg8AAFW3GroxtoopK9qTcnHTeR1MAQAY0zA16zH+1jqYhqa69hHE6nztbQAAmLshw3r8R57nsTVItQ1MfD9oGKWuPa7iuMVLueoxB6UBAICLDTYaTHz95+FwKOvXy7rtLMtidB6nCfupMdTL8WpGKAMAAFxvsLC+Xq93u12M46vVKmb3qu12O1rTlPLJYb1e7/f7srI/pNqMHgAAjg3ZwTQm4+PPx++XuV6vt9vt4+Pj4XDYbDZDlaTLYC86oQIAMJRsqHCZ5/l6vW5vDt5lmmFV26lfud4sG2xfAQCQmjTD3mBlyrJstVq1NHTZ7/ebzab6itN5SfP4AQAwiDTD3lXNYMpofvyPYzPN6AAAMJWrHiDKARm72+12Mx05Mc2HLQAABpFm2LtqNJhesXu1Wm2325kmdQAAGN94bdbnLs2HLQAABpFm2Bts6MZ7qDU3dCMAAGNK8QEiTWk+bAEAMIg0w96QL0WK2lvCLL72HQAAhjJkWNdKBAAABnTVaDBVXZI6AADQ3TBhvWz6stvtilaDrA4AAO7BkGH9HgaEAQCA0QzWDAYAABjWMGE9Vqgv+I1IAAAwvsGGk1yv14fDYcGt0jv2oF3wHgAAWLA0x1kfrBlMrFbPsizP86GWmZr2vrN60AIAMKyBa9bPTjbfOJvmwxYAAINIM+wNVqbFtxJJ8/gBADCINMPeYG8w3e12Qy0KAAAIA9asL16aD1sAAAwizbBnnHUAAEjU8GE9z/P1ep1lWdmKfb1eG4IdAAD6GrK2P8/zx8fH6idx4TG1r1arWUf2NH8ZAQBgEGmGvcFq1sukvlqtdrvdarUq/7TdbkMIh8Mhvuh0vrIOpi4jAADLMfDQjdvtNr4UKWb3cuH7/X6z2QRDNwIAkKQ0w94wNeuxfctqtTr1+tL1eh3r2hf8flMAABjWkGG9vZXL3NvAAADAyAZ7KVL4ENkBWKT2L/lYI9Ol7mZY+/2+LNh6vW5Zdfcp+07c0X6/n0u91fXHcfAzodx7LbvxeKXtxeiSWy7ehPGvBRarGEL5+tLyk9iptDpNnGC32w2yxvENta8A5ujsa6rjZAPeWS4uUuONpjrsQWm73XZfbOPEfUt75UJGE0JYrVbXLCHu8O43/dVq1bLG7XYb/xrTxandWFtpnLhlse2n9JUncyzMxbMziTQP2TA16+WD46kh1asTDLJGACYRA9Apq9XqcDhcuYosy86O9luOW1DtLpXn+eFw2Gw2u92uerspRxCObwKJteaPj49xELNqZ6rqYssK9VMTTy5uV5Fef7gLHA6Hxgeq6EY/StRO5niI28/wm1qv14fDYRkHlCENGPzLZZbXW3wULj+fb7V6kerDFsA4YsXwlbWtHXVZ0anbSpm0ap80LvD4PljevGpTHv+A3NctatYHv48PqHvNerlv26vA4z+GrVk/XsuA+/OCmnWV8ZNLc/8P+QbTcnj1slrl8fGx/HetngOAu3JcU15tF95LrN7ebrfHt5Wy5rtccvxHY414vGfVpmwc2azvmGbDduK6YEd1meWyQl581I7leZ5lWfwpo32yQVZ3O712yP6Dvqs4+1vTgIeGtAwe/3e7XaxQj7bb7awr1Eu32FcAc9GxZr16Zynrkmu13ceNwsuK0lpDiFMVqO33r3gbKm89cZmnFlW9Q52tDD57RzvetHL6Ws163Ce1pR1/WNsh5f6vNdWoHpdTs0SxDGU5T21OdcY4cdyrXY5OtRhnd9f2g5azK2aJ6oZPXrNeHqna3j4+dsfFa9yHx2dObV2nDujxBMf7p3GuXnvmfnQ8AUaWYpnSlObxAxjHxWG9DCjlvOV/VnN8jBfVRNiSjLuHqqISg85G7V6LPbuicsOrf+0V1i/YUY2zVI9a4xFp3BW1sF4+81RX3bI3enUwbT+7jpNrImG93P/VRr+1p8TjWWr7sFba2gGttiuurqX7YgthvY9rvgFuZ8i2WcuoQT8lzeMHMI5qw+Jj5WTH8bQWrY6bbh8HtfYYcUHr+ePK5sYb1pVh/Xj2avi+LKwf14tXV9GY245rVY9naa8UL5rCesumNRoqrMc/1dZ76jxsjL83DevVDaxtRS2sn9qH1WNRm6Vxt9R27HH9fccLSlhvlGbYG2yc9dgBP5526Tcvu0zsd9+u0IkbWLQLBnupDbcSPm7ju16vb/3NWTbnjcN9lDesVWXMmSsb+5bt3asf5nke13tBl63G8rTvqMbxana73WazyfO8+vkFt+napq3X68fHxxFGjs/z/LiZR7joPBzcarWqbn7896mCHTd0ifuwZfnxMNUO1n6/z7IsnlrHf2WRButgWl7Gj4+PWZadGsNx1ro8/UxdRoAbammo0DJL9T9jtjgcDtXAMYL1ep3neSxtdTiEshbmytB5Kjnt9/vL4lSZ/PruqP2RMESH16mGiDgcDserbm8GM5rGgoUTe7s6Emg8K872rC1z//EBLf9UfWNXx8UyO4OF9f1+X3x4bUH4UG+x1NQOQEfHgabMyo+Pj+Wdou8C2ytWYzRv+Wu8Z50q4QWLvcWdrkyfvXbU5mPHdbcjJ9pr7Of5EtDGkyH+ChFHv4nHpeOB2BypTRAXG5fcfbHMyJBDN4YPP/kVleZcZWr3Sw0AoZKVqzXcAway+GqkMjC1ZNzYMqHM/auPR3Ks2e/31cXW3ChQljsq3lWrPwWc0ljlPNNas1NtYBLXeDJsNpv44qeyuXnHXNT+S36WZbXFzvRY02LgsF4qf20sL7PYPOZGqwNgFqpDQVdruHs1QY53llP5+LjpdvvCy5rIOMupVgTxr6dWWrZwqH3eq66qNnt1R8W7avvjRMtiZxrghn2KG9zxXj31U0D5ZoBerfxP1ZHXWjfFrhe9dtRMz4e7dauwXprpYzEAt7Df7zebTS0r9P3hvmz4fpyDy0/K7BIX3hhlavn7+B/VYsfEfyp5x1lqbU76/qRcfaiIjY9rS2gPZPFuezzLTBsxp98GpvYQWJ4kp9S25ezp0fh8GE+M6hXUZbG1gmnsMDOnfl650vHbE8LMBwm63b4CSN/F46zX+gLWBiM/Ho+86DaCXnUoyXKE6ePB+6oLrK60eodqXGxjCdtHPKwO53c8GHltb+w+fi1Rdb21QdOPy9yyo7rs2y734nA0dGPjcWzZIeWq28f6rC6t9nk8oLUpLxhnvWMZiivGWW8c4Lw6qOLx4a7un1PlL4sUW7m0nAPHo+8fT1OuqHEAfqKOJ8DIBi7TqYy+gCHY0zx+AOMYKqwXTS9cbEyc7Vmw+DjgVjXecRor709tTuPEXW5kx5tWznW8N2priU8doSlrnirGceA73iero5HaRw7rjWoTN55djfv8srDepQxF/7B+vPyWQdOPD3dROdWPC3xqxtpuaTzlag9px2dFx8v5DnU8AUaWFQONNpjnee3nvzj+6GJ+asmywfYVAGW72+rYc7W/drmDVJcTzrWaaF/pNRMfzzjUKrrsqNqfLi55UmpjwyclZp7dbhf7XVxzuPM8r/7nZQe0bDBzarHVhSS7V1OQZtgbrEzVzqOLfC9SmscPABhZNaxPXRaGlGbYG+wNpmGhGR0AAKYyWFhP8EEEAABm7eZDN5ZSbnwGANDRer32olBGc2HTnDhQbjiqUI/9gRr7lcZG7fOtgE+zGRMAAINIM+wN2WY96vUWOgAA4JThw/qCVUe8OSXBBzIAAGZKWO9BEAcAYEzjdTAFAAB6EdYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEnXt0I3r9br6n/GNSIfDofY5AADQ17Vh/dT7Sr3HFAAArnRhWF+v16vVatiiAAAAVZm3cnaUZfYVAMBipRn2dDAFIA1ZFrJs6kIApEVYBwCARAnrAACQKGEdAAASJawDAECihHUAAEiUsA4AAIkS1gEAIFEXvsEUAAZXhJDyQOv7/X69Xk9diux7TiYAACAASURBVLDf7xs/Py7bqSnb52pcY7mo9Xp9dpbq9CGEPM9vVDC4CwXd2J8AN/LHb7/98erVHyH8EcIfn332x9/+9sdvv01dqLrdbhdC2G63Uxek2G63p+5Bu92uOuX1t6241cda9sNqtTqefrVanZ2m+yrgRtIMcmrWeyjSewMtwNwVT0/hr38NX3zxvk797dvi3bvw9dfFmzfZs2fTlu1KWZaFm907VqtVte55v98fDofNZrNarcp661qsf3x8PP6wxXq9PhwOcV1l7Xie54fD4fHxsVZ9Hsuw2WzKssXi7ff7x8fHw+FQfZF7nufVeWPha1ukZh3em/hhYT7sK4Bb+OPVqz+ePy9CqP7vj2+++eNvf5u6aB+5oGb9RvfZmLaPS1LWgtfq1y8rT8vSTv0pfti4i2JVeq1+vfZXVelMLs2wp4MpAJN6/Tr7179qn2WvX4fXrycpTs3Z1tX7D3ots+8sXazX6xijY/X2leJCdrvdcQ1344riZNvt9riFeviwGw+Hw+BbDYsnrAMwmeLdu/D2bfPf3r0rTv3p9vb7fZZlWZZtNpssyxqbZKzX6zhBlGVZmVPj7PHfcTnVz6uzDNvYo1zalZk4bkitXUptRbE6vNzk2GCmMalHMd+3TAA0EtYBmEz28BA++6z5bw8P2ak/3Vi17fV2u91ut7E5eHWasj33drvd7XaxaUpsyR3/WjYNjxPEf8eFlLOsVqvD4TBsXu/Sd/OsuBXtwbpskl7+f/uq4/RxpwHd6WAKwKSePy/evcs+bvRSvHgRPv10qhKVkbpMq+v1uhbWY+gsPjTUjkk0hvX47zzPY4fOatfM6mLjZFmWDZtf41PElaNMdinSer2OPUfDh7CuSyjcgpp1ACb18mX49dfim2/KD4oXL8J//hNevpywUOHjeuWy1Udpt9udGtawZYG73W5G7UDaw/fF0VyzdehFzToAU8qePSvevAk//lg8PIR378LDQ/j00/DmTfanP01SnlMtOsp2L+V/VqePAxSeXXh1rlv0MR1We/X8xYVXAQ+9qFkHYGLZs2fZ999n796FELK3b7MffpgqqYfTLTpqn8QgW/YWfXx87NJYPM/zst9ql3B/gUFapMRtaY/j1aeaavt1YFjCOgCpyKYuQDgdc2tJdLPZxPf4lGONn23fEht5hw8dTIuiuEW6jdX/V4b1LuG7+lTQpfNoOcLMNQWDOySsA8B/lV1Fa59Xk2vZVbRXP86yT2qe5zdqCjJUII7LaRkWPb5zNFRa9ler2BvVutsCHQnrANCgllOPq41rwfSCGNoYhS+ubi/Hnxmkwr587dHx0sqhLatdbMvXHjXuh7ivWgZuB04R1gHgI2VOzfN8v9/HhubVCWLiLINsrF+vDmIYNbb8jsuM/yiHgyyniTm4trpGj4+P6w9iO/iY1PuOUXNKOVT8ZrNZr9flrihHsdxut7XkHVf9+PgY3w9VTh+Hp1ytVhq1wyUKurGvAG4rhCKZb9rylUalmES3222coNbUZLVaFR/GXC/vF9WFFEVxHKPjG5fK5Ven6VW2ahlaXHDfPxX9y5b6xxob4ZT7rWWW9mlgBGmGvayofLnQIsvsK4BbitXJKX3TxtEVY+31qb+GEKoTxLrk2hCNXT4pW4/EyvWk7jjVUSZP7Y1Ts3ScHlKQZthLsUxpSvP4ASxHemF9ErEBiRYjML40w56XIgFAKuLLlYZqdw4sQIoPEGlK82ELYDnUrAOTSjPsqVkHIA3p3SMBJmfoRgAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYT2EEPI8z+L4vgAAkIwUx34f2X6/32w2IYT2XZHmOPkAAAwizbCXYplGVtapC+sAAHcrzbB3781g1ut1CGG73U5dEAAAqLvrsL7f7w+Hw263m7ogAADQYMZhfb1e53neMsF+v8/zfL1en5pys9lst9tYuQ4AAKn5ZOoCXChWirdMkOf54+Nj+Z+Hw+Hx8XG325XRPMuy1WrVHvcBAGBCc61Zj+O3nFIm9dVqtdvtyibp5Vwxo+d5vv8ghFD+AwAAUpBip9cWMU+XVear1aoxXscBXrbbbbXivPphrd696tQOSbODMAAAg0gz7M2pZj3P881mcypkVyer/SOK9etx9jzPi4r4p91ul+ARAgDgbs2pzXq1J2hLm/VY175arWqft9SmHy8fAAAmN7OwXubpPM9PhfX4eUvy3u/3l+Xy8vVJV1J/DwBAF3NqBjOU42busVXM2RmLgdxkqwAAWJzFhvXGuvPjtjEAAJCsxYZ1AACYO2EdAAAStdiw3jj+evtLT8/KOrhm+QAAULXYsN7i4iEadR4FIEz3xmuv2YY7tMCwHnuR+kYD4EY2m03tvXsjiG8GdHeDe7PAsB6/QI9bvJRfrF5+BADALCwwrJdZvBbK4+tLt9vt6CUCYFGKolDDDYxjgWE9hLDb7UIIh8NhvV7v9/s8z8uun+P/cAmwKFk21//117dtepeJ9x9cPAFwV5YZ1tfrdaxBPxwOm80m1qmHEHQABaCLWMuz2Ww2m00c7KuanrMsq/14u16v4/TxT/v9PsuyavPLWGdULjNOWVtpuZByApEdmGtYz/O8/VfIOMH2g91ud31SN3QjQCiKuf6vszzPy5aTu90ujluw2WxOTZ9l2eFwWK1W8Y4T64kaJ1utVrvdrlxm9a6xXq/Lhex2u1jl1LJS4E58MnUBbmvYRi8q5gHuQUzq5Xf+fr+PSbpx4nij2W635R2n2vayarValXVMseq9+te4/HKCWHP/+PgY137F1gDzNteadQAYzX6/P1VfE5N9rW4oVpzXtE8zyC/AwPII6wDwkdgEpWx9fsESGuvC2yvIy7/G3qVlUxzgzgnrAPCRPM+roxQcdzCtOa5Hv6DhSmzuUnYwldSBSFgHgLo4SkHs6Fl2MD2V14+bs/etj9/v95vN5nA4lCMixDESLik6sCwL72AKAH3FqL3+IHwYHybP8xuNpRgXu9vt9CUFatSs92DoRoB7EBuiVD9pydCx3r3WebRvI5bGZwAtYYAgrPdSdDB1GQEYRuxdGsXs3jgccMzZZb378ZiMHdcVlx+XVh2u0XuR4M4J6wDwkVjzEnuXlrXs2+32VP36brcLITw+PlYn7rXGPM9Xq1XZnzUupFystjFwzzKVwR1lmX0FcEdiNXn40Hi94/Rx4tjGvW8b9HKNZRV+dZk9iw/0lmbYS7FMaUrz+AEwrbL1S/XD+MZTdw2YlzTDnmYwAHCVw+FQrfnO8/xwODS+xBSgrxQfINKU5sMWAJOL9ei1D90yYHbSDHsplilNaR4/AFJQbQmjiTnMVJphL8UypanjUFz2JwDAHKUZ1r3BtIcEjx8AAAumgykAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJMs56D13ei2QsdgAAhiKs9yCIAwAwJs1gAAAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAk6pOpCzAnWZadnaYoihFKAgDAPRDWexDEAQAYk2YwAACQKGEdAAASJawDAECihHUAAEiUsA4AAIkS1gEAIFHCOgAAJEpYBwCARAnrAACQKGEdAAASJawDAECihHUAAEiUsA4AAIn6ZOoCzEmWZWenKYpihJIAAHAPhPUeBHEAAMakGQwAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEvXJ1AWYkyzLzk5TFMUIJQEA4B4I6z0I4gAAjEkzGAAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJCouw7reZ5nH6zX66mLAwAAH7nfsJ7n+ePj43a73e122+32cDjI6wAAJCUrimLqMkwjy7LVarXf7+N/xuzesjey7H73FQDA4qUZ9u63Zj2EkOd5+e9YrV5mdwAAmFyKDxCTWK/Xh8NBzToAwH1KM+zddc16CGG/38cOpu1JHQAAxjfjsL5er6vtWI7t9/s8z9frdcuU6/V6u92uVqvwoSUMAAAkIsXa/i72+/1ms6n2EK2JHUZrH+52u1OJPC5wu92eivVp/jICAMAg0gx7c61Z32w2LX8tk/pqtYojM9bmipXu1VlUqwMAkJqZhfUYsrMsa58sJvXtdrvf72MbmPI5qczoj4+Pxn4BACBlKdb2n3LcsqWxGUw5WW3Tap/HxF9OYzQYAIB7lmbY+2TqAvRQbamy3+8Ph0PjZDG+xz6jVbWsv9vtNptNtZJ+t9sNV1gAALjWzMJ6mdfzPD8V1uPnLW3QY9uY9XpdFEVZMd+lzfrZ5jcdJfjQBgBAguYU1ocSw3r8d69+pUI2AABjmlkH0+4aU/hx2xgAAEjWYsM6AADMnbAOAACJWmxYbxxD/VSfVAAASNA9djC9+GWlXUaD0QkVAIChLLBmPfYivcXbSYsOBl8pAAB3a4FhPc/z0NTiJX4erqhZBwCAMS0wrJ8aQz2+vnS73Y5eIgAAuMQCw3oIYbfbhRAOh8N6vd7v93mel83Ny/p1AABI3DLD+nq9jjXoh8Nhs9nEOvWg9ycAALOSLTu/VtupX9lUvctQMMHzAADAPGVZisE4xTKlKc3jBwDAINIMe8tsBgMAAAsgrAMAQKKEdQAASJSwDgAAiRLWAQAgUZ9MXYA56TJ6Y4KdiAEAmClhvQdBHACAMWkGAwAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABJl6MYejLMOAMCYhPUeBHEAAMakGQwAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRXorUgzeYAgAwJmG9B0EcAIAxaQYDAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJ8gbTHrIsOzuNt5wCADAUYb0HQRwAgDFpBgMAAIkS1gEAIFHCOgAAJEpYBwCARAnrAACQKGEdAAASJawDAECihHUAAEiUsA4AAIkS1gEAIFHCOgAAJEpYBwCARAnrAACQqE+mLsCcZFl2dpqiKEYoCQAA90BY70EQBwBgTJrBAABAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRn0xdgDnJsuzsNEVRjFASAADugbDegyAOAMCYNIMBAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUXcd1vM8zz5Yr9dTFwcAAD5yv2E9z/PHx8fVarXb7bbb7eFwyLJs6kIBAMB/ZUVRTF2GaWRZtlqt9vt99ZPtdpvn+anp73ZfAQAsXpph735r1kMIx01fqtkdAACm9cnUBZhM45OTlusAAKQjxdr+jtbr9Xq9PtVqJYSw/yBO3DJlCCE2WG/ZG2n+MgIAwCDSDHtzrVnf7/eHw6Flgth/tPzPw+Hw+Pi42+2O687LKXe73Q1KCgAAF5prm/XNZtPy1zJ/l4O9NM613++zLHt8fNxut0VRaAMDAEBSZhbW9/t9HBy9fbKY1Lfb7X6/jw1gyh81ysYw+/1+s9msVquiKNpbyAAAwCTmFNbzPN9sNtXGLacmq/0jivXr5ewxqRv+BQCAZM2pzXq1mUpLm/WYv1erVe3zaiv2MqPXAn3stDpAWQEA4GozC+tlks7z/FRYj5+3ZO4yqR8Oh9pCytFjGg31itMEOxoDAJCgOYX1ocSG7xckZiEbAIAxzanNei+NNevHbWMAACBZiw3rAAAwd8I6AAAkarFhvbGfaPtLTwEAICn32MH04sEZu4wGoxMqAABDWWDNeuxFeou3HRUdDL5SAADu1gLDenzP0XGLl/L9R157BADALCwwrJdZvBbK4+tLt9vt6CUCAIBLLDCshxB2u10I4XA4rNfr+Aqksrl5Wb8OAACJW2ZYX6/XsQb9cDhsNptYpx70/gQAYFayZefXajv1K5uqdxkKJngeAACYpyxLMRinWKY0pXn8AAAYRJphb5nNYAAAYAGEdQAASJSwDgAAiRLWAQAgUcI6AAAk6pOpCzAnXUZvTLATMQAAMyWs9yCIAwAwJs1gAAAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKIM3diDcdYBABiTsN6DIA4AwJg0gwEAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJMnTj/HUY/b2BYSgBAJKnZn3mLkvqAADMgZr1HtJ9g2mvlcr3AMACxEiz9MYCwnoP3mAKAMCYhHUAAC6l79yNabMOAMBFpm5bew+RX1inmyy75H8AwOIVRY//DbLCp6fi22/jsorPPy9evSqengZZcoKEdToQuwFSpn6Ee1I8PYW//jX8/nsWQhZC9vZtePcufP11p7w+w4tFWKez0Z+bgZub4X0LZsP1dSM//RS++CL717/KD7LXr8OXX4Yff5ywULeTGeGkoyxLcl9dMGhRsrMA43OpLoPjmKZ7OC6jJYShurG2rj3NsGc0mHvlWR9gQYoQfK1Ppv2WeuqvI4TCxYzTMmhomd3FohnMLemUCXdobhd+erdlelhgN7upr4jeki1tsgW72IemtsVnnzX//eGhpTnufC8WYf1mkr1IejU91wwdekn2wj8y3/sWpa7d7Ob2ADlLH98xi99+K169KkIoQig++6z429+K336b5n66yBv98+fFN9/UPitevAjPn5+a46o+qVMT1nvIOqjPs8iLBGiX/IU/6/sW/9Wlm53YPTrX1829fBl+/bWa14sXL8J//hNevjw5y5z7pKbYjj5Nvfsc3Hk/zmQLtiSLaYy4JDO5iotvvw2//169b4UQim++CQ8P2fffj1mSic3xm6py4Z9qetvw+az6/xUhZBMelKs35Pz1Nc6Jl2wOGWKW4ukp/Phj+OGHEEJ4eAjPn4eXL7M//ak+Szn9jS6WUQjrXZ0M66fOuWTP+HEkW7DFuLi2zEG5qWSv4svuW4s/W+b4TfXhUMZCnzqO9T+NczO6QC1+/fRTiHH2s8/ex69nzy5c8mWG+CEilesr2Rwy4Cwtj3YfP9aGG10so9AMBuYs+eYWJKj9VHCipO7DFZ0VRTjRzS48PGRzax6dVtORXhvy8ba4vkZ25umq18VSFGk2GhPWScliekEtZkNYjOrdqPN9a9wi3lL7RTffS7J/N7t0zblJce/ri/HN+WLRDKYrzWD6mehX1CSMsyFLOluWZCbHpXj1Krx7l71+/dGHL16ETz/NYhvQJVnMd8uR4ukpfP11+PLL8lC+72b35s1/G+8mezNKs0nxENfj+etrzEfBZA/9QM1gTi7q4z91ulhSfSmSmvUBJHdUZ20x7ToWsyHJuvOfL67c9gvGUkjHZRteueKK334r/p//p6jUqBXffFP83//3fwfXS3ZbPj6U2bNn4c2b8PDwfojAh4fw6ae18DELS2s6Muvra146X7CzvliE9csZpRgms6TYfYGrN3/G961BDn0iLS6G2Jbs2bPs++/jgrK3b7MffpjBQazq2zRrDrUb56+vvm3ir/nfYFs1+/qO+V4sKdb2p6n2y8j7rjCVr/vim2/Cr7+GN2/ed11P9rekcdzz5ifbBCjN3XWZZM+WNM/81l+Kew+TN+2e7Pyrd8OfPljgYB0X7JbL9mTfgnWeJZWmWcOe3sleXxes/YIT6YK1jDBL66I0g1mWRCpmAK4z77qy/pbW4mIxFtp05N6uL24hxQeINGVZVt1Tl1fMTF6ZMY5kH7UvcFm19zIOSkh18xM/W1L7XWWOXzu3rA8uPv88e/u24fOHh/efz24bk61Z77OW86+5GcHkF8uSzr2+ax9nlhnWrKdYpjRVw3r8x6mw/tGfhPU0ZxnBkg7KBRJ8JEj2WWW0sD7UKhIOEx2bHNxwsI5xAu4F5hDWy8/bjuMFe2CoL4pk72sXGPD6Sna3LCisawbTR2EU1Zm75j7X939LcusNT7bT0jgFu+DsmvocG2fd3dfSu7v/Qltc9JXs99TJCy/Z74pBpXZcljacxtTfnxcQ1i8159H1792sUtEdGee4ZFcN+TfXE2agTTh/z+61e7P6QIRd13I0fd83X95ksI5xDPFoN/vsldpBOVvUjtMmeVzSerPsvRLWL3VFxUwC3x8A/Zy/Zw9R63lJMriou3/ig7jd7jYxfvZa0i3vHo+L4TRSUNDN8b7647ff/vjb3/4I4Y8Q/nh4+OP//X//+P/+v+oMxcez/PHbb3+8evV++s8+++Nvf/vjt99q67jwfwm6oGAjzJLs7hrHmAdlGafxPTv+Bnv16o/nz2tH7Y9vvvnjb387NUvXtVz3vz86ft5tMy83xPV1/jZxtfPHsRjmKu56yzs24PEa6EsvleMyyIrat2XY6+uUZGdpCnspSLEdfZqybpVG/92fH/dgOD8ue7iuRXVq0uxxkmx/3HEk3oX3bo9LmsbsYXmFuLILu/uHQb8Trr6+Ot0mrilbXObp3TXELyP9b3nHe2zAAUmG+NK71XH5+OTvelyuO1e7viLmkkUndru/bBYdTBeg+Xnn40e3kzN3+SFpiMaIMDGnMd3V2lJ/SNgNE9b+9OG06fHmy/Tdvr1B+16o//Waq/iabUnteKV2XK6hTcs8pfgAkaaTD1vtD/Qf9KjMWMYRSfO5Wc16GKNmgkU6Pzb5RGu56s2XKdSsfzDObeKGx3H0+vv6qgesWa+ubZw67xsdl6vr72/yZtk0E8L7mVIMxmrWxzDeQzPAjYwzBNYFa1nEOIzj3SZufxyXdMtzXJZxfc2dsH5jfX+oTe957ipXDN8GpGWce3b/tZwfh7FFCt+6I98mbnccL2ibNFyTuYGP4vjtrG50XColvGxbrrq+GIiwPhbjsgNzNs49+7K1JD4OY1ej3CZGyl5j3fLGGJv87o/LQq6vOUuxaU6aejdjOu7m//XX4csvy4Zf7x+aPZ5e47L6+Ls9543TwiDa3wY/4Vqm7WIxyGgwY94mbnkcx9mWrmObXHcWOS5lwUIYtIPHBbRZ56b8kAQsxjit1u6tbdz4t4nb7eGRtmWUsU0cFyaX4gNEmq6sWa9+PkalFMCNjFOBPbvBiwYs8Fi/XTSvfei1DLwtF4w5M9RZdOfHZXaDg6lZ5xr3Vl0EQC9Luk3caFsmGXPGcWESwjoADGTZQ2ClUOxeY5vAInwydQEAYAjC2b15/rw48b6eqUq0ZK6v6ahZB4CrDTpqOJ14Xw/3QVgHoI9xImayQbZvU5AUmo40SnYPd7bMsU3mf1wYXIqdXtM04GgwzZ8DkL6+3+GzG9amRbLbcmpsk2ELnOxxucCStuWUBY0Go8366MY5Ce7hOgRqXPjLsKQjONa2tP14MdQvG44LE9EMBgDoRMSD8QnrAECb4ump+PbbmNSLzz8vXr0qnp4mLlMXev2yCMI6AHBS8fQU/vrX8PvvWQhZCNnbt+Hdu/D11/PI60wl2a7VMySsA0APfetdZ19P+9NP4Ysvsn/9q/wge/06fPll+PHHCQsF90MHUwA4r3h6Cj/99P7fn38enj8PL19mz54NNX1aPq4TPa4gzV6/LkIIP/zw0acakMANqFnvIetg6jL+l69MuJWEf95N9MJPeI911LcpyGKajrSfUYmeb7AswnoPRQdTl3G23YCAK7jwb65vU5C5Nx350NUyK4rw2WfN0zw8ZIn0y9QrlEVLcez3NA32UqRbel+XU7lDFN98E379Nbx5M5vfXiF9iQ1nPoMLP7E91snHPwUUJ0byHuDz5HdL8epVePcue/36ow9fvAiffprVmsFAafKrfkEvRVKzvixzr8uB8Y3TQuOma3Hh31jfpiBLazry8mX49dfim2/KD4oXL8J//hNevpywUKRvfqd6qlJ8gEhTujXrlQSwpLocGMk4b1Af/Avhggt/blVcSSk+/zx7+7bh84eH5s97Tp+44ukp/Pjj++6kDw/vO8v+6U9Tl4sUve9a/f33IYTw2WeTda2+uH4kvW8qo8Esx9m6nHl37wKauPBH8vx5caIpyDDTpy179ix8/3344YcidpaFE/7bKi/+99u3RexanU6rvBnSDGb+5tUNCBjEBRc+1+jbFGShTUeW8+w3/xGKEpVOq7yLXl6b5jmhZn1ZllWXA8lKq8Z6Dhd+Wnusv+zZs+LNm/Djj+8feh4ewqefhjdvTjUF6Ts9zJhR+W9Mm/Wu0m2zXlE8PYWvvw5fflnett/X5bhDwCl9LtXL22Le8gsh5Qs/ldarA8qyIoSs+6HsO33K5t/34L+WtC2T+xDW49481YWm/qckd77RYLi57Nmz8OZNeHgoQihCKNTlwHCSfc1Nshd+snvsSn1/Ipj1Twpwnua4N5biA0SapqxZv2joid51OaoZuE+dL5bi22/D779X22KGOKL5w0MWa46HWMtVEqvEvWqPJavvV+WSvlptS5pS2pa5j8qfZs16imVK1GU9UaYL62PMAnPWqYXG1UOjjtoOZPKr+LIXCc3ra0dYty2pSWlbUm6VFWEcSQAAF2BJREFU10WaYV0zGOAe9W2hcdlrbpbaDqSLpb0YCOgg2VZ5s5biA0SapnzYUrMOQ7ughcYFr7kZux1IYlfxwl4M9J6adduSmjS3JbFWeR2lWbOeYpnSJKzD7F3XpqVrW8wJXyqc2FU899arze45rC/JPKNkszTPsTRLdU6aYV0zGODuXNhCo+drbrQDWeqLgZi14ump+PbbeAEWn39evHp1D83SmDVhHbgb140v1rUtplHMPtB6ldTcczcS5ivF2v40aQYDS3JVC43uoz2O3A4k2at4SU0OmDPDiY4nzVKdk2YzmBTLlKZpw/oYg6a7m3JPrhpfrPP1NfYoZsneHZMtGIt3H8OJpnj7nudVn2ZY1wwmaeM0rdOAjzs0TgsN7UAgHcvrRuL2fSeE9XSN07ROAz7uVvbsWfb997E6LXv7Nvvhh1tk6HHWAjSr9Azp0Y1kDty+74ewnrCffgpffFFtWpe9fh2+/DL8+OP5ebt/3VyzFliEi95OnORa5pMzYBrPn1eHJ4qKFy/C8+eTFOcqbt93I8WmOWkaqRnTOCM0TzgONKRGB+4R3Pnmk4yxu5EMa17t7+d51WuzTg/jNK1bXgM+ADhlMd1I3L7vSooPEGka/2FrnDd1L/N94NCdmvUR3Pnmk6A0R1Dpw+37FtKsWf9k6gJw2vPnxYkRmue3FgBIyTidVW7I7ftuaAaTsHHe1O194AAwO27fd2OZYX29Xud53jLBfr/P83y9Xp+dckLGgQYAGi3w9p1ltU60RCk2zbnSfr/fbDar1Wq/3zdOkOf54+Nj7cPdbrder1sWO7M3mCa7FkjNOM2pNdqGpCzpklzM7TuBg5Jmm/UF1qxvNpuWv5ZJfbVa7Xa77XbbZa7JLWccaABgUG7fy7acsB5btmTnfkCJSX273e73+9gGpnyESrY9DAAA92khYT3P881mc9y45Xiy2j+iWL9+dnYAABjTQoZurDY33+/3h8OhcbLYin21WtU+b2zFTioSaMTGko1zajmBAbjIcsJ6mdfzPD8V1uPnLR1JY9uYwYsHAAAXWEgzmKGcGkAGAADGd49hvbHu/LhtDAAATGshzWDGcXaomY4SHMITAO6IGzHzIaz3IGQDANxIYcz4JvfYDKaxYfqpPqncC285BoApFE9PxbffxgrR4vPPi1eviqenicuUknsM6y0MBQMAMJri6Sn89a/h99+zELIQsrdvw7t34euv5fXSfYX12IvUkC8AAEn46afwxRfZv/5VfpC9fh2+/DL8+OOEhUrKfbVZjy86PW7xUr7QNNGadS9tAQAazfH2/XG70+NGqNnr10UI4YcfPvp0jls6hPuqWS+zeC2Ux9eXbrfb9tmzDm5SbgCAxWlP33eazY/cV1gPIex2uxDC4XBYr9f7/T7P8zJhl/XrpxQd3Lr898luBYDlKIr4v6wowmefNU/z8JB9mOz9/+7VfTWDCSGs1+vtdvv4+Hg4HDabTfm5nJ2g4ukp/PTT+39//nl4/jy8fJk9ezZtqQCAwTx/Xrx7l71+Xf2sePEifPrpVCVKTXa3IbXaTr1LU/Usu999NYn33cMrnU6Kb74Jv/4a3ry5SV6PP7AkeIiTLVialrS7lrQtACcUT0/h66/Dl1+Web148SL85z/hzZvsT38auTBphr0Uy5SmNI/fghXffht+/73aPTzEvP7wkH3//fDrSzYYJVuwNC1pdy1pWwBOK56ewo8/vu9O+vDw/of00ZN6SDXspVimNKV5/Jam0kP31GvMGj4f5LgkG4ySLVialrS7lrQtAGdlWRFCNumXXpph7+7arF+jy2AvCR7jOTrbPdywOwCwMG7uje5uNJhrGA3m5nQPBwCoULNOqkbvHq7CHgBIjZp1UvXyZfj11+Kbb8oP3ncPf/ly2PUUT0/Ft9/G+vni88+LV6+Kp6dhVwEAcBlhnURlz56FN2/Cw0MRQhFC8fAQPv108IGc3g8Q+fvvWQhZCNnbt+Hdu/D11/I6AJCCFDu9pinNDsJ34YLu4Z2H0Rh7gMgLXDAkSJqjiIxTqjS3/TJL2haAsxL40ksz7KVYpjSlefzuwrBp9eMhfboOEDnhoRfWE1zLOJa0LQBnJfCll2bY08G0B0M3LowBIgGAxGmz3oOhG5egMuZjjwEiAQCmoGad+zb6AJEAAN2pWee+jTVA5DVU7PeypN21pG0B4DLCOndtnAEiL2MA+F6WtLuWtC0AXElY595lz55l338f+5Jmb99mP/yQSFI3AHx3S9pdS9oWAK4nrMN7aY398tNP4YsvqgPAZ69fhy+/DD/+OGGh0rWk3bWkbQHgaikOJ5mmNIfevAvjDDQ++fCuAw4AP/m2NBq8VJU91nV3DVuAAS1pWwAuk8DNK82wZzSYHoyzzrW6fRMZAL6XJe2uJW0LAIPQDKYH46xzQwaA7+uC3ZXsHlvStgBcxjfbCWrWIUkGgO9lSbtrSdsCwNXUrEOS5jAAfEKWtLuWtC0AXE1YhxSlPAB8gpa0u5a0LQBcL8VOr2lKs4PwXbhoaJcihCzB0WDG2pbes4xgnFKlue2XWdK2AMxBmmFPzTqLsshXP3YfACTNzR+5VEsaL2VJ2wLAZYR1luPOX/2Y5uanWSoAmAthnQW581c/prn5aZYKAGYixaY5aUqzGROXvPpxwrd+Dvtq1QFfejqsCd/HmcAL8AazpG0BmIM0w55x1nvwBtOU3fmrH9Pc/DRLBQAzohlMD95gmqJ7futnsi899T5OABiImnUW5M5f/Zjm5qdZKgCYCTXrXCHLQoemQdfO0t3Ir3686bZcIM3Nv6ZUqe1hABidsM5y3PmrH9Pc/DRLBQBzkWKn1zSl2UF4YsOObTKgcd5gmvAs47wrNIQ+BUv2oCRrSdsCMAdphj016yzTnTeeSHPz0ywVAKRMWIdRJffADgAkTFiHEEK49eiBxdNT8e23cQXF558Xr14VT0+3Wx0AsAzCOtxc8fQU/vrX8PvvWQhZCNnbt+Hdu/D11/I6ANBOWIfb++mn8MUX2b/+VX6QvX4dvvwy/PjjhIUCANKXYqfXNKXZQXhiyQ7WMflaPh4dvDjRt7L+ecuiFrCTkx08J1lL2haAOUgz7HmDaQ9Zh/ezJHiMmVb7CXEqxwMABM1geik6mLqMpCF2Vy2KUBRZUYTPPmue7OEhq0w5bhEBgBlQsw639/x58e5d9vp19bPixYvw6adTlQgAmAU163B7L1+GX38tvvmm/KB48SL85z/h5csJCwUApE9Yh5vLnj0Lb96Eh4cihCKE4uEhfPppePMm+9Ofpi4aAJC0FDu9pinNDsITS3awjmTXkmVFCNkyRkQxGsytLWlbAOYgzbCnZh1GZewXAKA7HUwhbek94idtSbtrSdsCwKXUrAMhZFno8BoBAGBkwjoAACRKWOcqF/xOv6Sf9pe0LRcYYfPvfA8DgLDOJYqnp+Lbb2OQKj7/vHj1qnh6GnyWZC1pWy4wwubf+R4GgJKwTm/F01P461/D779nIWQhZG/fhnfvwtdft8SpC2ZJ1pK25QIjbP6d72EAqBLW6e+nn8IXX2T/+lf5Qfb6dfjyy/Djj0POkqwlbcsFRtj8O9/DAFCR4tjvaUpznPzxVIYKKU4MFn7q836zDLKTh32bzMfDpHTdlsa1p/m6ovZZhtr89lJddoLd8yUJwNDSDHvGWe8h6zC2XYLHeFjtm9cYsy6YJVlL2pYLjLD5d76HAaBGM5geig6mLuPNFEX8X1YU4bPPmqd5eMg+TFb9X79ZEnTZtizGOJu/mLMFAAalZp3+nj8v3r3LXr+ufla8eBE+/XTIWZK1pG25wAibf+d7GAAq1KzT38uX4ddfi2++KT8oXrwI//lPePlyyFmStaRtucAIm3/nexgAKoR1esuePQtv3oSHhyKEIoTi4SF8+ml48yb7058GnCVZS9qWC4yw+Xe+hwGgKsVOr2lKs4PwxLKsCCHrOepI71mSddHmh5DkGCYXDSBz80O5pLMFgOSlGfbUrHOVC4bmWNJoHkvalguMsPl3vocBQFgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECetACCEk93plAEBYhztXPD0V334bk3rx+efFq1fF09PEZQIAPhDW4X4VT0/hr38Nv/+ehZCFkL19G969C19/La8DQCKEdbhjP/0Uvvgi+9e/yg+y16/Dl1+GH3+csFAAQCkrCk1VO8ky++pIloUQQq/dcsEsyZrj5scCfFCEkDVNVf+8scAjbMvkuwuAe5Jm2Ptk6gLMSZY1BpuPJHiMoVH7mXoqxwMAY9IMpoeig6nLSNqKYuJ64liAoghFkRVF+Oyz5skeHrLKlOMWEQD4LzXrcMeePy/evctev65+Vrx4ET79dKoSAQBVatbhjr18GX79tfjmm/KD4sWL8J//hJcvJywUAFAS1uF+Zc+ehTdvwsNDEUIRQvHwED79NLx5k/3pT1MXDQAIwWgw3aXZQXhicxwOZUDL2pYihCy1Q7mkPQxA8tIMe2rWgRCM/QIASRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAk6pOpC8CcFcUYsyRrSdtygRE2/873MACoWQcAgGQJ6wAAkChhHQAAEiWs/9d6vc7zfLTVZVk22rpo51ikw7FIh2ORFIcjHY5FOu7kWOhg+t5+vz8cDlOXAgAA/kvN+nubzWbqIgAAwEfuPazv9/s8z+/kZxQAAOblrpvB5Hn++Pg4dSkAAKDZXYf19Xpd/lubdQAAUnPvYb3M63meC+sAACTl3tusAwBAsu66Zr2vofqhFkUxyHIAAFg2Nes9FAO5RdmGHdBm8OFxEi/esO5t793V4Uh5abdY4LDuau/d1bEYfIGJF29YiW9s4sW7E8I6AAAkSlgHAIBECesAAJAoHUx76NLQSudRAACGIqz3IIgDADAmzWAAACBRwjoAACRKWAcAgERl2mF3lGUD76thF5jy0gZfoOINv7TYefqitdh7iSxt8AUqXjpLG3yBirfUpQ2+QMVLQYplSpN3bgEALFuCwVhYBwCARGmzDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABL1ydQFIIQQ9h+EENbrdZ7nExfojtWORTRxmQghfDgcro5b83WUMlfBhNwd0nF3X1MFU2s8Ltvtdupy3aPVanV8LFar1dTlotjtdo7FCLbb7fElsNvtpi4XReEqmJS7QzruMDVpBjOx8sWo2+12t9vtdrv4jfD4+BgfGRnNer0+HA4hhNVqFY9FDC6Hw0H1yeQ2m83URVi+/X7/+PgYPlwCZXC38xPhQEzF3SEdd5qapn5auGvlvbD2efkEP0mp7lOssgpHlYinPmcc1cgY1GPdWONOtucn5yqYlrtDOu42NalZn1J8Cjz+cW35ra/SUz6R16pJ1ut1PEAOyvjyPN9sNrGul1srL4Fa7VRMJLFakfG5Cibn7pCOu01NOphOz49oKTj1FRAqP4Aysuqlsd/vHYWbOvULcnkU9vu9L6vxuQom5+6Qmjv8IhLWp3Tq7rjkdlepyvP8VBZxOKZSHWwhz3M3xZuK53ljB9Nygju8R07OVTA5d4d03G1qEtbTEociir94ttw1GdypQbjKqqzF/8rGnWtJgavVSkbkbrk7pOxOUpOwnoo8z6utEne7nUqsye33+zj8wmq1cji4c4uvu4Lu3B0md1epSVhP1GazKU4MJso4qo0RxRTuxILvdjAUd4cELTs1CesD63jdHt8R8zyPP6Xt9/vYMDHLsgWfeSO45liUz+vb7dZPnEO5+IgwGg3ToYW7QzruKjUJ6wPr2AGo5SJfr9f7/T4O+1+ei1zgsmNRvnBhtVqpMhnW9VcHwFTcHdJ0D6lJWB/YUBdw7NHl6+AaF+y98rt42a3fpuJ8TllLL9L4uSuCe+bukLhlpyYvRZpSlmXl9d/IN8KY4rGIbwe057k38ZxvefmOi4K75e6QiLtNTcL69BofBA2UNrLyh7OlPpdDu1M3uVOvb4Q74e6QmjtMTZrBTCn+anPchbn8alhk06s0laO0nn2PIyxSeYbHBqDl5+X4dFMUCqbn7pCOu01NwvqUyi4RWZaVg/lXe5pPVrJ79fj4eKoZgB5FLN5ut9tsNofDYb1ex7c2lpeDk5875+6QgrtNTcL6xOLdMRw1FTUgBjCy9Xpd5vX4vRTtdrsJSwVQus/UtNgxKeclvi83/vvUm42B/7+9O8pOFIbCAIwrA1dGXBmwMufhnuZwICC1qOn0+55mFBLah5nfeHPDe+T/8/xzBFTor6UmYR0AACqlGwwAAFRKWAcAgEoJ6wAAUClhHQAAKqV1IwDAOxQ7su80Mznewf14R5SDrVTimv++0cqvoBsMAMDLdV03TdPWu+tO4SmlrZOY1o7Eua0Bi+c6xfFDUmINlMEAAHzY7XaLfPyEtm0fXtN1XU7qbdv2fZ/vmqbp6amfNo5jHJb85nl/I2EdAOBN2ra9r/R9H+/OQ3NKaeuyxesPq2Xyon7f93F9Smkcx/v9no8ofnPFyziO0zQdr/P5y4R1AIBPSim9LjRHLG5KlTYxXXwG2CnR4bOEdQCAD3tdaM4Bfavm5OEFz4n1+1jCf+m9ceX3H/D3WH8XAwDAuaJGvFgGk0U2G4ah+O5WGcy+/THDMAx938+vWUwUUxcffv1I+TnnogLnPiu8yRbDrkvw873zEeLFbwXaYRjyXFG1H+X7R+79IK0bAQAqEpsvzxoq/rA/4E4PxydmjJ2sbdvGmPHX2+3WfWnbNn+BkC8LuWo/Xo8anhhhsXw+juP84ocPFhdH0J83xonS+Zqr55XBAABUIULnicHx/Rn0er02TdP3fS5luX8tlue0PY5jXqqPy+L1SO2x+J13wUa8XjedjLgf3wY8/DEjqfd9P//8EN8nxFA1d5QX1gEAONMi+6aUclDekjfCLpJ3rMQ3pZL6YRiOhOxiUX48TzxYU/f+WmEdAIAzLYJ1xOL9baCR0YsFLXHjenH94HL44sbFh4EX7a89kZp1AIAq1Ly+e9AwDNfrNQ5airrzgwXxkaGnaVqH5lOKefLHgPXDRA19tWXrwjoAQEVOrJ+eH1y6IxeO/zywdl0Xeb1pmmma8vbQYpf3oiMP3BzbVPp/UAYDAPB5Bzu3fEseaj+FR734Wev6XddFz8FojxgvRjeYh/ceaW35nIc/XbV7TIV1AIDPWzRFOVcsdW/JzRa/O+z+Z4Bo53L/6ry+X2ryuqxc/LnWTyKsAwBQllKKpd/iiUI/kQ8hesUJpovIG73Pc/vz9RQ7IisX179TSpfL5ekwPW8ZWbwgJhXWAQBYiiOQcqH26T1JcuvDYiHK+gyjrUGaUpJe1JfnEdYHGC0u2JpifU1+wqd/M/k3UPx6IaZbn6taDxtMAQDeJNqkFN+KE4JeMWk+7HPepCX3Nc/X7IyQA/TlcokO5TlDL0Rnldvtls9hzROty1FyYUxOzLmTTHzDML/3Jyvf8TAxcs7lsa12mqaD/do/ZqeKHwCAU+xUhLdtGydx7ssVMs89wFaBTXFP53qi4tpz8criT7qYZT7a/K3iLMV797eiFg3DsHi2JwZ5v8v9Z1trAQD4LcZxnBelfHdFeb4Ldufe+SzNRgVLvmY91Pz2V5xVFF8vVNtYfUFYBwDgD/ldYd0GUwAAqJSwDgAAlRLWAQCgUlo3AgDwh5x+8tRL2WAKAACVUgYDAACVEtYBAKBSwjoAAFRKWAcAgEoJ6wAAUClhHQAAKiWsAwBApYR1AAColLAOAACVEtYBAKBSwjoAAFRKWAcAgEoJ6wAAUClhHQAAKiWsAwBApYR1AAColLAOAACVEtYBAKBSwjoAAFRKWAcAgEr9A2vqRIHKraYcAAAAAElFTkSuQmCC\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",
    "        if k=='data':\n",
    "            #Select OOT DT clusters to avoid unblinding\n",
    "            #cut = (dtClusterTime[k][:,0].flatten()!=-999999)#!=0)\n",
    "            cut = (dtClusterTime[k][:,0].flatten()==0)\n",
    "        if k=='signal':\n",
    "            cut = (dtClusterTime[k][:,0].flatten()!=-999999)\n",
    "        h1[k] = create_TH1D( dtClusterPhi[k][cut],title=\"\",axis_title = ['DT Cluster #varphi','Events'], binning=[50,-3.2,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",
    "        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",
    "            leg.AddEntry(h1[k],\"data, DT OOT\",\"PE\")\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h1[k],\"signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\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",
    "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": 63,
   "id": "ce57274b",
   "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",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\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.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",
    "        if k=='data':\n",
    "            #Select OOT DT clusters to avoid unblinding\n",
    "            #cut = (dtClusterTime[k][:,0].flatten()!=-999999)#!=0)\n",
    "            cut = (dtClusterTime[k][:,0].flatten()==0)\n",
    "        if k=='signal':\n",
    "            cut = (dtClusterTime[k][:,0].flatten()!=-999999)\n",
    "        h1[k] = create_TH1D( tr_cscClusterPhi[k][cut],title=\"\",axis_title = ['CSC Cluster #varphi','Events'], binning=[50,-3.2,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",
    "        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",
    "            leg.AddEntry(h1[k],\"data, DT OOT\",\"PE\")\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h1[k],\"signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\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",
    "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": 64,
   "id": "a6818051",
   "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",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+QAAAMECAIAAAC5e3jEAAAABmJLR0QAAAAAAAD5Q7t/AAAgAElEQVR4nOzdW67bRsIu7OKP3BorvneCjCSS+uuxOD5MYNtAR1rdF8kEEgdrKl/SkvZAAgN73ceeQPO/KJtNkxRFUpRYlJ4HRrAi8VA8SHxZqipmeZ4HAAAgPf/f1AUAAACaCesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0A4CSbzWbqInC1hHUAgOE2m839/f3UpeBqZXmeT10GAIBZ2u12q9UqhCBQcSZfTV2Aa7bZbHa7XQhhv9/HVxaLxfKzLkuIszc6uoSWebvMHg6UP87bfRNoPxAVye7V8lbUC/nvf/+7+Ptvf/vbRUrUoL2QAONaLpfF9RHOKGds6/W6y55fr9fty9lut6fMHoP1IdvttmW97fMWFotF351zgzruzMR3bHkrKm/98ccfxVs//vjjJMWLyvtwwmIAN2K73a7X6+KiP3VxuFrarI9pt9tlWdax4dr9/X2WZYO7pBytrx12u79cLlerVcd59/v9KZtwIwYciAR3bOXXlca3Gt+dRMcbZoBTLJfLzWaz2WwS+erjWmkGM5qi1Vov9/f3u92uV0uJ6Bw/vWVZNmCuwZtAu/v7+wSbG9XLUz4VtYEBEhTrPopv1Pi/SVWIRJvNJsGv/b567dhh21s5oN2njDdXfVc3vamr9q9Ee5OVoxrbtBxdZntTlr7znlgxcLRZzm2qHIhtq8b64Km3IM+/3Ir6mZNIact7b8JiwBVbr9fFlWKxWLR/7feauMtyhi2k/PUVZy9eGVaeRrGEJy4kfom1XNnzPO9ytR1rz8c2scXOby9Yea5e4WFYs8+O8xaFKXbC4DVOy1VtHEfPxaNRuP4xOHrGt3wC+66uZV2xQV6lZV6j8Xfr/JX3WMcviKMnxuXJwXDjWr78e128egXHQ8vptZDyN3As6rCw3l6AUcL60ctEPAot07Ts+b6XksYU0eUqdpmwXhSv42TF5ne5I0qQS+8IDiXjxjvRlvO4+5RHT/GjH49KwRo34dAX4qGCze7sv4Dyju2+f7ochUtq6V0KXL1K5XSsu2n5WihfpGItz4nfhMVyBi+kPP2wsL4uOfTTdK8FNi7haLV66Hbpb9zz3QvTspxh2Xr0Prj1KvNGjds+x2vZzIqboGG3/o2zdK/tPvrZOzpjZV19y984yxx/Wjq3Lgerfa4UwrpDDLfs6EWq/M1QxLJDTeY6fo3U60QrhemykMZcnmYzmJYiVRpJHtqBh/ZY42FqUayrcvVpObLdl9l3xhZHz4RDgT4WJoVra3fC+ql61UmX1eeqfJAGh/UuMx4N60fLn2wD66QM2znlk+ocXyh//PFHr+nPWhggZe1VmPXWCPF/G3Nhx6YL7cvpFbXnEtbj7PU93Hg1P5S5z73ni7cGXAjOEdaPblTLSmeXWAzdeKrGUVm69DWuh90uA7xU5mocg6Xy4pmGsZt7d/ULKB+IXv13y2dCZT9vPiu+xLfb7XK5zD47tMz1el1M8z//8z/xj+VyWX6eUaPyyVw/6MXvwvXl7Ha7orTlpWVfWi6X9dO442Tt6yovrfLWbrcr77RC90GN4qAN9SW0l/NQecrbG3fyjyVdytN3euioOJ8Pfbgqk0WNF4juV42WlRYLOXqdjeMqFn+X/7e8osoHeZKRzeJ3/iijlDQuZJQ9Hz6PkXDuq3/l+//Ql2pRwkP7rWUc7XhFntModlPfLcxbYw4+pcf00QkqL7bfQzfO0ljIYVuxremy4bejfHoM6xFV/4QWr//73//Om37YqS/taHpr/220vclj8Vb9cUiVbqntN42V3j9HJ+u+x/Ivfy3dHnvmV5eRFlpmbylG426pfzxjAb7//vvilf/93/9tL9I//vGP7hNDL+11ouVag2L6xlbdRxfVfcou9cSNF771l6PBjNKBtVykvnOVi9qljUos3qEp455vKd7pe36w7ottPCKHDkrxbv2t9l+EjnbVTY2wfpLGq3732dvD7qE0f3R1lQmGhfX6NPQ1rE9VJQuW3yrXXudNp1/9q6fxyDY6VJ6Wacq3AfWmNeUOSV1+WGjcoo7lLN5t+dE8HL42V7QcrF6/kLQvIXZAP7T2Xvm7mPL7779vnxLG1SvbHfqQ1rWHy47Rs9zUu3yFrXzu4q1FpV34JZv8HWoDU9d9Bw6esb5vR6mJ63ieVA5Kfmzg4JbFdrzJHLAtk5hNQdNUv9COeKN2KKxX4kJ7qdoDQaHXgDZ01H6YGlUOVmXnV/oY1Q9WrG5vLECc4Mcff/zjjz/++OOPenV7ezvIxgk6Vro3nk7tNdzlDa//UtSy0+oXvMa1VE7syg3S0f5b5YUU6jXu7VVBhwoWJyuH9X/84x+N5Yl61cHDiIqPXsuFr/7p6HJNWXwe27vx3e53CI2ZrP0bo3jr6MLH0n23HN3bZfU9370wcRX176jBeaDLIRvQNbml+vzovjpxiy5MWD9J/Vo74u34obBeyQTt9fHx9rS+nJYUeMhisTj04yZ1ld0+YJb6XI3xrhLQC5XJGjuVViJ7fZqOV7XGDWw/5RqnaVxLZcPrE7TngPoqGkvS8oNGxwnqRW3poXV0k//3f/+3mKAlrJcnU63OJZW/HLpM0z5lRcsnKB81rLcs/GKV6933TPtuKavs+e7ViMX09W+qU3ZLl0PWsvyWivDGQ9kS4rusLkHC+knq5/GIWfZQWK/H8fJc9SjfJaw3bku7xQnPRbsFlVrw9okbq5mPHqOWxVZSeMuq28Nlxxzc3vikcd768sPh7832n6d7VfA3Lr8+Zfu7LR/z8oYf3S3tiyqmaUnhHTcNxtWxjV/9hO+YGtsnHiusHyp5+9fRuHq1x+i+D0/c8/VZ2pujHHX0kA0+KI318V3OkO6tj1JgNJjhpupHXOmIXSlGpftz917bec+8vt/v7+/vOw5/cYPK+2S/39eHDSlbrVaVsYC2x3rcLxaLlt3+z3/+s/i7/ciWY319PKLyKirlKTegr99plGdcr9ddzsPFYnGoU3959vqiWoZRquyixhvXvhaLRcePVX2yenm6LOr//t//2/j677//XvxdbjYD5xPHTokfuhjmWs7h5XJZpI2Yn+KX4cVKe4pZX9dO3/Pr9bry/V9cSkYZteaQ8tBeZYembxyPKAahLl2MZnOUL3xzcE061liPu/z4VstBLL8ev0l7lbNLe5hGc7k9vZhhu7Hl6FTGRmxZdXu/z/aiHnqrXivTvpaORe1YP9fe7LKlkL1+3+g+ZYv2ora35zlUnkP7sONOhlF0/LmsyxI6nvznrlk/NFf3sVNOd6aa9YqW5uCNqzhUnsF75ugh65g9Gre9UqqjlfTluUbsZ3hWX3XZO6RmsVg01iZ2Gem2XXEXu9vtuoz7Xog3sme94b4F6/X60D4sH47277Vytfrf/va37mtvqYdor89uWUt73UbLiPJl7SOsF383DqLc8u4hp4wi3DKyb/hye4+W5/vvvz9Upx6+/Emk3HIdzmGz2RTndsvXVLvik3W0OjNe4w5dgy5TG9pr6KfEFYcvjivfMuWhdBEtl8tewWCA9qvbofH7Y6ni1hWnxzU9DUZYH27C82Cz2axWq/L/xq/O08N6scD4x+6z0OGZTff39/HBE8NWek0qB+Lol/7ys47LbLlSlr/pfvzxx6PPPOq4xsGNTzqeDx0zfXt7m/ZCtpek/dlPXZTTTDi2RafngH/961/xj++///7vf//7iUuDFrvdrmhX0B6Ud7vdarU6OtlRXULh6R+iQ8n13Hn0HOL3T5cDdKEC9bRcLgdX+RXfvbGesXsbmDCfQC+sj+zobesoDjVbHyusl5dQXkiR3Q99l8WPyokrvQKVZ5eOsk86Xj/Kk5Wr2LuofLt1zNx9A3TfycqOtgI/5OgXd/fCdLyDrS+k8sjS9vKEEBaLRVGz/vvvv5cTeXlz5hgsmJdYN9T9q2y/37dfCo9+3ovo1riceM6ffoE7sZCjGHctR78Nuuz57r2AzuHQQYnfmYe+Oes/xRz9jp3ZN+fU7XDmrb4/LzDOeuOqW148U9v6Q+nnxMVeh15NkzvquMADH/ROKk3PW0ZZ+eOPPw7N1T5jWcehl9tHISjeah96pXtLzUNlbhyxp0V9jR13S6HcuKU8gHrHUR1hFL0ee5R3G4DvlAcAdW9+nR9rs964UZdssB5135xD+yTv9sDOXmtpeUzEKY3mj663ceHdB5Ppfvi675AUiFYnabx495q9onzetIf1yqrji+VXijP+fB1hT9z8Kzb6ri63Zjk0sHp91X1VYnf9XCqUG0y3l6GlqAMyfcu62sdfb1l+ZTntHZgaLT4/gqBjUbuUJz8cyvsuB05RnPzrVvXpK199hyJyOWaVXz+UL1s+p3VHw/qhlV6y32H3MQTby1ZsVN89X1n1oSN46PUuuoT1Q2fCodcryl+MXQ7fvL5CZ1PQNDX2hOg4b3sWPzrB0fHUi4/f0bC+bTLKJtys0XdIx9xZrvD+8ccfT1xp/VwqtOfs4q2O363tk7Wsq73uvHtNdnk59Y2tn+TrA08HG2W3NM5SDLXe/cmmMIr6+d+o/Ikovx7roQ5NmbdGsfJC4i1Bx090feGNL7YUsv9+Gi5uV/d8eWjKynYd3ague76+nGG/FXf8faa8oqISs+NBKU95NMP0GoQnBbMpaJoa02rHK/HRoN8ehevRvLLA9uWUT+VTKsgHz3jFWqptBuv4hdV30MYWF2h8Uj57u0zW8oN4427pfhRaGuS054zua2y/Hzi6wCKs+6xxYaGbSgXQoR+j6p+g9nrTxuV0r9ltD+uHtq77zhlF9+DYsqMqi6pobznT/n01bM9XdG9M1RiNulxJD/2A0LKWGQ05rYPpSQ51JO/SzbQ+xFuvFrGH+pgOMHgwJn1JGw3oN3lUy3AoZ3JNvUuPLv9QYSp9qfPOwaW9qAPOitjT1HCNXF73074Qh88rd8VuGfBqWXraTl15OV1Gzeqy8PKLeZ6fsvxRFGs8mhyOHou4aeUtCrWBIioTd1zOiXum/cFG9SmLwSq6r7r9RKqY32DTE90kXI9DY4K2z9UYuSo3eUcbmbTktvJtaJdmMO1L6LUVR+e6er1+jOui3GC9vSagHOa6NINpOdwtx3T03qUtk12ggr9lOd1/gc2P9ZfttajC999/X56r+LuoaAeuQPy+umRD+Vs2x739/wVOc+jOLMuyxmq/3W5XPKu546IOGWvMqUO/D7QvpLE+vuNDyK5b97G9ByzwaE/HxrkalcvWfuPXUp7645A6/gjQsVK8Zfjz9rrqYTXZlSkHPBfs0BpPHyas18EFZiR+Y/hcX0b7KJBpEtZHcKh112q1yrJsuVzG33SWy2WWZeWHGXVZSIuxwno4ELL3+31R/uLnsGJDRrnfoIty7jx0/kTl6Lzf71ueiLRer8tHsNIoqz3pdryitJ+EHTP94EcvdW+jNUqzpSzLOk7ZqyFTeeJizPVyH1PgOsSrsGvoBez3+8Vicfn2TieZumr/SpxYo9ze+aPleHU5rEebwbQvqrsZ9dU4n/KZMNavbC0nQF0lCzZ2My23lmmcpr1FR8sGXrJ36VhDr7Q0yCnvpUObU//sn9gmp6yxYXr32YEZid9pU5fiys10J+tgOo54N1zvM9rFYqQnXJ4oz/PutYN16/ValUA4T+/SQpdK2djOqvjf//mf/ymPflV5xlsI4Y8//qg3ZWnZinJt/bl7l16ggj+01sEvFotiLavVar1ex65OcZbd5+da1wtW6Sg24lmhXylcq/jt3b0vJgPs9/tZtted+m7hqgxoytJSrdilZr0xvR16oEDZoeq9YYONqFMvdNnJvXTvXVoodwBtd2h4x/I0lbfaR4cct3fp4Ar+9hm7Lyfv/ItT45TFQob1Lq0XQL9SgBukzfqY4shBHW/aYjI48Qa6cfZTlrnb7XrdcoyyFdfqwr1LC3/729+O5vU4Vky9Tr2ifjKP0ru0429QLRXSF+hdGh39OMQ7qFDb5Mb+oCeOvKn/GcANyvIxGitTF/tihtr1dbFYxD6ak5Sql9ivtJ4PYs+MScajpZd///vf//znPytxf7FYDGuvdcvqn4XGD3J5iKTtdjvKB6Ro1PSPf/zjn//85+kLBGBehHWARC0Wi2IQGN/VALdJMxiAFP3++++GawTgdmvWd7tdfcjqm90bQGrKo/r4agK4Wbc+dOMsR/ABrl25K6rhGgFu2e2G9ThehGFMgET8/vvvf//733///fd//etf5QYwf//736ctGAATut1mMHHchpvdfCApP/7447/+9a/6676jAG7crXcwXS6XWZbFZ4ZNXRbgdknqADS63bBeDIe8Xq/jyNPl7lwAE/rHP/4hqQMQZt0MJj6Up6VGfPdZnLgyZXygSfHUkjg4zHq9VsUOTOL333+Pf2ikDkBhrmE9ZuvFYlF+rnjZZrOpP6ax/ZmCWZa1LBAAAC5srs1g6kOklxVJfbFYbLfbYnzG9rkAACApMwvru91us9kcbVwek/p6vd7tdrEBTPEDQmzlstvtsiyrV6K31LsDAMCFzakZTL1lS2OrlWKyyqZVXo+Jv2gYYyRHAABSM6eHIpWrvXe7XTGcS0WM7+Xn/0WVrL/dblerVblhzHa7Ha+wAABwsvzMYpPx7XY77mJjM/TFYlF/K27Xer0+9Fa5MNvPjq5xsiMEAMBFDE2mZzRmzXqsui6Pflg0Lm9slzKV2JA9/t2rkXoi5QcAYHRpPnJntA6m9QblRQ4uWqRcsvtm47rqbWMAACBZo4X1YgCWolo9tinfbre73S7WSe/3e6OYAwBAR+OE9aJPZ5HUi1Be1HDHVubCOgAAdDRmWK+M1hImbXbSeFdwaACZjrIOTlk+AACUnWvoxtgqpqhoT8rgpvM6mAIAcEnj1KzH+FvpYBqa6tovIFbna28DAMDcjRnW4x+bzSa2Bim3gYnPBw0XqWuPq6i3eClWfclBaQAAYLDRRoOJj//c7/dF/XpRt51lWYzOl2nCfmgM9WK8mguUAQAATjdaWF8ul9vtNsbxxWIRs3vZer2+WNOU4s5huVzudruisj+k2oweAADqxuxgGpNx/fXL98tcLpfr9fr+/n6/369Wq7FK0mWwF51QAQAYSzZWuNxsNsvlsr05eJdpxlVup37ierNstH0FAEBq0gx7o5Upy7LFYtHS0GW3261Wq/IjTuclzeMHAMAo0gx7JzWDKaJ5/Y+6mWZ0AACYykk3EMWAjN1tt9uZjpyY5s0WAACjSDPsnTQaTK/YvVgs1uv1TJM6AABc3uXarM9dmjdbAACMIs2wN9rQjbdQa27oRgAALinFG4g0pXmzBQDAKNIMe2M+FClqbwlz9bXvAAAwljHDulYiAAAwopNGgynrktQBAIDuxgnrRdOX7XabtxpldQAAcAvGDOu3MCAMAABczGjNYAAAgHGNE9ZjhfoVPxEJAAAub7ThJJfL5X6/v+JW6R170F7xHgAAuGJpjrM+WjOYWK2eZdlmsxlrmalp7zurBy0AAOMauWb96GTzjbNp3mwBADCKNMPeaGW6+lYiaR4/AABGkWbYG+0JptvtdqxFAQAAYcSa9auX5s0WAACjSDPsGWcdAAASNX5Y32w2y+Uyy7KiFftyuTQEOwAA9DVmbf9ms7m/vy+/EhceU/tisZh1ZE/zlxEAAEaRZtgbrWa9SOqLxWK73S4Wi+Kt9XodQtjv9/FBp/OVdTB1GQEAuB4jD924Xq/jQ5Fidi8WvtvtVqtVMHQjAABJSjPsjVOzHtu3LBaLQ48vXS6Xsa79ip9vCgAA4xozrLe3cpl7GxgAALiw0R6KFD5HdgCuUvuXfKyR6VJ3M67dblcUbLlctqy6+5R9J+5ot9vNpd7q9OM4+plQ7L2W3VhfaXsxuuSWwZtw+c8CVysfQ/H40uKV2Km0PE2cYLvdjrLGyxtrXwHM0dHHVMfJRryyDC5S44WmPOxBYb1ed19s48R9S3viQi4mhLBYLE5ZQtzh3S/6i8WiZY3r9Tq+G9PFod1YWWmcuGWx7af0iSdzLMzg2ZlEmodsnJr14sbx0JDq5QlGWSMAk4gB6JDFYrHf709cRZZlR0f7LcYtKHeX2mw2+/1+tVptt9vy5aYYQTg+CSTWmt/f38dBzMqdqcqLLSrUD008ubhdeXr94QbY7/eNN1TRmX6UqJzM8RC3n+FntVwu9/v9dRxQxjRi8C+WWXze4q1w8fp8q9XzVG+2AC4jVgyfWNvaUZcVHbqsFEmr8krjAuvXweLiVZmy/gNyX+eoWR/9Oj6i7jXrxb5trwKPf4xbs15fy4j7c0DNusr4yaW5/8d8gmkxvHpRrXJ/f1/8XannAOCm1GvKy+3Ce4nV2+v1un5ZKWq+iyXHPxprxOM1qzJl48hmfcc0G7cT14Ad1WWWYYUcfNTqNptNlmXxp4z2yUZZ3fn02iG7z/qu4uhvTSMeGtIyevzfbrexQj1ar9ezrlAvnGNfAcxFx5r18pWlqEuu1HbXG4UXFaWVhhCHKlDbr1/xMlRceuIyDy2qfIU6Whl89IpW37Ri+krNetwnlaXVX6zskGL/V5pqlI/LoVmiWIainIc2pzxjnDju1S5Hp1yMo7tr/VnL2RWzRHnDJ69ZL45UZW/Xj129eI37sH7mVNZ16IDWJ6jvn8a5eu2Z29HxBLiwFMuUpjSPH8BlDA7rRUAp5i3+t5zjY7woJ8KWZNw9VOWlGHQ0avda7NEVFRtefrdXWB+woxpnKR+1xiPSuCsqYb245ymvumVv9Opg2n521ZNrImG92P/lRr+Vu8T6LJV9WClt5YCW2xWX19J9sbmw3scp3wDnM2bbrOuoQT8kzeMHcBnlhsV1xWT1eFqJVvWm2/Wg1h4jBrSer1c2N16wTgzr9dnL4XtYWK/Xi5dX0Zjb6rWq9VnaK8XzprDesmmNxgrr8a3Keg+dh43x96xhvbyBla2ohPVD+7B8LCqzNO6Wyo6t1993/EAJ643SDHujjbMeO+DH0y795mXDxH737XKduIGrNmCwl8pwK+HLNr7L5fLc35xFc9443EdxwVqUxpw5sbFv0d69/OJms4nrHdBlq7E87Tuqcbya7Xa7Wq02m0359QGX6cqmLZfL+/v7C4wcv9ls6s08wqDzcHSLxaK8+fHvQwWrN3SJ+7Bl+fEwVQ7WbrfLsiyeWvV3uUqjdTAtPsb39/dZlh0aw3HWutz9TF1GgDNqaajQMkv5f2O22O/35cBxAcvlcrPZxNKWh0MoamFODJ2HktNutxsWp4rk13dH7WrCGB1epxoiYr/f11fd3gzmYhoLFg7s7fJIoPGsONqztsj99QNavFV+YlfHxTI7o4X13W6Xf35sQfhcb3GtqR2AjuqBpsjK9/f3xZWi7wLbK1ZjNG95N16zDpVwwGLPcaUr0mevHbX6Ur3u9sKJ9hS7eT4EtPFkiL9CxNFv4nHpeCBWNZUJ4mLjkrsvlhkZc+jG8Pknv7zUnKtI7X6pASCUsnK5hnvEQBYfjVQEppaMG1smFLl/8eVIjhW73a682IozBcpiR8WravmngEMaq5xnWmt2qA1M4hpPhtVqFR/8VDQ375iL2n/Jz7KsstiZHmtajBzWC8WvjcXHLDaPOdPqAJiF8lDQ5RruXk2Q45XlUD6uN91uX3hRExlnOdSKIL57aKVFC4fK673qqiqzl3dUvKq23060LHamAW7cu7jR1ffqoZ8CiicD9Grlf6iOvNK6KXa96LWjZno+3KxzhfXCTG+LATiH3W63Wq0qWaHvD/dFw/d6Di5eKbJLXHhjlKnk7/of5WLHxH8oecdZKm1O+v6kXL6piI2PK0toD2TxalufZaaNmNNvA1O5CSxOkkMq23L09Gi8P4wnRvkT1GWxlYJp7DAzh35eOVH96Qlh5oMEnW9fAaRv8Djrlb6AlcHI6+OR591G0CsPJVmMMF0fvK+8wPJKy1eoxsU2lrB9xMPycH71wcgre2P75WOJyuutDJpeL3PLjuqyb7tci0Nt6MbG49iyQ4pVt4/1WV5a5fV4QCtTDhhnvWMZ8hPGWW8c4Lw8qGL9cJf3z6HyF0WKrVxazoH66Pv1aYoVNQ7AT9TxBLiwkct0KKNfwRDsaR4/gMsYK6znTQ9cbEyc7Vkw/zLgljVecRor7w9tTuPEXS5k9U0r5qrvjcpa4l1HaMqah4pRD3z1fbKojdR+4bDeqDJx49nVuM+HhfUuZcj7h/X68lsGTa8f7rx0qtcLfGjGym5pPOUqN2n1s6Ljx/kGdTwBLizLRxptcLPZVH7+i+OPXs1PLVk22r4CoGh3Wx57rvJulytIeTnhWKuJ9pWeMnF9xrFW0WVHVd4aXPKkVMaGT0rMPNvtNva7OOVwbzab8v8OO6BFg5lDiy0vJNm9moI0w95oZSp3Hr3K5yKlefwAgAsrh/Wpy8KY0gx7oz3BNFxpRgcAgKmMFtYTvBEBAIBZO/vQjYWUG58BAHS0XC49KJSLGdg0Jw6UG2oV6rE/UGO/0tiofb4V8Gk2YwIAYBRphr0x26xHvZ5CBwAAHDJ+WL9i5RFvDknwhgwAgJkS1nsQxAEAuKTLdTAFAAB6EdYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEnXq0I3L5bL8v/GJSPv9vvI6AADQ16lh/dDzSj3HFAAATjQwrC+Xy8ViMW5RAACAssxTOTvKMvsKAOBqpRn2dDAFIA1ZFrJs6kIApEVYBwCARAnrAACQKGEdAAASJawDAECihHUAAEiUsA4AAIkS1gEAIFEDn2AKAKPLQ0h5oPXdbrdcLqcuRdjtdo2v18t2aMr2uc19WpoAACAASURBVBrXWCxquVwenaU8fQhhs9mcqWBwE3K6sT8BzuQ//+///efNm/+E8J8Q/vP11//5P//nP//v/01dqKrtdhtCWK/XUxckX6/Xh65B2+22POXpl6241XUt+2GxWNSnXywWR6fpvgo4kzSDnJr1HvL0nkALMHf542P44Yfw7bef6tQ/fMg/fgzPn+cPD9mzZ9OW7URZloWzXTsWi0W57nm32+33+9VqtVgsinrrSqy/v7+vv9hiuVzu9/u4rqJ2fLPZ7Pf7+/v7SvV5LMNqtSrKFou32+3u7+/3+335Qe6bzaY8byx8ZYvUrMMnE98szId9BXAO/3nz5j8vXuQhlP/95+XL//yf/zN10b4woGb9TNfZmLbrJSlqwSv168PK07K0Q2/FFxt3UaxKr9SvV95Vlc7k0gx7OpgCMKl377Lffqu8lr17F969m6Q4FUdbV+8+67XMvrN0sVwuY4yO1dsnigvZbrf1Gu7GFcXJ1ut1vYV6+Lwb9/v96FsNV09YB2Ay+ceP4cOH5vc+fswPvXV+u90uy7Isy1arVZZljU0ylstlnCDKsqzIqXH2+HdcTvn18izjNvYolnZiJo4bUmmXUllRrA4vNjk2mGlM6lHM9y0TAI2EdQAmk93dha+/bn7v7i479NaZldter9fr9Xodm4OXpynac6/X6+12G5umxJbc8d2iaXicIP4dF1LMslgs9vv9uHm9S9/No+JWtAfrokl68d/2Vcfp404DutPBFIBJvXiRf/yYfdnoJX/1Kjx5MlWJikhdpNXlclkJ6zF05p8basckGsN6/Huz2cQOneWumeXFxsmyLBs3v8a7iBNHmexSpOVyGXuOhs9hXZdQOAc16wBM6vXr8P59/vJl8UL+6lX488/w+vWEhQpf1isXrT4K2+320LCGLQvcbrczagfSHr4HR3PN1qEXNesATCl79ix/eAi//JLf3YWPH8PdXXjyJDw8ZN98M0l5DrXoKNq9FP9bnj4OUHh04eW5ztHHdFzt1fODC68CHnpRsw7AxLJnz7Kffso+fgwhZB8+ZD//PFVSD4dbdFReiUG26C16f3/fpbH4ZrMp+q12CfcDjNIiJW5Lexwv39WU268D4xLWAUhFNnUBwuGYW0miq9UqPsenGGv8aPuW2Mg7fO5gmuf5OdJtrP4/Max3Cd/lu4IunUeLEWZOKRjcIGEdAP6r6Cpaeb2cXIuuor36cRZ9UjebzZmagowViONyWoZFj88cDaWW/eUq9kaV7rZAR8I6ADSo5NR6tXElmA6IoY1ReHB1ezH+zCgV9sVjj+pLK4a2LHexLR571Lgf4r5qGbgdOERYB4AvFDl1s9nsdrvY0Lw8QUycRZCN9evlQQyjxpbfcZnxj2I4yGKamIMrq2t0f3+//Cy2g49Jve8YNYcUQ8WvVqvlclnsimIUy/V6XUnecdX39/fx+VDF9HF4ysVioVE7DJHTjX0FcF4h5Ml80xaPNCrEJLper+MElaYmi8Ui/zzmenG9KC8kz/N6jI5PXCqWX56mV9nKZWgx4Lp/KPoXLfXrGhvhFPutZZb2aeAC0gx7WV76cqFFltlXAOcUq5NT+qaNoyvG2utD74YQyhPEuuTKEI1dXilaj8TK9aSuOOVRJg/tjUOzdJweUpBm2EuxTGlK8/gBXI/0wvokYgMSLUbg8tIMex6KBACpiA9XGqvdOXAFUryBSFOaN1sA10PNOjCpNMOemnUA0pDeNRJgcoZuBACARAnrAACQKGEdAAASJawDAECihHUAAEiUsA4AAIkS1kMIYbPZZHF8XwAASEaKY79f2G63W61WIYT2XZHmOPkAAIwizbCXYpkurKhTF9YBAG5WmmHv1pvBLJfLEMJ6vZ66IAAAUHXTYX232+33++12O3VBAACgwYzD+nK53Gw2LRPsdrvNZrNcLg9NuVqt1ut1rFwHAIDUfDV1AQaKleItE2w2m/v7++J/9/v9/f39drstonmWZYvFoj3uAwDAhOZasx7HbzmkSOqLxWK73RZN0ou5YkbfbDa7z0IIxR8AAJCCFDu9toh5uqgyXywWjfE6DvCyXq/LFeflFyv17mWHdkiaHYQBABhFmmFvTjXrm81mtVodCtnlySp/RLF+Pc6+2WzykvjWdrtN8AgBAHCz5tRmvdwTtKXNeqxrXywWlddbatPrywcAgMnNLKwXeXqz2RwK6/H1luS92+2G5fLi8UknUn8PAEAXc2oGM5Z6M/fYKubojPlIzrJVAABcnasN64115/W2MQAAkKyrDesAADB3wjoAACTqasN64/jr7Q89PSrr4JTlAwBA2dWG9RaDh2jUeRSAMN0Trz1mG27QFYb12IvUNxoAZ7JarSrP3buA+GRAVze4NVcY1uMXaL3FS/HF6uFHAADMwhWG9SKLV0J5fHzper2+eIkAuCp5nqvhBi7jCsN6CGG73YYQ9vv9crnc7Xabzabo+nn5Hy4BrkqWzfVff33bpneZePfZ4AmAm3KdYX25XMYa9P1+v1qtYp16CEEHUAC6iLU8q9VqtVrFwb7K6TnLssqPt8vlMk4f39rtdlmWlZtfxjqjYplxyspKi4UUE4jswFzD+mazaf8VMk6w/my73Z6e1A3dCBDyfK7/OttsNkXLye12G8ctWK1Wh6bPsmy/3y8Wi3jFifVEjZMtFovtdlsss3zVWC6XxUK2222scmpZKXAjvpq6AOc1bqMXFfMAtyAm9eI7f7fbxSTdOHG80KzX6+KKU257WbZYLIo6plj1Xn43Lr+YINbc39/fx7WfsDXAvM21Zh0ALma32x2qr4nJvlI3FCvOK9qnGeUXYOD6COsA8IXYBKVofT5gCY114e0V5MW7sXdp0RQHuHHCOgB8YbPZlEcpqHcwrajXow9ouBKbuxQdTCV1IBLWAaAqjlIQO3oWHUwP5fV6c/a+9fG73W61Wu33+2JEhDhGwpCiA9flyjuYAkBfMWovPwufx4fZbDZnGksxLna73epLClSoWe/B0I0AtyA2RCm/0pKhY717pfNo30YsjfcAWsIAQVjvJe9g6jICMI7YuzSK2b1xOOCYs4t69/qYjB3XFZcfl1YertFzkeDGCesA8IVY8xJ7lxa17Ov1+lD9+na7DSHc39+XJ+61xs1ms1gsiv6scSHFYrWNgVuWqQzuKMvsK4AbEqvJw+fG6x2njxPHNu5926AXayyq8MvL7Fl8oLc0w16KZUpTmscPgGkVrV/KL8YnnrpqwLykGfY0gwGAk+z3+3LN92az2e/3jQ8xBegrxRuINKV5swXA5GI9euVFlwyYnTTDXoplSlOaxw+AFJRbwmhiDjOVZthLsUxp6jgUl/0JADBHaYZ1TzDtIcHjBwDAFdPBFAAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQZZ72HLs9FMhY7AABjEdZ7EMQBALgkzWAAACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACTqq6kLMCdZlh2dJs/zC5QEAIBbIKz3IIgDAHBJmsEAAECihHUAAEiUsA4AAIkS1gEAIFHCOgAAJEpYBwCARAnrAACQKGEdAAASJawDAECihHUAAEiUsA4AAIkS1gEAIFHCOgAAJOqrqQswJ1mWHZ0mz/MLlAQAgFsgrPcgiAMAcEmawQAAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUV9NXYA5ybLs6DR5nl+gJAAA3AJhvQdBHACAS9IMBgAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACTqpsP6ZrPJPlsul1MXBwAAvnC7YX2z2dzf36/X6+12u16v9/u9vA4AQFKyPM+nLsM0sixbLBa73S7+b8zuLXsjy253XwEAXL00w97t1qyHEDabTfF3rFYvsjsAAEwuxRuISSyXy/1+r2YdAOA2pRn2brpmPYSw2+1iB9P2pA4AAJc347C+XC7L7VjqdrvdZrNZLpctUy6Xy/V6vVgswueWMAAAkIgUa/u72O12q9Wq3EO0InYYrby43W4PJfK4wPV6fSjWp/nLCAAAo0gz7M21Zn21WrW8WyT1xWIRR2aszBUr3cuzqFYHACA1MwvrMWRnWdY+WUzq6/V6t9vFNjDFfVKR0e/v7439AgBAylKs7T+k3rKlsRlMMVll0yqvx8RfTGM0GACAW5Zm2Ptq6gL0UG6pstvt9vt942Qxvsc+o2WVrL/dblerVbmSfrvdjldYAAA41czCepHXN5vNobAeX29pgx7bxiyXyzzPi4r5Lm3Wjza/6SjBmzYAABI0p7A+lhjW49+9+pUK2QAAXNLMOph215jC621jAAAgWVcb1gEAYO6EdQAASNTVhvXGMdQP9UkFAIAE3WIH08EPK+0yGoxOqAAAjOUKa9ZjL9JzPJ0072D0lQIAcLOuMKxvNpvQ1OIlvh5OqFkHAIBLusKwfmgM9fj40vV6ffESAQDAEFcY1kMI2+02hLDf75fL5W6322w2RXPzon4dAAASd51hfblcxhr0/X6/Wq1inXrQ+xMAgFnJrju/ltupn9hUvctQMMH9AADAPGVZisE4xTKlKc3jBwDAKNIMe9fZDAYAAK6AsA4AAIkS1gEAIFHCOgAAJEpYBwCARH01dQHmpMvojQl2IgYAYKaE9R4EcQAALkkzGAAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAAJAoQzf2YJx1AAAuSVjvQRAHAOCSNIMBAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkykORevAEUwAALklY70EQBwDgkjSDAQCARAnrAACQKGEdAAASJawDAECihHUAAEiUsA4AAIkS1gEAIFHCOgAAJEpYBwCARHmCaQ9Zlh2dxlNOAQAYi7DegyAOAMAlaQYDAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkKivpi7AnGRZdnSaPM8vUBIAAG6BsN6DIA4AwCVpBgMAAIkS1gEAIFHCOgAAJEpYBwCARAnrAACQKGEdAAASJawDAECihHUAAEiUsA4AAIkS1gEAIFHCOgAAJEpYBwCARAnrAACQKGEdAAASJawDAECivpq6AABwFbJsyFx5PnY5gKuiZh0ATjYsqQMco2YdAEbSq5pcvgc6ULMOAACJEtYBACBRmsH0kHX4yTLXVQgAgJEI6z0I4gAAXJJmMAAAkCg16wBQY6gWIA3COgB86ZJJfcC6tMmEWyKsA0ATmRhIgLAOAFMYcDOgcQ7cHh1MAQAgUcI6AAAkSlgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUZ5gCsC18+BPYLbUrANw1SR1YM7UrANwA/J86hIADKFmHQAAEiWsAwBAooR1AABIlDbrADArA7rMarIPs6VmHQAAEqVmHQBmYkAFuZErYeZuumZ9s9lkny2Xy6mLAwAAX7jdsL7ZbO7v7xeLxXa7Xa/X+/0+U/0AAEBKsvxWO51kWbZYLHa7XfmV9Xq92WwOTX+z+wpgxmJFzM1+gd/45kMfaYa9261ZDyHUm76UszsAAEzrdjuYNt45abkOAEA6Uqzt72i5XC6Xy0OtVkIIu8/ixC1ThhBig/WWvZHmLyMAHHHj7UBufPOhjzTD3lxr1ne73X6/b5kg9h8t/ne/39/f32+323rdeTHldrs9Q0kBGJXBAIBbMtc266vVquXdIn8Xg700zrXb7bIsu7+/X6/XeZ5rAwOQOkkduDEp1va3iM1aiirzynAuhdimpTK0S+XF3W63Wq0OLaFxmfPaVwBXSKOOvuwx6CzNsDenmvXNZrNarcqNWw5NVvkjivXrxey9kjoAAFzenNqsl5uptLRZj/l7sVhUXi+3Yi8yeiXQx06rI5QVAABONrOwXiTpzWZzKKzH11syd5HU9/t9ZSHF6DGNxnrEaYK/sAAAkKA5hfWx7Ha7zWYzIDEL2QAAXNKc2qz30lizXm8bAwAAybrasA4AAHMnrAMAQKKuNqw39hNtf+gppCjLck+BAYBbdbVhvcXgwRmzDkYtKTctf3zM376NnZrzp0/zN2/yx8eJywQAXNYVhvXYi/QcTzvKOxh9pdym/PEx/PBD+OuvLIQshOzDh/DxY3j+XF4HgJtyhWE9Pueo3uKleP6Rxx4xA7/+Gr79Nvvtt+KF7N278N134ZdfJiwUAHBhVzjOepHFl8tluX49Pr50vV5PUSg4ptaGqt6mKnv3Lg8h/Pzzf1/yYw7QxYBWmr5eIA1XWLMeQthutyGE/X4f8/pmsylakxf165Cs9iuk6ycA3I7rDOvL5TLWoO/3+9VqFevUg0eQkrI8L/5leR6+/rp5sru7rDTlZYsIzFD5G6PjPyAl2XXn13I79RObqncc6eW69ycXk795Ez5+zN69++LFV6/CkydZuRkM3Jr4Veyb9qzsZG5VlqUYjFMsU5rSPH5cq/zxMTx/Hr77rsjr+atX4c8/w8ND9s0305YNpiRHXoCdzK1KM+xdZzMYmLvs2bPw8BDu7vIQ8hDyu7vw5ImkDgC3JsUbiDSlebPF9cuyPITMuce1GvYsOZ+Is1Kzzq1KM+ypWYfU9c4yWTYwAMGFOVEBjrnCcdbhqgy6xc8HRHyYSnr1WADpULMO1yN/fMzfvo3BJ3/6NH/zJn98nLhM3JT4q073fwAcI6z3kHUwdRm5XfnjY/jhh/DXX1kIWQjZhw/h48fw/Lm8zoX4AgQ4gxTb0acpzT4HUMjfvg1//ZX99tsXL758Ge7usp9+mqpU3BC9Eq+GQ8mtSjPspVimNKV5/LhpX1ZkHmqnXn3dacyZSHhXw6HkVqUZ9jSDgWvQ/tWS3BcPANCNsA6zlefFvyzPw9dfN092d5eVprxsEQGAkxi6Ea7Fixf5x4/Zu3fl1/JXr8KTJ1OVCAA4kZp1uBavX4f37/OXL4sX8levwp9/htevJywUAHAKYR2uRPbsWXh4CHd3eQh5CPndXXjyJDw8ZN98M3XRAICBUuz0mqaOY6jbn0wvy/IQMqciF2YIkavhUHKr0hwNRpv1HhI8fszMpS6BHk4DANdBMxgAAEiUmnW4qEOPLhp1HX4CAoAroWYdhsqy0K0nQwghf3zM376NITp/+jR/8yZ/fDxf0QCA6yCsw9nlj4/hhx/CX39lIWQhZB8+hI8fw/Pn8joA0E5Yh+G6Njf59dfw7bfZb78VL2Tv3oXvvgu//HKecgEAVyLFEWrSlOZoPkwif3wMv/4afvophBC+/jq8eBFev86ePfvvFF82jznUTr36+oQnmJHaOJ2z6Go4lNyqNMOemnXop2+blvYPfXJfCVCIvTK6/wPgDIR16KlLm5Y8L/5leR6+/rp5UXd3WWnKM5f7CLcNV65v8ha+AdJg6MYeujzENMFfTzhV7bjXz4Ps3bs8hPDzz/99qXwmvHiRf/yYvXtXniV/9So8eTJiMYf51KQn/v30aUOTHq7A4OTtCw1gamrWe8g7mLqMnNfANi2vX4f37/OXL/875atX4c8/w+vX4xVtCMPUhNBvCM55K/+M0/Eft8yvMZAGYR1CCK2J7eQ2LdmzZ+HhIdzd5SHkIeR3d+HJk/DwkH3zzdib0ZNhagAgbSl2ek1Tmh2EGU3n0Q/yN2/CgTYtWbkZzIG15CFkk4/68tkMhqm5gFsY+OIWtpFpOce4CmmGPTXrXNYV/FR6WpuWdDbeMDWFm9pYAOZFWIdPOia2dNu0dDHDYWrOJ398zN++jZuXP32av3lzW431AZgDYZ1LSy36DUhs2bNn2U8/xTry7MOH7Oefuyb11LLvixflnwii/NWr8OLFJMW5JJ1rAZgFYZ0LSbMW88TElk6bloFSHabmEnSuBWAOUmxHn6Y0+xzMxadMXMpG+cuX4f378PBwfEjvc/Zbyt++DX/9VU5sn8p2d5f99NOEBbuY/PEx/PLLpxHi7+4+jbPe5YeCvpufwu4q9Zfo2rk2TF3mUaSw87luzjGuQpphL8UypSnN4zcXCWXiEYdDuaaL04BhauYc1mMhDh366ltXcIhT2PlcN+cYVyHNsJdimdKU5vFL2li1mGcL6z0S29Uf+gE7eY5hvSR/+jT78KHh9bu7xte/kNi2HDe7AjM7zjGuQpph76upCzAnWYcxBxM8xpM7OkTg0d3aZZrOpflvcbIQ8qdPQ2My65LYbl7f4zLmcTzdixf5gfHypyoRANTpYNpD3sHUZUzJgCECv9yBl+iTesPDoQzW97ik2bf4pjvXAjAfwjoX0T8TX2hkPYkt6jymZN/jkuwIiSeOl+++HIDLENa5iAGZ+CIj6837CUeT6HtcEh4hccB4+Yn+SgDA9UqxHX2a0uxzMCOdhgiccGS9AcOh3Ihh4+cMeH2UvsXnnOWkEUinpfMf5+Yc4yqkGfZSLFOa0jx+89OeiSccWc+V5pBh4+cMmD79sH7KCKTTcnpzbs4xrkKaYS/FMqUpzeM3P92D0Skj6w3gStNN3+Ny6RESR5/lMr/2dBhpqmnFcx03kyvkHOMqpBn2DN1Iqoysl6a+x+W04zhgtMczDRB5+gikBw1L6gDcBh1MSZVxWtLU97gMOo4D+nEO7/rZPhLOySOQdlVZQrGQ+uvp1foAcD7COom69DgtMlA3fY/LgOM4YLTHCw0QaVR+AC4uxaY5aUqzGdOYkm1xaJyWNPU9Lp2nH9CP8zJdP/PHx/D8efjuu6JVz6dfCU68hzz00Wv5SJ67jTv0Nbg1l9OSlKQZ9lIsU5rSPH5jSjish5BkwW5c3+Nyjn6cA2Y57UTqNAJpX4fD+sHbG2Gd1AjrXIU0w16KZUpTmsdvTMlm4mQLduPOE9b7jg7Ze5YER+Wv7Zn88TH8+muIvwl8/fWnW4LEh3KHvny3k540w54260AChvXjvEzXzybnG8DlQu3vAZgJYZ3/Su5ekts0oB9n+l0/s6xrO4Fffy0/JDWEkL17F777Lvzyy7nKBkDCUqztT1Oav4yMwm/uJGVAP85zdf08ZNxHL30Z4i/W/h4mphkM6Ukz7KlZ7yHrYOoy9uY3d1IzYLTHSw/0eTZHH70EwK1J8QYiTWnebJ3uMmPewRAD+nFeZqDPc9Ssf34rf/o0+/ChPlV+d9f4OsyVmnXSk2bYS7FMaUrz+A00bJi8GW2+a8B1GDcTT+voOIxFWH/zJnz8WLTn+fTiq1fhyZMsDhkJ1yHZTys3LM2wpxnMTfObO5xb/viYv30bP03506f5mzdH2pi9fh3evy/3l/3U/v716/MWFIAkCes3adIx7+B2DOgTcjXt7wEYRYq1/WlK85eR013nb+5+Xb0O828G06lPyIAnmMIVSOzTCiHVsJdimdKU5vE73aXHvLsMKec6zDSsj9UnJIVtgfNxhpOeNMOeZjC37sp+c+/dPpiUDWh/lVKTLX1CADhdijcQaUrzZmtM86+N/tQ+uPT0x/zly/D+fXh48IwnJtFpHMbDzWCaX4fr4AwnPWmGPTXr/Nf8HulU4TntpObFi/K4LlH+6lV48WKS4gAwOyneQKQpzZutMd1O++DrPo6kpFOfEDXr3CZnOOlJM+ypWedKaB9Mgk7qE5JS+3sAppLiDUSa0rzZGtNMa9ZLPKeddHV+gincCmc+6Ukz7H01dQFgPC9e5AfGjJ+qRHSVXarHRN9v4fEKlo26tNFc5i59/nUBAFPRDIYr4jntM5VghI2SLRgAN0NY57P5N5C9sjHjb048A8/3b9qCHV3UKLLMDUY/9hiQvBSb5qQpzWZME0t2aPZkC0ajyzR4mLYlxjVtY7KzDKCxzYTsfNKTZthTs84Q6T8oVF3ZaGLVY99/AMAYhHV6+/Sg0L/+ykLIQsg+fAgfP4bnz1PL64xA7AaASQnr9OdBobfmMk3DmciAY5bsLADXR1inm3ILh59+Kif1T++/exd+/llbCGiW3p3MgMZsyc4CcMWE9R6yDqYu49l5UCikrONncEBjtmRnOZFvLSBxwnoPeQdTl/FsPjdyyPI8fP118zR3d5kWETCF3rXRAxqzJTvLIOrvgblIcYSaNKU5ms8k8jdvwoEHhWY//zxVqb5gRLCxXN8gfQMkfyJ9qo0uZdz85cvw/n14eMiePfs00Zebnx8YMenQ68nNctpB6bTHODdf1KQnzbCnZp3+0n9QqHp9bkrP2ugBjdmSnWWgS/aS14EHOE2KNxBpSvNmayr542P45ZcQ69Hv7sKLF+H1aw8KvULXVLN+ZUr5b0BtdP70afbhQ8Msd3eNr6c8SyfDfliY0fOw5sieIT1phr2vpi4As5Q9exZ++in8/HMee4ABEzlaG91cqfviRX6gMdvBZSU7S08D9xjARDSD4SSuajCNAX2+ywY0Zkt2lkJLg5PSfhi4xwAmIqwDZ1AZcb/9Hyd68aKcbqP81avw4sWhObJnz8LDQ7i7y0PIQ8jv7sKTJ+HhoaUxW7KzDNF/jwFMJcWmOWlKsxnTxLQ4vHqDG6AP4EQaKn98DM+fh+++K1qPfKqN7pJxsywPIet5iJOdJYROJ9JJe6wv35OH2DOkJ82wp2YdGFVlrP3u/xjqxNroAXdXyc7SdcmXqb8HGEOKNxBpSvNma2LqRa6eQzwv56yNvtZZNOgxxAAAGd1JREFUeu+xvi6wipny9UJ60gx7atYBroceAH2db495SCowCmEdAEb26SGpf/2VhZDFIW4/fgzPn8vrQF/COgCM7ZIPSQWuWopNc9KUZjMmOC+NSucl4abhl5nlEk32jy4thND9Iakjrn12jBxFetIMe2rWAZi31FqHH31IKkB3wjoAM5ZQ6/ABD0lNrw7vcgzwCt0I6wA3bEAGSm2WNFuHe0gqMJIUm+akKc1mTHBe2qzPy40cry/bOndtHd64W862x058rOyZSjV79gxnlmbYU7MOwFwl2zrcQ1KBsaR4A5GmNG+24LzUY83LTR6v/OnT7MOHhtfv7hpf/8IF9tjkY9RcE3uGM0sz7H01dQEAGEl615hLePEi//ixaG0S5a9ehSdPjs97kT3msbLAKTSDAWDOXr8O79+Xe3N+ah3++vVZVpdlwwcI5/Li8er7D1IirAMwY1qHc5DYzVVIsWlOmtJsxgTnpYUoMzKgdfigtYTQ50Nxmae33gg7nzNLM+ypWQfgSqhHBa6PDqaQhmE/16ZXAQCc7tDg8cANus6a9eVyudlsWibY7XabzWa5XB6dEi5Bw0oghPzxMX/7Nt6C50+f5m/e5I+PE5cJmNoV1qzvdrv9ft8ywWazub+/L/53v9/f399vt9vlcnn2wkGLAQ0rgWuRPz6GH34I33776bP94UP+8WN4/jx/eMiePZu2bMCErrBmfbVatbxbJPXFYrHdbtfrdZe5AOC8fv01fPtt9ttvxQvZu3fhu+/CL79MWChgcil2eh1mt9vtdruiynyxWOx2u/pkWZaFENbrdbn1S+OL9RmvZl+RnMFDFlyGM59ZuMw4HuMOSFL6IB9qp97w+s1+JI0Gw5mlGfaupGZ9s9msVqty45ZDk1X+iGL9+tHZAeAcV/L2ZSaXHYALupI26+Xm5i1t1mNd+2KxqLxeacUOM5DerT9ct/zxMfz666e/nz4NL16E16+PtyZv/6h+fjeLy/zwoWGau7us8fUy9cFwva4nrBd5fbPZHArr8fWWjqS73U43UwAqLtH788WL/OPH7N27L9b76lV48mSc5QPzdCXNYMbS2MwdgFt3gd6fr1+H9+/zly+LF/JXr8Kff4bXr0dbBTBDV1Kz3ktj3flisWgf8BGAG1Lrw13v/Zm9e5eHEH7++b8vndAQJXv2LH94CL/88mkRd3fhyZPw8JB9883gZQJX4BbD+mDZSONvJNjRGGD2zvbVerT351hjM2XPnoWffgo//5yHcLydOnAbhPUehGyAW1H6wj+192d/nnkGFG6xzXpjw3RtYAA46MWLcmvyKH/1Krx4MUlxRpBlHoQMs3CLYb2FoWAAaKD3JzCR2wrrcYR1Q74A0Ev27Fl4eAh3d3kIeQi53p/ApdxWWI8PLq23eCkeaKpmHYBG2bNn2U8/xYYj2YcP2c8/S+rABdxWWC+yeCWUx8eXrtfr9tmzDs5SbgCS4YseuKTbCushhO12G0LY7/fL5XK32202myJhF/Xrh+QdnLv8AFDn8gPX6ubC+nK5jDXo+/1+tVrFOvVgWEYAZih/fMzfvo0XsPzp0/zNm/zxceIyAaPKbjakltupd2mqnmW3u684u/jzjhMM0neBT2vnVeSPj+GHH8K332a//fbplZcvw/v34eEhe/ZsrLUkpG+ZB2zjHHcL40kz7KVYpjSlefy4Ei4PMBdJhfW3b8NffxVJ/dOLL1+Gu7vsp5/GWktChHXOLM2wl2KZ0pTm8eNKuDzAXEwe1ksjGeQHers2vF5f2hy/doR1zizNsPfV1AWYky6DvSR4jAG4Pu0Xm0M5Hpidm+tgegqjwQAwsTyP/7I8D19/3TzN3V32ebJP/4DZUrMOAPP04kX+8WP27l35tfzVq/DkSZe51b7DLKhZB4CUdK8Lf/06vH+fv3z531lfvQp//hlev25bvNEeYVaEdQCYpezZs/DwEO7u8hDyEPK7u/DkSXh4yL755tAsn0Z7/OuvLIQshOzDh/DxY3j+XF6HZKXY6TVNaXYQ5koYfwDmIs1Pa5blIWRXP9qj0WA4szTDXoplSlOax4/eOgzp0+Dch97lAeYizU/rjYz2KKxzZmmGPR1MezB04+wNS+oAV8FojzBHwnoPgviVGFDLAjBfn7/0shDyp0/Dhw8N09zdZY2vA1MT1gGgs7nX2pw22iNweUaDAYCbMWi0R2BCwjoA3IoBoz0C00qx02ua0uwgTD/Jjgxg/AHgFIO+3DqO9njSWsZlNBjOLM2wp2YdAG6R7vMwCzqYMnNpjtaSZqkAgLkR1nswznpy0szEaZYKAJghYb0HQTxRaR6XNEsFAMyKNusAAJAoYR0AABIlrAMAQKKEdQCgE31x4PKEdQCgTf74mL99G5N6/vRp/uZN/vg4cZngZgjrAMBB+eNj+OGH8NdfWQhZCNmHD+Hjx/D8ubwOlyGsAwCH/fpr+Pbb7Lffiheyd+/Cd9+FX36ZsFBwOzJjh3eUZfZVeuLjh856XAas4gKlAjhR+zdV6eFueQiNT3preP3c33vDHjnnC5zO0gx7HorUgyeYAnBT2i9ph3I8MCJhvQdBHICb8Pl6l4WQP30aPnxomObuLmt8/fylgpsirAMAh714kX/8mL17V34tf/UqPHkyVYngpuhgCgAc9vp1eP8+f/myeCF/9Sr8+Wd4/fr4vFk2sKE58JmwDgAclD17Fh4ewt1dHkIeQn53F548CQ8P2TffTF00uAkpdnpNU5odhG+d0WAAhhn05ZaHkF339+HsCsyo0gx7atYBgE60aIHLE9YBACBRRoMBgNuT3m/9QCM16wAAkChhHQAAEqUZDHRgnGAAYArCeg9Zh8SW4Ig/AADMlLDegyB+ixx0AGA62qwDAECihHUAAEiUsA4AAIkS1gEAIFHCOgAAJEpYBwCARAnrAEAyssxz6KBMWAcAgEQJ6wDAuXiwHJxIWAcARpY/PuZv38aknj99mr95kz8+TlwmmCdhHQAYU/74GH74Ifz1VxZCFkL24UP4+DE8fy6vwwDCOgAwql9/Dd9+m/32W/FC9u5d+O678MsvExYKZirLc83JOsky+yo9ccQAxwXgAtq/cktDuOQhNI7n0vB6fWnTfrG7rNy2NMPeV1MXYE6yDoNJJXiMAeBi2q+Ch3I8cIhmMD3kHUxdRgCYQp7Hf1meh6+/bp7m7i77PNmnf8AxatYBgFG9eJF//Ji9e1d+LX/1Kjx5MlWJYL7UrAMAo3r9Orx/n798WbyQv3oV/vwzvH49YaFgpoR1AGBM2bNn4eEh3N3lIeQh5Hd34cmT8PCQffPN1EWD+Umx02ua0uwgfOt02wdIWZblIWS9vqWNBsN00gx7atYBgHMx9gucSFgHAIBECesAAJAoYR0AABIlrAMAQKKEdQAASJSwDgAAiRLWAQAgUcI6AAAkSlgHAIBECesAQEKSe9o7TEpYBwCmlz8+5m/fxqSeP32av3mTPz5OXCZIgLAOAEwsf3wMP/wQ/vorCyELIfvwIXz8GJ4/l9dBWAcApvbrr+Hbb7PffiteyN69C999F375ZcJCQQqyPNc2rJMss696yrIhc/XayXEVjgtAmtq/pUuXiTyExmtGw+tn/c53WbltaYa9r6YuwJxkHdJngsd4GsOSOgC3p/3CeSjHn0QoZz6E9R4E8d4GVJMDcCM+XyOyEPKnT8OHDw3T3N1lja/DzRDWAYCpvXiRf/yYvXtXfi1/9So8eTJViSAROpgCAFN7/Tq8f5+/fFm8kL96Ff78M7x+PWGhIAXCOgAwsezZs/DwEO7u8hDyEPK7u/DkSXh4yL75ZuqiwcRS7PSapjQ7CKdrQN+dy8wCwMUM+mLPQ8jO/cV+qGAuK7ctzbCnZh0ASIjRBqBMWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkChhHQAAEiWsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgEQJ6wAAkKivpi4AAHCl8nzqEsDsqVkHAIBECesAAJAoYR0AABIlrP/XcrncbDZTlyJRWZZNXYTJ3PK2B5t/w5t/y9sebP5tb/4tc+gTpIPpJ7vdbr/fT10KAAD4LzXrn6xWq6mLAAAAX7j1sL7b7TabjR99AOCmGFSSubjpZjCbzeb+/n7qUgAAF5I/PoZff/3099On4cWL8Pp19uzZtKWCFjcd1pfLZfG3NusAcN3yx8fwww/h228//Z7+4UP+8WN4/jx/eJDXSVaWe7pYCOFzLftisdjtdo0TZNlN76vemx9bFiU4S38Ovc2fuhTTuOVtDzZ/ws0/5xd7/vZt+Ouv7Lffvnjx5ctwd5f99NO51z4LzvwEN/+ma9YBgGtW65NW76OWvXuXhxB+/rllrrNILxSSJmG9h7H6oSZ40wYA16390ps35XhIwa2PBtNL3tOhWVpWMeB+4DKzXI3LbHuyx9Hm951lgDS35Za3fdgsAyS7Lbe8+VkIIc/jvyzPw9dfN093d5cVk5Vm6fiv9yyDOPQXmCVNatYBgNvw4kX+8WP27l35tfzVq/DkyVQlgqPUrAMAt+H16/D+ff7yZfFC/upV+PPP8Pr1hIWCdsI6AHATsmfPwsNDuLvLQ8hDyO/uwpMn4eEh++abqYsGB2kG00OXxk86jwJAsrJnz8JPP4Wff85DyD58mLo4cJyw3oMgDgDX4Ur6HnIDNIMBAIBECesAAJAoYR0AABKVaYfd1bUMrX9Rvc6uwXu4z1qyrPc5bxazXMEsaZbKLGZpmCVeCw4sarQz//BaLrHtEkXK0gvGwnpnPlr99dplg09EBwaAGRG8kpZeMBbWAQAgUdqsAwBAooR1AABIlLAOAACJEtYBACBRwjoAACRKWAcAgER9NXUBUrf7LISwXC43m83EBRrb4A3c7XaHJr7KHbVcLq9yu0L/TbuFQ1/5XEQTl2k8g7fuBg/9dWxUme/8LjabTdzea/rgl/XawOs+9C1bF9+9XFFa5By2Xq/re2y73U5drtGcsoGN817rebXdbkMIi8Vi6oKMb8CmXf2hXywW9e26mqN/ytZd/aFv3K71ej11uUZzygZe/dEvxG/FKzv0ZX038LoP/Sy2Ts36Qbvd7v7+PoSwWCziPWj839VqlV/Fk6RO3MB4u7lYLOr35ddXFbFaraYuwrkM2LTrPvTL5XK/34fPn4vw+ZOy3++Xy2UqtSxDnbh1133os8+PqV6v13FzNpvNfr+/v7+/jp9WTtzA6z76ZVf8hR/13cBbOPSNW5eQqe8W0hX3T6XCqfHFmTpxA+OU1/Q7Q912uy3fc1/HcY9O2bQrPvRFhVNl6w69Pi//f3t3u+QqCgRgWKv2vtQri7ky8crcH11DcRRQASO27/Nj62wmOrSdSVrCR350Ci5CiP1zWD1uv4i4pVUF5QeoOPsu96snlT3rCQHqTr1ckMpz/fg3oIvYT6+Djz9OfoA6rkPE9qsxNcV6ZmiKUx8qaJa/N/RHvwbyo1Oc+tAVUPOenx+gjusQZ6+G1mI9LUDdqX/ErQjDYPxCXwfbb0mMMVV/Y7JHfYD53PCNMTJ4QAfFoWWy3/Zuf2QHkDyX7uiKUP+mpz7ATDI+ZFkWO2RIGfUBJqv8T4Ni3U8+1SLTDp5ey2YG6Nb6Mt69UTEr3OUO4pSRnbc2p6Sc0HSnXiLyvvKfPlq9yY5Od+pDV0BB3kVmgLqzL+RPIz7d8NHSAnxD6oUbXXXTVO7u2q+UXBzvN0SPGN60KzPAyF/706+Ml8T76CEQIWdDe1vqhY4x6yEHo3tb6t15HQSoPvurd0JNoYnkAHWnfjUuqNro2BQpkZrulpDjAX4+H/dN//v96rvhhtdLUm+Mke+Oa18uIEladLpTP45j27bDMMgCWdM0aYquyQ5QX/btYmhaP9lLBagy9fbfNjrpspRVku5q2NrddwuVkovj7WdSMM9syQ4w9Bw1Kyes0LNuvS317gjvu9tS3qno3pP6bVfi3S0qLCFA3dnffiDKI1X1rebICVB36kPT7u3jlXybSs96jNabbCs5QGPMsizbw+0jT7/bRsh7Ui+9jzKgXz7S7m5RSQnRvSr18gE5TZNUJMpm4yUEqDj7diR3Rd2oRWUGqDj1jfO3sH1c/lFJHcgEUxTWdZ2muZg4TlPqbe3SdV0lb9YFFY9OU+pdslGUXK5xHB9dlHgVCfDR2bfLYYU2BbMzDn/arHIuDfDRqd8l0VXy/k+x7hd5CdrX/U8bVNrVAVby+sbvKUi9rWWnaXr6X/rWddEpSL1XVZ/ZVygS4NOvj3dTz+/3K0O9FXyxdl2AT099iCxoW8ndCMW6nyQpMnni6R/hmQHu3os//fogRH3qpZZV2aHe5EWnO/VyZSIly6Oja7IDVJx9784DtkTz/vRZMgNUnPomGp0Jb0xxg5+Njn8WdjCNHy7P8U68iPzouZhgaulOfWSPTwUyo9Od+t3onj7XMDNA3dnf0pH0iOMB6k595DpU9RrQ+ZlUhORpVcR4H3yo4wHKSkbuSzY0DVzH9PCt1xbrb0u9fXeeAu5uYJZT0b0t9aEo1Ny/nQrwbdnfqqpQu0IowLelfnc1mFtatVVLOypk+5i7rnMXFq0neZmOB+j9m7RP/vyxjzy9ptl6bbH+ttQ3ex79GjgV3dtSv0Sj01G0HQ/whdlf0ZR3r1CAL0y9+wZYbXRK6s6LeLe2qid5+Q4G6P3rDe37pen6WBTr7oOKU++Ny/Xo18Cp6N6W+iUcnZqK7XiAL8z+irLUb5F6V/3Rtcvz5zhfzU7B7Pv+0RMpQnICNMbYmWparw+8SP1r6U697uia7ADVXx+E6E595dFRrAMAAACVYgdTAAAAoFIU6wAAAEClKNYBAACASlGsAwAAAJX67+4GAAAA1MsYU3B5ELvqyFb8txRvhrREznnkzGmH2P+mrT60fTByksi19Z6k7CW90N1rRwIAAFRKNqMoeMLdwsy7n0NCM5rAYuF2MfWV0Mri0zSdPWQJr84u+zAeaX/oDJHz7F7bVctDV7s2DIMBAABIYTcqKWie57ZtM0/i7fw2xrRtO89z0zSdQ346DMM2HGPMMAz2ENnj0z3E25k9juMwDPJvOcoeMs9z6KhT5DyZ13+apnme8xtzubvvFgAAACoV6dKWAvTsCaX6Cm2Pare7X/X4nupZlz7pSMdzZKvy1Y8i5aJ3u9NICMu/neUHo/A+0z1PfKPZULyrJ+w25l70rAMAAJwm/c1l+2XHcZQiWE6eRnq1V93q9n+XZdkO1LZRePuqF98Ik9Ah3++3aZqu67ZXpu97W2fndIr3fb/83S3Ir0smtxaVd65TrAMAAJxja83iI2EypzxK3Wm7t+2DUv1HBoLLIe5Nwm4JK+Wy+zR7NULH9n2/PSpN/AbjIDn2iuFMBbEaDAAAwDm2QzenC/wKUnduR6vLPyJ3ApGCNbRqyrbgtt3q8RaW6snuum6e5+/3m1Nty0mKtOci9KwDAACcIINViozo2JJCNl7vRkjd6S3Wd885jqMbiz3J2Smh8QvS9/3qFyUrchIJs+bOdYp1AACAE6Qr19aymcOmXeM4SrWdVjuGinJvBX+EHU4zDEPbtlJnJzTsajld9XbN9UJtKY9iHQAA4CjpVpcKz9ayZ0u97/fb+kjdP01T2sh1d9OirYRzjuPoDnOXMSfSVO86j8m/KE2RXyQnqXkkDMU6AADAUe4I6eummdZDll6ZpsldLr35u994xg6gD0exDgAAcMi26zptpcXt6uDTNNk+bLujUFrz0n4aJwNgjDG2cJfH53mOdLFf7fd9+begWAcAADhkGIbV6oelOtf7vpc+7PyzhSrX3RpaBuLv/mp5znal8+MVswRbcPXGIqodtk6xDgAAsM87Irz4NNP8Zci3xx7s/v9+v+5z+r5v2zbSEvuj1XPi5b4s+j7Pc353eNnyutrueYp1AACAfeM4rjYbEsnTTIsLlZu7exU1vj2GErZo3e6sFGlMJrvTkzcpmlCsAwAA7JDS0Fto2geTx5q7rujfdVdMDz1n+6PVKJet7ZBxeykiQ3FKVdi2wYpn9wqKdQAAgB2hbnVRSed6ZMlwO9TeO7LF1tbuiPx45W2MkXJ5tay77VzfHmUPaf6tsGWH1NAo9tWDxphxHNu23TY4TeYuVD/w390NAAAAqJrtVj8yR7NIvZ627HdkyfC+76dpklp5GAa7VLzt6m6a5vP5uBV23/efz0cGsrdt6z2k8Q1Yt6PS7VHyHHvUtsKOxBv5NiB5QXpXfHH6KiwAAADwkX7iU92u8RPKc7ZLN1q2kO26btWMIw2Wpk7TFD/5VsIhbgtXQt9CeA+xv8JtQ7zLPHIBXfHQhFyxI2e7Cz3rAAAAMQUHtyx/FWSIu4BjgnEch2GQgSWRk7ujUGQISrw9xhj3IsQPkfNLF/tqXHukVXZky6qpOY6cYZ7nmsfANAyDAQAAUEOqYXebVa+zkzJ3q/OCR/2SXIfKp6gywRQAAEAPGYJy+zqSp0T63S8la91UfkdBsQ4AAKCH9BMXWUfyN2TQTv6gl4Tf25RYT+ZqFOsAAACqSAH6lM71vu9vGYjiropTs/b39zEAAABPEZqsWXkzHrAi4d0qyewuinUAAACgUgyDAQAAACpFsQ4AAABUimIdAAAAqBTFOgAAAFApinUAAACgUhTrAAAAQKUo1gEAAIBKUawDAAAAlaJYBwAAACpFsQ4AAABUimIdAAAAqBTFOgAAAFApinUAAACgUhTrAAAAQKUo1gEAAIBKUawDAAAAlaJYBwAAACpFsQ4AAABUimIdAAAAqBTFOgAAAFCp/wGeQk0CWi0jvQAAAABJRU5ErkJggg==\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",
    "        if k=='data':\n",
    "            #Select OOT DT clusters to avoid unblinding\n",
    "            #cut = (dtClusterTime[k][:,0].flatten()!=-999999)#!=0)\n",
    "            cut = (dtClusterTime[k][:,0].flatten()==0)\n",
    "        if k=='signal':\n",
    "            cut = (dtClusterTime[k][:,0].flatten()!=-999999)\n",
    "        h1[k] = create_TH1D( np.abs(dR_csc_dt[k][cut]),title=\"\",axis_title = ['|#Delta R| (CSC,DT)','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",
    "        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",
    "            leg.AddEntry(h1[k],\"data, DT OOT\",\"PE\")\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h1[k],\"signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\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",
    "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": 65,
   "id": "0e032a54",
   "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",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\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.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",
    "        if k=='data':\n",
    "            #Select OOT DT clusters to avoid unblinding\n",
    "            #cut = (dtClusterTime[k][:,0].flatten()!=-999999)#!=0)\n",
    "            cut = (dtClusterTime[k][:,0].flatten()==0)\n",
    "        if k=='signal':\n",
    "            cut = (dtClusterTime[k][:,0].flatten()!=-999999)\n",
    "        h1[k] = create_TH1D( np.abs(dEta_csc_dt[k][cut]),title=\"\",axis_title = ['|#Delta #eta| (CSC,DT)','Events'], binning=[50,0,3])\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",
    "        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",
    "            leg.AddEntry(h1[k],\"data, DT OOT\",\"PE\")\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h1[k],\"signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\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",
    "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": 67,
   "id": "1729e877",
   "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",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\n",
      "Warning in <TROOT::Append>: Replacing existing TH1: h (Potential memory leak).\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+QAAAMECAIAAAC5e3jEAAAABmJLR0QAAAAAAAD5Q7t/AAAgAElEQVR4nOzdXa7jxpkw4OIH3xrHvu8EWYklZbIWx+7ewNhALJ7kwtmA3UFvZeyImoUEBqbv3b2B8LsoN8OmKIqkKKpIPQ8axrHEn2Lx72XprWJWlmUAAADS8//uXQAAAKCdYB0AABIlWAcAgEQJ1gEAIFGCdQAASJRgHQAAEiVYBwCARAnWAQAgUYJ1AABIlGAdAAASJVgHAIBECdYBACBRgnUAAEiUYB0AABIlWAcAgEQJ1gEAIFGCdQAASJRgHQAAEiVYBwCARAnWAQAgUYJ1AABIlGAdAAASJVgHAIBECdYBACBRgnUAAEiUYB0AABIlWAcAuEqe5/cuAqslWAcAGC/P8+fn53uXgtXKyrK8dxkAABapKIrdbhdCEFBxI5/cuwBrlud5URQhhOPxGD/ZbDbbD/osIc7e6uISOubtM3s4U/44b/9NoHtHNCRbq/WtOC3kP//5z+rvP/7xj7OUqEV3IQGmtd1uq/sj3FDJ1Pb7fZ+a3+/33cs5HA7XzB4D63MOh0PHervnrWw2m6GV84B6VmbiFVvfisZXP//8c/XVd999d5fiRfU6vGMxgAdxOBz2+3110793cVgtOetTKooiy7KeiWvPz89Zlo3uknKxvXbc4/52u93tdj3nPR6P12zCgxixIxKs2MavK61ftX57Fz0fmAGusd1u8zzP8zyRSx9rJQ1mMlXW2iDPz89FUQzKlIhu8dNblmUj5hq9CXR7fn5OMN3otDz1Q1EODJCg2PZRXVHj/ybVIBLleZ7gZX+oQRU7bnsbO7T/lPHhaujq7u/eTfsr0Z2yclFrTsvFZXansgyd98qGgYtpOY+psSMOnVrbg++9BWX58VacHjmJlLZee3csBqzYfr+v7hSbzab7sj9o4j7LGbeQ+uUrzl59Mq48rWIJr1xIvIh13NnLsuxzt52q5mNObFX53QWrzzUoeBiX9tlz3qowVSWMXuN9uatN4+KxeDEUPj0NLh7xHWfg0NV1rCsm5DUy81pNX63LV6+xnheIiwfG/MTB8OA6Lv6Dbl6DAsdzyxm0kPoVOBZ1XLDeXYBJgvWLt4m4Fzqm6aj5obeS1iiiz11snmC9Kl7PyarN7/NElCC33gmci4xbn0Q7juP+U148xC+eHo2CtW7CuQviuYIt7uifQb1i+9dPn70wp47epcDqNRqnY9tNx2WhfpOKrTxXXgmr5YxeSH36ccH6vubcT9ODFti6hIvN6qHfrb+15vsXpmM542LryfvgnjaZt2rd9iXeyxZW3ASNe/RvnaV/a/fFc+/ijI11DS1/6yxL/Gnp1vrsrO65UgjW7WJ4ZBdvUvUrQxWWnUuZ63kZOW0TbRSmz0Ja4/I002A6itRIkjxXgedqrHU3dajW1bj7dOzZ/sscOmOHi0fCuYA+FiaFe2t/gvVrDWqTrjudq3EijQ7W+8x4MVi/WP5kE6yTMq5y6gfVLS4oP//886Dpb1oYIGXdTZin2Qjxf1vjwp6pC93LGRRqLyVYj7Of1nDr3fxczH3rmq++GnEjuEWwfnGjOla6uIjF0I3Xah2VpU9f49Ngt88AL425WsdgaXx4o2Hslt5dfQb1HTGo/279SGjUc/5BdRE/HA7b7Tb74Nwy9/t9Nc1//dd/xT+22239fUat6gfz6U6vfhc+XU5RFFVp60vLPrbdbk8P456Tda+rvrTGV0VR1Cut0n9Qozhow+kSust5rjz17Y2V/F1Nn/IMnR56qo7ncydXY7Ko9QbR/67RsdJqIRfvs3Fcxerv+v/WV9Q4ke8yslm85k8ySknrQiap+fBhjIRb3/0b1/9zF9WqhOfqrWMc7XhHXtIodvd+Wli21jj4mh7TFydofNj9DN06S2shx23F4USfDX8c9cNjXI+o0zO0+vyf//xn2fbDzunSLkZv3b+Ndqc8Vl+dvg6p0S21+6Gx0fvn4mT9a6z8+NfSw6V3fvUZaaFj9o5itFbL6ekZC/DFF19Un/zP//xPd5H+8pe/9J8YBuluE623GlTTt2Z1X1xU/yn7tBO33vj2H48GM0kH1nqRhs5VL2qfHJVYvHNTxprvKN71NT9a/8W27pFzO6X69vSr7l+ELnbVTY1g/Sqtd/3+s3cHu+ei+Yura0wwLlg/nYahxvWpasSC9a/qrddl2+F3eulp3bOtzpWnY5r6Y8Bpak29Q1KfHxZat6hnOatvO340D+fvzQ0dO2vQLyTdS4gd0M+tfVD8XU35xRdfdE8J0xoU2507SU91B5c9Q896qnf9Dts47+KjRSMvfM6Uv3M5MKf6V+DoGU/rdpKWuJ7HSWOnlJcGDu5YbM+HzBHbcheLKWiaTm+0Ez6onQvWG+FCd6m6A4LKoAFt6Kl7N7Vq7KxG5Tf6GJ3urNjc3lqAOMF33333888///zzz6fN7d15kK0T9Gx0bz2culu46xt++ktRR6Wd3vBa19I4sBsPSBf7b9UXUjltce9uCjpXsDhZPVj/y1/+0lqeaFAbPEyoOvU6bnynZ0efe8rmw9jerd/2f0Jojcm6rxjVVxcXPpX+1XKxtutOa75/YeIqTq9Ro+OBPrtsRNfkjubzi3V15RbNTLB+ldN77YSP4+eC9UZM0N0eHx9PT5fTEQWes9lszv24yalGtY+Y5XSu1vCuEaBXGpO1dipthOyn0/S8q7VuYPch1zpN61oaG346QXcccLqK1pJ0/KDRc4LTonb00Lq4yf/zP/9TTdARrNcn06zOnOoXhz7TdE/Z0HEGlZMG6x0Ln61xvX/NdFdLXaPm+zcjVtOfXqmuqZY+u6xj+R0N4a27siOI77O6BAnWr3J6HE8Yy54L1k/D8fpcp6F8n2C9dVu6ba54L9ojaLSCd0/c2sx8cR91LLYRhXesuju47BkHdyeftM57uvxw/rrZ/fP0oAb+1uWfTtn9bcdpXt/wi9XSvahqmo4ovOemwbR65vidHvA9o8buiacK1s+VvPtyNK1B+Rj96/DKmj+dpTsd5aKLu2z0Tmltj+9zhPTPPkqB0WDGu1c/4kZH7EYxGt2f+/faLgfG68fj8fn5uefwFw+oXifH4/F02JC63W7XGAvocKnH/Waz6aj2v/71r9Xf3Xu2HtafjkdUX0WjPPUE+tMnjfqM+/2+z3G42WzOdeqvz366qI5hlBpV1PrgOtRms+l5Wp1OdlqePov63//939bPf/rpp+rvetoM3E4cOyWedDGY6ziGt9ttFW3E+CleDGcr7TUWfV+7vub3+33j+l/dSiYZteac+tBedeembx2PKAZCfboYLWYvz/xwsCY9W6ynXX78qmMn1j+PV9JB5eyTD9NqKY+nsxlXjR17pzE2Ysequ/t9dhf13FenrTLda+lZ1J7tc91plx2FHPT7Rv8pO3QXtTuf51x5ztVhz0qGSfT8uazPEnoe/LduWT83V/+xU653o5b1ho508NZVnCvP6Jq5uMt6xh6t294o1cVG+vpcE/YzvKlP+tQOqdlsNq2tiX1Guu1WPcUWRdFn3PdKfJC96QP3I9jv9+fqsL47uq9r9Wb1P/7xj/3X3tEO0d2e3bGW7raNjhHl67pHWK/+bh1EuePbc64ZRbhjZN/w8fZeLM8XX3xxrk09fPyTSD1zHW4hz/Pq2O64THWrzqyLzZnxHnfuHjRPa+igoZ8SV+2+OK58x5Tnootou90OCgxG6L67nRu/P5Yqbl11eKzpbTCC9fHueBzkeb7b7er/Gy+d1wfr1QLjH8UHocc7m56fn+OLJ8atdE0aO+LiRX/7Qc9ldtwp61e677777uI7j3qucXTySc/joWdM351v013I7pJ0v/upj3o0Ey5t0fVxwN/+9rf4xxdffPGnP/3pyqVBh6IoqryC7kC5KIrdbndxsov6BIXXn0TnItdbx6O3EK8/fXbQTAUaaLvdjm7yq669sZ2xfw5MWE5AL1if2MXH1kmcS1ufKlivL6G+kCp2P3cti6fKlStdgca7Syepk573j/pk9Sb2PhpXt54x99AAeuhkdRezwM+5eOHuX5ieT7CnC2m8srS7PCGEzWZTtaz/9NNP9Yi8vjlLDCxYltg21P9Sdjweu2+FF8/3KnRrXU485q+/wV1ZyElMu5aLV4M+Nd+/F9AtnNsp8Zp57sp5+lPMxWvswq6c987DWbbT+pxhnPXWVXd8eKPc+nPRz5WLXYdBqck99VzgmRO9l0bqeccoKz///PO5ubpnrOs59HL3KATVV91Dr/TP1DxX5tYRezqcrrFntVTqyS31AdR7juoIkxj02qOy3wB817wAqH/6dXkpZ711o+ZMWI/6b865Oin7vbBz0Fo6XhNxTdL8xfW2Lrz/YDL9d1//CkmB0OoqrTfvQbM31I+b7mC9ser4Yf2T6oi/XUfYKzd/xSav6no2y7mB1U9XPVQj7D49lir1hOnuMnQUdURM37Gu7vHXO5bfWE53B6ZWmw+vIOhZ1D7lKc8H5UOXA9eoDv59p9PpG5e+cyFyPcyqf34uvuw4T09dDNbPrXTOfof9xxDsLlu1UUNrvrHqc3vw3Od99AnWzx0J5z5vqF8Y++y+ZV1CF1PQNLX2hOg5b3csfnGCi+OpV6ffxWD90GaSTXhYk1dIz7iz3uD93XffXbnS02Op0h1nV1/1vLZ2T9axru628/4t2fXlnG7s6UG+P/N2sEmqpXWWaqj1/m82hUmcHv+t6mdE/fPYDnVuyrIzFKsvJD4S9DyjTxfe+mFHIYfX03hxu/rHl+embGzXxY3qU/Onyxn3W3HP32fqK6oaMXvulPqUF2OYQYPwpGAxBU1Ta7Ta8058MdDvDoVPQ/PGAruXUz+Ur2kgHz3jinU024zW84I1dNDGDjMkn9SP3j6Tdfwg3lot/fdCR0JOd5zRf43dzwMXF1gF6841Zhb6aTQAnfsx6vQM6m43bV1O/5bd7mD93Nb1r5xJ9A8cOyqqsaiG7syZ7uvVuJpv6J9M1Roa9bmTnvsBoWMtCxpyWgfTq5zrSN6nm+npEG+DMmLP9TEdYfRgTPqSthrRb/KijuFQbmRNvUsvLv9cYRp9qcvegUt3UUccFbGnqeEamV//w74Sh8+rd8XuGPBqW3vbzqn6cvqMmtVn4fUPy7K8ZvmTqNZ4MXK4uC/iptW3KJwMFNGYuOdyrqyZ7hcbnU5ZDVbRf9XdB1LD8gabvtNDwnqcGxO0e67WkKvxkHcxyaQjbqs/hvZJg+lewqCtuDjX6g36Ma6PesJ6d0tAPZjrkwbTsbs79unkvUs7Jpuhgb9jOf1/gS0v9ZcdtKjKF198UZ+r+rtqaAdWIF6v5kyUf2RLrO3/F7jOuSezLMtam/2Koqje1dxzUedMNebUud8HuhfS2h7f8yVk69Z/bO8RC7zY07F1rlb1snU/+HWU5/R1SD1/BOjZKN4x/Hl3W/W4luzGlCPeC3ZujdcPEzZo5wILEq8Yzut5dI8CmSbB+gTOZXftdrssy7bbbfxNZ7vdZllWf5lRn4V0mCpYD2eC7OPxWJW/+jms2pBJnjfoox53njt+onrofDweO96ItN/v63uwkZTVHen2vKN0H4Q9Y/rRr17qn6M1SdpSlmU9pxyUyFSfuBpzvd7HFFiHeBd2D53B8XjcbDbz5ztd5d5N+ytxZYtyd+ePjv3VZ7deTIPpXlR/C+qrcTv1I2GqX9k6DoBTjViwtZtpPVumdZrujI6ODZyzd+lUQ690JOTUa+nc5pye+1fm5NS1Jqb3nx1YkHhNu3cpVm6hlayD6TTi0/Bpn9E+NhO94fJKZVn2bx08td/vNQmE2/QurfRplI15VtX//td//Vd99KvGO95CCD///PNpKkvHVtRb62/du3SGBv7Q2Qa/2Wyqtex2u/1+H7s6xVmKD++1Pi1Yo6PYhEeFfqWwVvHq3b8vJiMcj8dF5uve+2lhVUaksnQ0K/ZpWW+N3s69UKDuXPPeuMFGtKlX+lTyIP17l1bqHUC7nRvesT5N46vu0SGn7V06uoG/e8b+yyl7/+LUOmW1kHG9S08LoF8pwAOSsz6lOHJQz4e2GBlc+QDdOvs1yyyKYtAjxyRbsVYz9y6t/PGPf7wYr8exYk7b1BtOD+ZJepf2/A2qo0F6ht6l0cXTIT5BhZNNbu0PeuXIm/qfATygrJwiWZlTsS9mOLm/bjab2EfzLqUaJPYrPY0PYs+Mu4xHyyD//Oc///rXvzbC/c1mMy5f65GdngutJ3J9iKTD4TDJCVIlNf3lL3/561//ev0CAVgWwTpAojabTTUIjGs1wGOSBgOQop9++slwjQA8bst6URSnQ1Y/bG0AqamP6uPSBPCwHn3oxkWO4AOsXb0rquEaAR7Z4wbrcbwIw5gAifjpp5/+9Kc//fTTT3/729/qCTB/+tOf7lswAO7ocdNg4rgND7v5QFK+++67v/3tb6efu0YBPLhH72C63W6zLIvvDLt3WYDHJVIHoNXjBuvVcMj7/T6OPF3vzgVwR3/5y19E6gCERafBxJfydLSIFx/EiRtTxheaVG8tiYPD7Pd7TezAXfz000/xD0nqAFSWGqzH2Hqz2dTfK16X5/npaxq73ymYZVnHAgEAYGZLTYM5HSK9rorUN5vN4XCoxmfsngsAAJKysGC9KIo8zy8ml8dIfb/fF0URE2CqHxBilktRFFmWnTaid7S7AwDAzJaUBnOa2dKatVJN1ti0xucx4q8SY4zkCABAapb0UqR6s3dRFNVwLg0xfK+//y9qxPqHw2G329UTYw6Hw3SFBQCAq5U3FlPGD4fDtIuNaeibzeb0q7hd+/3+3Ff1whw+uLjGu+0hAABmMTYyvaEpW9Zj03V99MMqubw1L+VeYiJ7/HtQknoi5QcAYHJpvnJnsg6mpwnlVRxcZaTM2X2zdV2nuTEAAJCsyYL1agCWqlk95pQfDoeiKGKb9PF4NIo5AAD0NE2wXvXprCL1KiivWrhjlrlgHQAAepoyWG+M1hLumnbS+lRwbgCZnrIerlk+AADU3WroxpgVUzW0J2V06rwOpgAAzGmalvUY/jY6mIa2tvYZxOZ8+TYAACzdlMF6/CPP85gNUs+Bie8HDbO0tcdVnGa8VKuec1AaAAAYbbLRYOLrP4/HY9W+XrVtZ1kWQ+d5UtjPjaFejVczQxkAAOB6kwXr2+32cDjEcHyz2cTYvW6/38+WmlI9OWy326Ioqsb+kGoaPQAAnJqyg2mMjE8/n79f5na73e/3z8/Px+Nxt9tNVZI+g73ohAoAwFSyqYLLPM+32213OnifaaZVz1O/cr1ZNlldAQCQmjSDvcnKlGXZZrPpSHQpimK329Vfcbosae4/AAAmkWawd1UaTBWan/5xaqExOgAA3MtVDxDVgIz9HQ6HhY6cmObDFgAAk0gz2LtqNJhBYfdms9nv9wuN1AEAYH7z5awvXZoPWwAATCLNYG+yoRsfodXc0I0AAMwpxQeINKX5sAUAwCTSDPamfClS1J0Js/rWdwAAmMqUwbosEQAAmNBVo8HU9YnUAQCA/qYJ1qvUl8PhUHaaZHUAAPAIpgzWH2FAGAAAmM1kaTAAAMC0pgnWY4P6it+IBAAA85tsOMntdns8Hlecld6zB+2KawAAYMXSHGd9sjSY2KyeZVme51MtMzXdfWf1oAUAYFoTt6xfnGy54WyaD1sAAEwizWBvsjKtPkskzf0HAMAk0gz2JnuD6eFwmGpRAABAmLBlffXSfNgCAGASaQZ7xlkHAIBETR+s53m+3W6zLKuy2LfbrSHYAQBgqClb+/M8f35+rn8SFx6j9s1ms+iQPc1fRgAAmESawd5kLetVpL7ZbA6Hw2azqb7a7/chhOPxGF90ulxZD/cuIwAA6zHx0I37/T6+FCnG7tXCi6LY7XbB0I0AACQpzWBvmpb1mN+y2WzOvb50u93GtvYVv98UAACmNWWw3p3lsvQcGAAAmNlkL0UKH0J2AFap+yIfW2T6tN1MqyiKqmDb7bZj1f2nHDpxT0VRLKXd6vr9OPmRUNVeRzWerrS7GH3iltGbMP+5wGqVU6heX1p9EjuV1qeJExwOh0nWOL+p6gpgiS6+pjpONuGdZXSRWm809WEPKvv9vv9iWyceWtorFzKbEMJms7lmCbHC+9/0N5tNxxr3+338NkYX56qxsdI4ccdiuw/pKw/mWJjRs3MXae6yaVrWqwfHc0Oq1yeYZI0A3EUMgM7ZbDbH4/HKVWRZdnG032rcgnp3qTzPj8fjbrc7HA712001gnB8E0hsNX9+fo6DmNU7U9UXWzWon5v47uJ2len1hxvheDy2PlBFN/pRonEwx13cfYTf1Ha7PR6P69ihTGnCwL9aZnW+xUfh6vPlNquXqT5sAcwjNgxf2draU58VnbutVJFW45PWBZ7eB6ubV2PK0x+Qh7pFy/rk9/EJ9W9Zr+q2uwk8/jFty/rpWiaszxEt6xrj7y7N+p/yDabV8OpVs8rz83P1d6OdA4CHctpSXs8LHyQ2b+/3+9PbStXyXS05/tHaIh7vWY0pW0c2Gzqm2bSduEZUVJ9ZxhVy9F47led5lmXxp4zuySZZ3e0MqpDig6GruPhb04S7hrRMHv4fDofYoB7t9/tFN6hXblFXAEvRs2W9fmep2pIbrd2nSeFVQ2kjEeJcA2r3/SvehqpbT1zmuUXV71AXG4Mv3tFON62avtGyHuuksbTTDxsVUtV/I1Wjvl/OzRLFMlTlPLc59RnjxLFW++ydejEuVtf+g46jK8YS9Q2/e8t6tacatX26706L11qHp0dOY13ndujpBKf10zrXoJp5HD0PgJmlWKY0pbn/AOYxOlivApRq3up/63F8DC/qEWFHZNw/qCprYdDFUHvQYi+uqNrw+reDgvURFdU6S32vte6R1qpoBOvVM0991R21MaiDaffRdRq5JhKsV/VfT/ptPCWeztKow0ZpGzu0nldcX0v/xZaC9SGuuQLczpS5WetoQT8nzf0HMI96YvGparLT8LQRWp2mbp8Gat1hxIjs+dPG5tYb1pXB+uns9eB7XLB+2i5eX0Vr3Hbaqno6S3ejeNkWrHdsWqupgvX4VWO9547D1vD3psF6fQMbW9EI1s/VYX1fNGZprZZGxZ623/c8oQTrrdIM9iYbZz12wI+HXfrpZePEfvfdSp24gVUbMdhLY7iV8HGO73a7vfWVs0rnjcN9VDesTW3MmSuTfat89/qHeZ7H9Y7ostVanu6Kah2v5nA47Ha7PM/rn4+4TTc2bbvdPj8/zzByfJ7np2keYdRxOLnNZlPf/Pj3uYKdJrrEOuxYftxNjZ1VFEWWZfHQOv2WVZqsg2l1Gj8/P2dZdm4Mx0Xr8/Rz7zIC3FBHokLHLPX/jbHF8XisBxwz2G63eZ7H0taHQ6haYa4MOs9FTkVRjAunqshvaEUVJ8IUHV7vNUTE8Xg8XXV3GsxsWgsWztR2fSTQeFRc7Flbxf2nO7T6qv7Grp6LZXEmC9aLoig/vLYgfGi3WGvUDkBPpwFNFSs/Pz9Xd4qhC+xuWI2hece38Z51roQjFnuLO10VfQ6qqN3HTttuZ45or1Es8yWgrQdD/BUijn4T90vPHbE70ZggLjYuuf9iWZAph24MH37yK2vpXFXU7pcaAEItVq63cE8YkMVXI1UBU0eMGzMTqrh/8/FIjg1FUdQX23CjgLKqqHhXrf8UcE5rk/NCW83O5cAkrvVg2O128cVPVbp5z7io+5f8LMsai13ovqbDxMF6pfq1sTrNYnrMjVYHwCLUh4Kut3APSkGOd5Zz8fFp6nb3wquWyDjLuSyC+O25lVYZDo3PB7VVNWavV1S8q3Y/TnQsdqEB3LRPcZM7rdVzPwVUbwYYlOV/ro28kd0Uu14MqqiFHg8P61bBemWhj8UA3EJRFLvdrhErDP3hvkp8P42Dq0+q2CUuvDWUacTfp3/Uix0j/nORd5ylkXMy9Cfl+kNFTD5uLKE7IIt329NZFprEnH4OTOMhsDpIzmlsy8XDo/X5MB4Y9TOoz2IbBZPssDDnfl650unbE8LCBwm6XV0BpG/0OOuNvoCNwchPxyMv+42gVx9Kshph+nTwvvoC6yut36FaF9tawu4RD+vD+Z0ORt6ojcPHryWqr7cxaPppmTsqqk/d9rkXh5OhG1v3Y0eFVKvuHuuzvrTG53GHNqYcMc56zzKUV4yz3jrAeX1QxdPdXa+fc+WvihSzXDqOgdPR90+nqVbUOgA/Uc8DYGYTl+lcjL6CIdjT3H8A85gqWC/bXrjYGnF2x4LlxwFuXesdp7Xx/tzmtE7c50Z2umnVXKe10VhLfOoIbbHmuWKcBnyndbI5Gal95mC9VWPi1qOrtc7HBet9ylAOD9ZPl98xaPrp7i5rh/ppgc/N2KiW1kOu8ZB2elT0PJ0fUM8DYGZZOdFog3meN37+i+OPruanliybrK4AqPJu62PPNb7tcwepLydcyproXuk1E5/OONUq+lRU46vRJU9KY2z4pMSY53A4xH4X1+zuPM/r/ztuh1YJM+cWW19IsrWagjSDvcnKVO88usr3IqW5/wCAmdWD9XuXhSmlGexN9gbTsNIYHQAA7mWyYD3BBxEAAFi0mw/dWEk5+QwAoKftdutFocxmZGpOHCg3nDSox/5Arf1KY1L7chvg00xjAgBgEmkGe1PmrEeD3kIHAACcM32wvmL1EW/OSfCBDACAhRKsDyAQBwBgTvN1MAUAAAYRrAMAQKIE6wAAkCjBOgAAJEqwDgAAiRKsAwBAoq4dunG73db/N74R6Xg8Nj4HAACGujZYP/e+Uu8xBQCAK40M1rfb7WazmbYoAABAXeatnD1lmboCAFitNIM9HUwBSEOWhSy7dyEA0iJYBwCARAnWAQAgUYJ1AABIlGAdAAASJVgHAIBECdYBACBRgnUAAEjUyDeYAsDkyhBSHmi9KIrtdnvvUoSiKFo/Py3buSm752pdY7Wo7XZ7cZb69CGEPM9vVDB4CLlMJfsAACAASURBVCX9qE+AG/n3//3fv7/55t8h/DuEf3/22b//+7///X//d+9CNR0OhxDCfr+/d0HK/X5/7h50OBzqU15/24pbfaqjHjabzen0m83m4jT9VwE3kmYgp2V9gDK9N9ACLF359m3485/D73//W5v6u3fl+/fhyy/LN2+yFy/uW7YrZVkWbnbv2Gw29bbnoiiOx+Nut9tsNlW7dSOsf35+Pv2ww3a7PR6PcV1V63ie58fj8fn5udF8Hsuw2+2qssXiFUXx/Px8PB7rL3LP87w+byx8Y4u0rMNv7vywsBzqCuAW/v3NN//+6qsyhPq/f3/99b//+7/vXbSPjGhZv9F9NkbbpyWpWsEb7evjytOxtHNfxQ9bqyg2pTfa1xvfakrn7tIM9nQwBeCuXr/O/vGPxmfZ69fh9eu7FKfhYnZ18cGgZQ6dpY/tdhvD6Ni8faW4kMPhcNrC3bqiONl+vz/NUA8fqvF4PE6+1bB6gnUA7qZ8/z68e9f+3fv35bmvbq8oiizLsizb7XZZlrWmZGy32zhBlGVZFafG2ePfcTn1z+uzTJvsUS3typg4bkgjL6WxotgcXm1yTJhpjdSjGN93TAC0EqwDcDfZ01P47LP2756esnNf3Vg993q/3+/3+5gOXp+myufe7/eHwyGmpsRM7vhtlRoeJ4h/x4VUs2w2m+PxOG283qfv5kVxK7oD6yolvfpv96rj9LHSgP50MAXgrr76qnz/Pvs46aV8+TJ8+um9SlSF1FW0ut1uG8F6DDrLD4naMRKNwXr8O8/z2KGz3jWzvtg4WZZl08av8SniylEm+xRpu93GnqPhQ7CuSyjcgpZ1AO7q1avwyy/l119XH5QvX4Z//Su8enXHQoWP25WrrI/K4XA4N6xhxwIPh8OC8kC6g+/Robm0dRhEyzoA95S9eFG+eRN++KF8egrv34enp/Dpp+HNm+x3v7tLec5ldFR5L9X/1qePAxReXHh9rlv0MZ1Wd/P86MJrgIdBtKwDcGfZixfZ999n79+HELJ377K///1ekXo4n9HR+CQGslVv0efn5z7J4nmeV/1W+wT3I0ySkRK3pTscrz/V1PPXgWkJ1gFIRXbvAoTzYW4jEt3tdvE9PtVY4xfzW2KSd/jQwbQsy1tEt7H5/8pgvU/wXX8q6NN5tBph5pqCwQMSrAPAf1RdRRuf1yPXqqvooH6cVZ/UPM9vlAoyVUAcl9MxLHp852ioZfbXm9hbNbrbAj0J1gGgRSNOPW02bgSmI8LQ1lB4dHN7Nf7MJA321WuPTpdWDW1Z72JbvfaotR5iXXUM3A6cI1gHgI9UcWqe50VRxETz+gQx4qwC2di+Xh/EMGrN/I7LjH9Uw0FW08Q4uLG6Vs/Pz9sPYh58jNSHjlFzTjVU/G632263VVVUo1ju9/tG5B1X/fz8HN8PVU0fh6fcbDaS2mGMkn7UFcBthVAmc6WtXmlUiZHofr+PEzRSTTabTflhzPXqflFfSFmWp2F0fONStfz6NIPKVi9DhxH3/XOhf5Wpf6o1Caeqt45ZuqeBGaQZ7GVl7eJChyxTVwC3FJuTU7rSxtEVY+v1uW9DCPUJYltyY4jGPp9U2SOxcT2pO059lMlztXFulp7TQwrSDPZSLFOa0tx/AOuRXrB+FzGBRMYIzC/NYM9LkQAgFfHlSlPlnQMrkOIDRJrSfNgCWA8t68BdpRnsaVkHIA3p3SMB7s7QjQAAkCjBOgAAJEqwDgAAiRKsAwBAogTrAACQKME6AAAkSrAeQgh5nmdxfF8AAEhGimO/z6woit1uF0Loroo0x8kHAGASaQZ7KZZpZlWbumAdAOBhpRnsPXoazHa7DSHs9/t7FwQAAJoeOlgviuJ4PB4Oh3sXBAAAWiw4WN9ut3med0xQFEWe59vt9tyUu91uv9/HxnUAAEjNJ/cuwEixUbxjgjzPn5+fq/89Ho/Pz8+Hw6EKzbMs22w23eE+AADc0VJb1uP4LedUkfpmszkcDlVKejVXjNHzPC8+CCFUfwAAQApS7PTaIcbTVZP5ZrNpDa/jAC/7/b7ecF7/sNHuXneuQtLsIAwAwCTSDPaW1LKe5/lutzsXZNcna/wRxfb1OHue52VN/OpwOCS4hwAAeFhLylmv9wTtyFmPbe2bzabxeUdr+unyAQDg7hYWrFfxdJ7n54L1+HlH5F0Uxbi4vHp90pW03wMA0MeS0mCmcprmHrNiLs5YTuQmWwUAwOqsNlhvbTs/zY0BAIBkrTZYBwCApROsAwBAolYbrLeOv9790tOLsh6uWT4AANStNljvMHqIRp1HAQj3e+O112zDA1phsB57kbqiAXAju92u8d69GcQ3A7q7waNZYbAeL6CnGS/VhdXLjwAAWIQVButVLN4IyuPrS/f7/ewlAmBVyrLUwg3MY4XBegjhcDiEEI7H43a7LYoiz/Oq6+f8P1wCrEqWLfXfcENz0/tMXHwwegLgoawzWN9ut7EF/Xg87na72KYeQtABFIA+YivPbrfb7XZxsK969JxlWePH2+12G6ePXxVFkWVZPf0ythlVy4xTNlZaLaSaQMgOLDVYz/O8+1fIOMH+g8PhcH2kbuhGgFCWS/3XW57nVebk4XCI4xbsdrtz02dZdjweN5tNvOPEdqLWyTabzeFwqJZZv2tst9tqIYfDITY5dawUeBCf3LsAtzVt0ouGeYBHECP16ppfFEWMpFsnjjea/X5f3XHquZd1m82mamOKTe/1b+Pyqwliy/3z83Nc+xVbAyzbUlvWAWA2RVGca6+JkX2jbSg2nDd0TzPJL8DA+gjWAeAjMQWlyj4fsYTWtvDuBvLq29i7tErFAR6cYB0APpLneX2UgtMOpg2n7egjEldiukvVwVSkDkSCdQBoiqMUxI6eVQfTc/H6aTr70Pb4oih2u93xeKxGRIhjJIwpOrAuK+9gCgBDxVB7+0H4MD5Mnuc3GksxLvZwOOhLCjRoWR/A0I0AjyAmotQ/6YihY7t7o/Po0CSW1mcAmTBAEKwPUvZw7zICMI3YuzSKsXvrcMAxzq7a3U/HZOy5rrj8uLT6cI3eiwQPTrAOAB+JLS+xd2nVyr7f78+1rx8OhxDC8/NzfeJBa8zzfLPZVP1Z40KqxcqNgUeWaQzuKcvUFcADic3k4UPyes/p48Qxx31oDnq1xqoJv77MgcUHBksz2EuxTGlKc/8BcF9V9kv9w/jGU3cNWJY0gz1pMABwlePxWG/5zvP8eDy2vsQUYKgUHyDSlObDFgB3F9vRGx+6ZcDipBnspVimNKW5/wBIQT0TRoo5LFSawV6KZUpTz6G41CcAwBKlGax7g+kACe4/AABWTAdTAABIlGAdAAASJVgHAIBECdYBACBRgnUAAEiUYB0AABIlWAcAgEQZZ32APu9FMhY7AABTEawPIBAHAGBO0mAAACBRgnUAAEiUYB0AABIlWAcAgEQJ1gEAIFGCdQAASJRgHQAAEiVYBwCARAnWAQAgUYJ1AABI1Cf3LsCSZFl2cZqyLGcoCQAAj0CwPoBAHACAOUmDAQCARAnWAQAgUYJ1AABIlGAdAAASJVgHAIBECdYBACBRgnUAAEiUYB0AABIlWAcAgEQJ1gEAIFGCdQAASJRgHQAAEiVYBwCARH1y7wIsSZZlF6cpy3KGkgAA8AgE6wMIxAEAmJM0GAAASJRgHQAAEiVYBwCARAnWAQAgUYJ1AABIlGAdAAASJVgHAIBECdYBACBRgnUAAEiUYB0AABIlWAcAgEQJ1gEAIFGCdQAASJRgHQAAEiVYBwCARAnWAQAgUYJ1AABIlGAdAAASJVgHAIBECdYBACBRn9y7AEuSZdnFacqynKEkAAA8AsH6AAJxAADmJA0GAAASJVgHAIBECdYBACBRgnUAAEiUYB0AABIlWAcAgEQJ1gEAIFGCdQAASJRgHQAAEiVYBwCARAnWAQAgUYJ1AABIlGAdAAASJVgHAIBECdYBACBRgnUAAEiUYB0AABIlWAcAgEQJ1gEAIFGCdQAASJRgHQAAEiVYBwCARD10sJ7nefbBdru9d3EAAOAjjxus53n+/Py83+8Ph8N+vz8ej+J1AACSkpVlee8y3EeWZZvNpiiK+L8xdu+ojSx73LoCAFi9NIO9x21ZDyHkeV79HZvVq9gdAADuLsUHiLvYbrfH41HLOgDAY0oz2HvolvUQQlEUsYNpd6QOAADzW3Cwvt1u63ksp4qiyPN8u912TLndbvf7/WazCR8yYQAAIBEptvb3URTFbrer9xBtiB1GGx8eDodzEXlc4H6/PxfWp/nLCAAAk0gz2Ftqy/put+v4torUN5tNHJmxMVdsdK/PolkdAIDULCxYj0F2lmXdk8VIfb/fF0URc2Cq56QqRn9+fjb2CwAAKUuxtf+c08yW1jSYarLGpjU+jxF/NY3RYAAAHlmawd4n9y7AAPVMlaIojsdj62QxfI99Rusasf7hcNjtdvVG+sPhMF1hAQDgWgsL1qt4Pc/zc8F6/LwjBz3mxmy327Isq4b5PjnrF9NvekrwoQ0AgAQtKVifSgzW49+D+pUKsgEAmNPCOpj21xqFn+bGAABAslYbrAMAwNIJ1gEAIFGrDdZbx1A/1ycVAAAS9IgdTEe/rLTPaDA6oQIAMJUVtqzHXqS3eDtp2cPkKwUA4GGtMFjP8zy0ZbzEz8MVLesAADCnFQbr58ZQj68v3e/3s5cIAADGWGGwHkI4HA4hhOPxuN1ui6LI87xKN6/a1wEAIHHrDNa3221sQT8ej7vdLrapB70/AQBYlGzd8Ws9T/3KVPU+Q8EEzwMAAMuUZSkGximWKU1p7j8AACaRZrC3zjQYAABYAcE6AAAkSrAOAACJEqwDAECiBOsAAJCoT+5dgCXpM3pjgp2IAQBYKMH6AAJxAADmJA0GAAASJVgHAIBECdYBACBRgnUAAEiUYB0AABIlWAcAgEQZunEA46wDADAnwfoAAnEAAOYkDQYAABIlWAcAgEQJ1gEAIFGCdQAASJRgHQAAEiVYBwCARAnWAQAgUYJ1AABIlJciDeANpgAAzEmwPoBAHACAOUmDAQCARAnWAQAgUYJ1AABIlGAdAAASJVgHAIBECdYBACBRgnUAAEiUYB0AABIlWAcAgER5g+kAWZZdnMZbTgEAmIpgfQCBOAAAc5IGAwAAiRKsAwBAogTrAACQKME6AAAkSrAOAACJEqwDAECiBOsAAJAowToAACRKsA4AAIkSrAMAQKIE6wAAkCjBOgAAJEqwDgAAifrk3gVYkizLLk5TluUMJQEA4BFoWR+gPOPfRVH9fe8yAgCwHoL18cq3b8tvvy0//zxst+Xnn5fffFO+fXvvQgEAsB6C9ZHKt2/Dn/8cfv01e/cuCyF79y68fx++/FK8DgDAVATrY/34Y/j977N//KP6IHv9OvzhD+GHH+5YKAAA1iSTZt1TlmX1mipDaO1t2vxc9QIALEGWpRgYa1kfo3s3JreTAQBYJsH6EGUZ/2VlGT77rH2ap6fsw2Sa1QEAuIZx1sf66qvy/fvs9ev6Z+XLl+HTT+9VIgAAVkbL+livXoVffim//rr6oHz5MvzrX+HVqzsWCgCANRGsj5S9eBHevAlPT+XTUxlC+fQUPv00vHmT/e539y4aAAArkWKn1zR1dBAuiyLbbuctDgAAU0pzNJgUy5SmNPcfAACTSDPYkwYDAACJEqwDAECiBOsAAJAowToAACRKsA4AAIkSrAMAQKIE6wAAkCjBOgAAJEqwDgAAifrk3gVYkizLLk6T4IuvAABYKMH6AAJxAIA76NFg2mIVkZs0GAAAEjYuUl8LLesAACRvUDP5iuJ7LesAAJAowToAACRKsA4AAImSsw4AwIxWlFA+Ay3rAADMRaQ+kJZ1AADmtYoR0OehZR0AABIlWAcAgEQJ1gEAIFGCdQAASJRgHQAAEmU0GAAAxjIU440J1gEACCGIvFMkWAcA4IpI3aDptyRYBwDgA5F3YnQwBQCARAnWAQAgUYJ1AABIlGAdAAASJVgHAIBEGQ0GAGCNDJq+Cg/dsp7nefbBdru9d3EAACYiUl+Lxw3W8zx/fn7ebDaHw2G/3x+Px8xhDQCsSVkO/kdisvJR90qWZZvNpiiK+if7/T7P83PTP2xdAQALE5sgHzZ0GbX5aQZ7j9uyHkI4TX2px+4AAHBfj9vBtPXJSeY6AADpSLG1v6ftdrvdbs9lrYQQig/ixB1ThhBiwnpHbaT5ywgAQAtpMGElaTBLbVkviuJ4PHZMEPuPVv97PB6fn58Ph8Np23k15eFwuEFJAQBgpKXmrO92u45vq/i7Guylda6iKLIse35+3u/3ZVnKgQEAICkLC9aLooiDo3dPFiP1/X5fFEVMgKl+1KiSYYqi2O12m82mLMvuDBkAALiLJQXreZ7vdrt6csu5yRp/RLF9vZo9RuqGfwEAIFlLylmvp6l05KzH+Huz2TQ+r2exVzF6I6CPnVYnKCsAwIS8uvFRLSxYryLpPM/PBevx846Yu4rUj8djYyHV6DGtpnrFaYIdjQGA+Yi86W1JwfpUYuL7iIhZkA0AXGt0pC4OeUhLylkfpLVl/TQ3BgDgDspy8D8e0mqDdQAAWDrBOgAAJGq1wXprP9Hul54CAEBSHrGD6ejBGfuMBqMTKgAAU1lhy3rsRXqLtx2VPUy+UgAAHtYKg/X4nqPTjJfq/UdeewQAwCKsMFivYvFGUB5fX7rf72cvEQAAjLHCYD2EcDgcQgjH43G73cZXIFXp5lX7OgAAJG6dwfp2u40t6MfjcbfbxTb1oPcnAACLkq07fq3nqV+Zqt5nKJjgeQAA6BYjCgHDTY2q5CxLMTBOsUxpSnP/AQALI1ifwYqC9XWmwQAAwAoI1gEAIFGCdQAASJRgHQAAEiVYBwCARH1y7wIsSZ/RGxPsRAwAwEIJ1gcQiAMAMCdpMAAAkCjBOgAAJEoaDADAFXp0aYPRtKwDAIwlUufGtKwDAFzHEBTcjJZ1AABIlJb1AYyzDgDAnATrAwjEAQCYkzQYAABIlGAdAAASJQ0GAOADQzGSGC3rAAAhBJE6KdKyDgBQYzwJUiJYBwCuNq5NWlgMl0iDAQCuI3sEbkbLOgAwhUHN5OJ76EewPsA0bzCNC/HDHwAAlwjWB/AGUwAA5iRnHQAAEqVl/Q7KEGTqAcDNyYxn+bSsz6d8+7b89tuYSVN+/nn5zTfl27d3LhMArJVInVUQrM+kfPs2/PnP4ddfsxCyELJ378L79+HLL8XrAHBDZTn4H6REsD6XH38Mv/999o9/VB9kr1+HP/wh/PDDHQsFAEDKMiOc9JRlw+uq9gPcuTz1ls/tEQCWZcSoxDMMZGys5Ec2au+PCfZuT8v6HLp3e3IHBQAAaRCs39KH7LesLMNnn7VP8/SUSZUDAKCNoRvn8tVX5fv32evX9c/Kly/Dp5/eq0QAACROy/oAWQ9nZ371KvzyS/n119UH5cuX4V//Cq9ezVF0AAAWSLA+QNnDuXmzFy/Cmzfh6akMoQyhfHoKn34a3rzJfve7OTcBAIAFSbHTa5om6yCcZWUImWoHYDWMBkNqjAbDNbxRDQCAPnQwBQDupKOvFxBCEKwDAE1iaEiGYH126eVCAcB/zBOpuxtCP4J1AOCEYBrSoIMpAAAkSrAOAACJEqwvQZbp6wMA8IAE6wAAkCjBOgAAJEqwDgAAiRKsL4MBtAAAHpBgPWnl27flt9/GSL38/PPym2/Kt2/vXCYAAOYiWB8g62HC1ZVv34Y//zn8+msWQhZC9u5deP8+fPmleB2AAeKQYv3/ASnJSq8o6yfL5q6r8ttvw6+/Zv/4x0cffv11eHrKvv9+zpIAsFSjg2/hAYsWj/yBh/H8wV4fKZYpTTPtv9pVtQyh9RLb8rmdCECrUSELLN6KgnVpMInqPlKSO44AALgBwXpiyjL+y8oyfPZZ+zRPT9mHyX77R4O0S6CPu18rhmaT373AwOw+uXcBOO+rr8r377PXr+uflS9fhk8/vVeJAJiMsBvoQct6wl69Cr/8Un79dfVB+fJl+Ne/wqtXdywUJE27I4vT+KW0+x/weATr6cpevAhv3oSnpzKEMoTy6Sl8+ml48yb73e/uXTQAAOaQYqfXNN2zg3CWlSFk69hTI3pnzzML62DXM8h9DxjXQ7gdo8EwM7/rD5XcqQYkybUCSJxgnVUp374tv/023n3Lzz8vv/nmhi98TTY9OtmCsQ6rOMBmvVYAXEGwznqUb9+GP/85/PprFkIWQvbuXXj/Pnz5pXvwQ9FQykWuFcCCCNZZkR9/DL//ffaPf1QfZK9fhz/8Ifzwwx0LxTw0lDKAawWwHCnm0afpvh1MQ0iye9Cork6DO8t2z1L7Ob48k9zf/HyqmlzTflm43xpKa+FX+fXX4Zdfwps32YsX9y3bCi2xj+PHeTtzXyvO0cEUbkcHUxhqRMPnoFm6z63kzjympaGU3lwrgGURrC/B8t+FMSJDtO8sH94VkpVl+Oyz9mU9PWXeKrI+9bevf/99PVL/7fvXr8Pf/77g97QvrsApq10BXCuAZRGsM4sRDZ8jZvnqq/oLX6Py5cvw1VejC94t2Zt5sgW7BQ2l81t8rc5+rQAYLcXUnDSlmcZ0Z90JYSOyyXt81fL5hwKUb9+GL78Mf/hD9vr1b5+8fBn+9a/JX/tavn0bfvwxfP99CCF89ln46qvw6lUKudHJFuzWys8/z969a/n86an182VIL9V4/AGW2LbMdq24YHQC+gjJVD7MZEUni5Z1bm5Ew+e4ttLsxYvw5k14eipDKEMon57Cp5/eJFJPctC3ZAv2m5smdWgovb3UD7Ah5rlWAExCa3FfWtZb9B7aZUTD51VtpSPGnOmt/Pbb8OuvjQzp8uuvw9NTFlsc7yTZgv3mlm2rqTSUTiu11uhrDrBbnpJXuW/BEtvFQJrBXoplSlOa++9ehv4aXn7zTXj/vgqkfvvw5cvw6afZ3/8+1Sz/Me0tMM1B30LCBWt147ikfPs2/PBDiMfG09Nvx+RyI/WQQCQ3xQGWemrWfSv57rsY+FiawZ40mAGyHu5dxjmM+TX81avwyy/1RIXfGj5fvZpylttLti9jsgWbTfbiRfb99/EMzN69y/7+92VH6iGElHbcuAPsqswZg+EAhBAE64OUPdy7jLMYPk7LiAzRhJJKkx30LdmC3dUK4rtU3sZ6/QFm/HuAq6XY2p+mNH8Zmc+4oV1Oa2zyN5iemaV97VO4Kj/nlpIt2G/m+cV/+XkFyb6NtdcBNmFq1iMcMMs/XGFl0gz2tKwzzPXpFiMaPtNqK00yPyeE6wo2S8pBcte/0W5aXde0Rt+0YAMPMKlZv5knn0fWEKyXYJ1+Rvwant6z6SQSys9ZSMFSSepI2RLextrrAJOaBTC1FFv705TmLyN3Mfc4LfPMMsKaRqO7WY3NndSx0NyJD5F3XOK51JHmV21pZhMXrFX/MVvTGdPpjmvpWMWEa5dRA1NIM9jTss5wyeaBVEY0141qqpyjbTPZgvWki2EfS/vlqu8BtsprBQmSBcSqfXLvArA82YsX5Zs34YcffrvFJZNuQSo+vmue3kKz16/LEEKjbVXMFH31VXmmNfpeJRrtymvFuf6pAA8lxdb+NKX5y8idzZNukeyv4Wsq2G1eI3VtUsfoVSe4U3q76m2syW7+kGtF6u9RGkoazAwefPOZTprBnjQYrqLdixZ3TOpYflZDsh2Fr9TzWnHVe5QA1ijFB4g0pfmwdWdLbPSdcC1rKtjNOsumPvr7OPP0LU72pQS3nKX89tvw66+N8XDKr78OT09ZbGtfnI6dMmnLeqL93efx4C3rD775k0oz2NOyzrxGNHwuv600ZTcfVzH9LoZD3Kq6GmMyfugtl5376qQ73YLHx/x4o7IzI1dmjZErl2CenbLgXQ/0I1iHxzVDysGakjpuVV1Xh54LTh1ZSNg9wjw7ZcG7Hugtxdb+NKX5y8hZif20vQDJ1liyKQdDC7b8n+lvlaFxriZ7d0ycdT9OO8vJ5+Xnn2fv3p0uoHx6+u3zhVx2eu2Uq7dlhVlD4yzkqLiVB9/8SaUZ7KVYpjSluf/OSiwoXIC5spBDuGs2eSN34vxQLZfHaRkerA+bPhG1GutbXeFWgWxrqQYU7NZp0x36B+sXOznMdiBd1+p/q6MlzHJMLs7y2wKustCra5LSDPakwfDoks34vHXBuq9GyV2r7i3Z6kq2YCMl0snh6kh99LeprSVxyV7AYUKCdR5ashmftypYbajEAeMqPrKU3y26xv2YVieHxm7t/lebpe9Oua5UKR6T80r2Ag7TEqxzhRXcA378Mfz+9/WMz+z16/CHP4QffrhjoUKYq2BffVVvwozKly/DV19NuZbVSLa6ki1YZci1InvxIvv++9iynb17l/3970vsjjzTTkl/199UshdwmFSKqTlpSjON6awHT0DvMGGy7+i13zoLubdZX5a5/APsqurqcH0H0+v244VRwIea6rIzolomNPoSOsI1HUxvdEzeV3flj0jZX/Jlp5cHT9mfVJrBnpZ1HleyGZ+zFSytlIPkJVtd4wp2Idl3vYMqrkmyx+QMkr2Az0nK/oNI8QEiTWk+bJ2lZb2fy+PETav/oIqzF2xww8zjtaz/xy2G6LmiZX1EwX5L9q2lEJRffx1++SW8eZO9eHFh7edMO8viWtbPL2qekabW07aa7HUyMZfPYoZLM9jTss5jSzbjc/aCaUcdZI7qGtUnpG/BJPvOaJ6T6xFP4WQv4PNwFj+MFB8g0pTmw9ZZoxpK19Mw09vcGZ+DGj7nLVgIg9tEhx0wKbSsT5WEPe223PIdQ82vPrhJsm/KLesT5t+n+ZvSQ65lnSn7He77goUUruG3l2awp2V9bUZksD1y0ttsGZ9DKznlVNSlHjCSsD94uGRfu36lUr5O3trDncWPTbC+KiMGnTVOX94qGgAAGKVJREFU7QzjxI2r5DQHsBt/wCQy0Gfn8NjtX61Dbbt6jc+9Pv1HTF/lAbBSaV4nb2XoWewwXgvB+rqMyGCT9PbBDRvfrqvktFoFHTDr8ODJvqxOWtfJeTiLH0aKqTlpSjONKYRRg872+Krl8zQ3fyq3yEL+YO7MwhESGwD+JiYddOXsLBMWbMQsEyb73n2g8Qkr/7776+6n8ALXcvPBqVZh1hdljJtlgdIM9tbZsr7dbvM875igKIo8z7fb7cUpF2REBpuktxmsqZLn3pYsk218I4+c7EuyUu8Pk9gVKfWzOLHqWrQUHyCuVBTFbrfbbDZFUbROkOf58/Nz48PD4bDdbjsWm+bDVsOIQWcffJza/7hlm8FVlZxYg9msB8w8DaIP2bJen6W9FTPZVrS7twhqWb/RdfKaUcOXv/lXmee3iDSP/KmlGeytsGV9t9t1fFtF6pvN5nA47Pf7PnMtxogMNklvM1hTJa9pWwghPGayLwnSH+YKzuJ1S/EBYpyiKIqiqJrMz7WsZ1kWQtjv9/Xsl9YPT2dMv65GZLA93Di159y6xWjOzMIR0hzYWMv60Fl69z3oK8GL3rSZ8aMLkFr74kLXMq7P1b1+CEq2qfju7xueahUJSDPYW0nLep7nu93uNLnldLLGH1FsX784e/pGZLClnvS2Cmuq5DVtSyW5C/PkZI5Oav0HzHk32vY19e1ZihG1akfcS4oPECPEZvXq7+Px2Nqyvt1uz30VG9c7aiPNh62zvMF0KKMcDDXDAXPjBuzy7dvw44/h++9DCOGzz8JXX4VXrz7Kjk22uW7CJq5kD7ARbrwtlw+Y9Rq/7fP0h0n2VJ3HkIKN2JUj9/7du5eMkmawt5KW9TioS9TRT/R4PMaJz01wrk/qEo1oSdP4NoM1VfKit8XrwBjkkQ+YmbZdf5jb8+bEhVpJsD6VNQXrQBe92RjkkQ+Yebb91avwyy/1eP23/jCvXk25lgfnzYnL9Mm9C3AHrS3rm80mtrsvT0c2asdX6f3KA3OonRSnp0f2+nUZQvj732csEKk6uX72OmBWc2n9ePP7nixXbH724kX55k344YffFrGK/jD3N+4wHjHLao78JD1isD5aNlEnrSnTofQbm0qyF5pkC7ZkF3uzOa+oe+QDZs5tz168CN9/H/7+9zKmW/TnOtnDiF35yEd+UqTBDFBO5BYla/4797krGosy/fFalqEss7IMn33WPsHTU+ZkIXx0/ex7wKzpmBmx7dNtfrIh4PJ28LjDeKIjf3nVlapHbFkviuI0E2apOTCwRr8NPhD//vzzmwy78dVX5fv31Wjxv63r5cvw6adTrqWSwCgHXGXmAyYpj7ztIYR5rkjzGLErh88ya3U9xqVVy/pHOgaKAeYx0+ADerMxyCMfMI+87SsbDmXErhw4y6qqKxmPFaxvNptgyBdI3CyDD6zy7U7cziMfMI+87SGsajiUOd6cuKLqSkeKY79fKc/z5+fn1jcfFUWx2+3CSRfPOMvp53VpjpOf7hvU12TC97Sv6W3wt3hj0VCTvG6j4+1OE27jtK8leoz3fg+W7KvNVmOe17rd/XD9+HJ0rhtl8/NlHRLTvjmxVmN9qytMFIdMfbSkGew9Vst6leXSSHeJkfp+v++ePevhJuXmjubZpw9+5Nx78x+79hnskQ+YR9v2i8OhLNct3py44uq6r8cK1kMIh8MhhHA8HrfbbVEUeZ5XEXae593z3mekF1LQOq7OuX+JryVZHzatPDP4QPn0tObNZwqOjAQtb6c8+EBAI0w3dtBj1+NZDzcazHa73e/3z8/Px+MxpsRE4mxIxcMPPcFQ6xmsY0XWs1NckQYZVV3rOVpuY4Ut63mel2XZ0Ys0TrD/4HA4iNQhIY899ARDrXD0iSy7e27YlRawU/pXsivSIMOrawFHy72lmEefpjT7HKTQG2Pl5qnhB9+PJ9tSvn0bfvjht3dZPz391spSH3xgwhqbtuvn0LWPW4sOpjXlt9+GX3+tjz4RQii//jo8PWXffz/9+maozGT3V++CXbVT5uoo3H8tl69Ii3PLy87Q6krqaEkz2EuxTGkas//uOMDFtLM8stE1PEKa+zHlcVomKZhgfXHuO1iHYP1cwe44JMgIo8679QwENMtlp6u6Uj1a0gzWHy5n/Rp9Bnv5zz5e+I+YEML9D2NnEd0ujj7hEJrfinfKckt+F32qa8VHy4QE6wOMediap0WWpKT3UH6tBA/j9VUy/dX2fha7o7171zLZ01PW+jk38mG/2Clc5mgZQrAOMAdNRLdisI4E2Sn0d93R8giX1hWOBgOQjvLt2/Lbb2MjUvn55+U33xjiYGIG60jQNTvFsOWPZtTR8lCXVsE6wK0YkmwG2YsX4c2b8PRUhlDGl2d9+ml482bZg3UsnJ1CfyOOlke7tKbY6TVNgzsIJzt+X7LjDKQp2epKeMCEyWa5+zZeXYBeQ5IZDWYq8wzWYTSYdYygkuwN9+7XvalmueXRcrsBW9McDSbFMiVqNeMwjrsQzNb5NbUDck13zXnWsr5gfR6p3TWX6O4HzIJWMU6yoecIyd5wkz2MZwnWu2aZarTHC0VIMTCWBkMPhqkBABJwcbTH9TEaTF/ZuKEb12SeB31Ix9XHfPn5561Dj5WGJAMY5IFHexSsA4/tpk+hBrBbn0dutXnkbV+ZW7835tYe7NIqDQbgZowqyCgphUWrpZIX7MEurYJ1gFsxgB2DPNTQ0feiklfg0S6tKXZ6TdMcHYST7WmebOf0GaRZqpDwTlncaDDzmHYAO6PBtFr4Zv42dPTvf18NSFd+/XX45Zfw5k324sV9yzZeYjvlqkpe0w13BnNV17RjgxoNBuBx6UDNBT/+WA8iQwjZ69fhD38IP/xwx0KtjUpenUe4tKb4AJGm+VrWRxjx5HrrtYwwZ1PxUAmeJnMeLVrWrzfttmhZb7XEzZxl6Oh7uvtO+fhS2beSp3pLmpb1pVVXmi3rRoMZIOsRHiW4j/kPo0MCSbo4dPT0F6/VBIW93aGSYQqC9QFuHojPc9F8pEtzu3XUwIitWNyzyjr2FHR44KGjZ1K7jFxbya5Ig6iu6QjWASABDzZ09H2oZBZIB1MASMCDDR19HyqZBRKsA8D9PdrQ0XehklmiFDu9pinNDsKrMkNvp8frUPWRZPvmP8J+MRrMDFazmVMPHX1uLSGsZZivEeaq5MFrmadgaUrg9pFmsKdlHQDSsrTO4It000oe8Z5Ur1blHME6AMBkfntP6q+/ZiFkIWTv3oX378OXX3YE3yNm4XEI1gEApjPiPalercp5KabmpCnNNKZVmeGVnMlmT84j2QT0R9gvt8hZH2rdNbwmD55NPo9bnpIDXkY7dJaH3V/nPEbOunHWB/AGUwCgw4j3pHq1Kt2kwQxQ9nDvMi5ZWQ7+B49pxMnifIHbqZ1oWVmGzz5rn+zpKWs7NwfMwkPSsg4AMJ0R70n1alXO07IOADCdEe9J9WpVzhOsAwBMZsR7Ur1alQ4pdnpNU5odhB+d9zgOkuzQLo+wXx5hG5mK0WBmMFcle4PpbT3GaDBa1gEAbmLEQC7GfqFBsA4Ajyi59kOgjWAd4PYMu0Yyyrdvy2+/jYdj+fnn5TffeKc9S/UYl1bBOgA8ivLt2/DnP4dff81CyELI3r0L79+HL78Ur0OyBOsA8DB+/DH8/vfZP/5RfZC9fh3+8Ifwww93LBTQIcVOr2lKs4PwozMazCBzDu0ywsPuF2iY/EpVOyvPvbu+5fN1n5LJDrnz4Pepe0sz2PMG0wGyHlFIgvsYAMKlHqXn4njgvgTrAwjE4TKnCaTmw1mZhVB+/nl4965lmqenrPVz4N4E6wDwML76qnz/Pnv9uv5Z+fJl+PTTe5UI6KaDKQA8jFevwi+/lF9/XX1QvnwZ/vWv8OrVHQsFdBCsA8CjyF68CG/ehKenMoQyhPLpKXz6aXjzJvvd7+5dNKBdip1e05RmB+FHZzSYQYxLAIsw10AlZQjZw57dRoOhTZrBnpZ1AHhExn6BRdDBFABSkl7D3gqpZJZDyzoAACRKsA4AAIkSrAMAQKIE6wAAkCjBOgAAJEqwDgAAiTJ0I8uXGSx4CNUFAMshWB8g6xHlJPjiKwAAFkqwPoBAPDn2yCCqCwCWRs46AAAkSrAOAACJEqwDAECi5KwDANzAiJ5COhdxQss6AAAkSrAOAACJEqwDAECiBOsAAJAowToAACRKsA4AAIkSrAMAQKIE6wAAkCjBOgAAJEqwDgAAiRKsAwBAogTrAACQKME6AAAkSrAOAACJEqwDAECiPrl3AZYky7KL05RlOUNJAAB4BIL1AQTiAKyEOxoshDQYAABIlGAdAAASJVgHAIBECdYBACBRgnUAAEiUYB0AABIlWAcAgEQJ1gEAIFGCdQAASJRgHQAAEiVYBwCARAnWAQAgUYJ1AABIlGAdAAASJVgHAIBECdYBACBRgnUAAEiUYB0AABIlWAcAgEQJ1gEAIFGCdQAASJRgHQAAEiVYBwCARAnWAQAgUYJ1AABIlGAdAAASJVgHAIBECdb/Y7vd5nl+71JwWZZl9y4C/2F3pMO+SId9kRS7Ix32xQif3LsAqSiK4ng83rsUAADwH1rWf7Pb7e5dBAAA+MijB+tFUeR57kcZAAAS9NBpMHmePz8/37sUAADQ7qGD9e12W/0tZx0AgNQ8erBexet5ngvWAQBIyqPnrAMAQLIeumV9qKn6oZZlOclyAABYNy3rA5QTiUubdgialJd2iwVO66Fq76H2xeQLTHlpk3uofXGLBU7roWrPvkhngQ+1L5IlWAcAgEQJ1gEAIFGCdQAASJQOpgP0SY3SeRQAgKkI1gcQiAMAMCdpMAAAkCjBOgAAJEqwDgAAicrkYfeUZRPX1bQLTHlpky9Q8dJZ2uQLfKjiPdTGTr5AxUtnaZMv8KGK91AbO/kCEy/eVFIsU5oe5C1ZAAAPK8HAWLAOAACJkrMOAACJEqwDAECiBOsAAJAowToAACRKsA4AAIkSrAMAQKI+uXcBUld8EELYbrd5nt+5QKs2uraLojg3sb02j+12q6pnMLSenRoza1zEojuXadVGV7hTY2aiqauUnLff709r7HA43Ltc63RNbbfO6yCfzeFwCCFsNpt7F2TlRtSzU2NOm83mtJKdF7dzTYU7NebUWsn7/f7e5VoML0U6qyiK3W4XQthsNnmeF0Xx/Pwcv1Jpk7uytrfb7fF43Gw2p20qWrZmEN/vu9lsYqsJNzKinp0as4lVHT5cxEII1XXMqXELV1a4U2M21Qvg9/t9rNg8z+O+OxwOqrqXOz8sJCzWT+MZvfVDrndlbccp/egxs8PhUG+dcl7cyDX17NSYR/zR47Sqz33Ola6vcPtlHtW1q/F59avIXUq1OKqpXXXC9/yca1xf23bK/E5/RBas38KV9ezUmMe5iKT8EJQ4O6Z1fYU7NeZxbneIpgbRwbTduV/Qqt9riqLw281U1PYS1fdIURTxN00mp54XIV7EWlOoq2wNJqTCl8Ud/EqC9XbxQtDRAUX4OKEra7se68d896Cz+e3V0zqrBEQmd009OzVmE6u39TIlW/0Wrqxwp8Zszu0O58UggvV2HXfEzWYjLpnWlbVdnfNVL5a4zOfn5/1+7+LLw3JqzOZcl8TqxxC1Pa0rK9ypcUdxAMfYFbh7TB4qXoo0kofCOfWv7f1+X++N9/z87LILwalxD/VBrvwSO4NxFe7UmE2e51mW7Xa7GKkfDgdV3ZNgvYvL65xG13aVvFiWZZ7n8afM8kO/lmoISHg0To072m63MXAMGndmMajCnRopqPYXFwnWu7jCzml0bRdFUZbl6ezVJ57deUxOjbuIzYcxGSO+9uXeJVq5ERXu1LiL+ERUluXhcIjPRfU0JDrIWWfNdDCAVk6NG6mCDy9CmsfkFe7UmMF2uy2KIu67PM89Gl2kZb1d64BQUTyNZchM6Na17ZYJrZwa06oCx8PhoG5ncLsKt/tmEG/9qroPwXq7GB12JK4J1id0ZW3HruUXlw+Pxqkxpxg4xjRoFTuDayrcqTGbLMu6c11UdR+C9Xbnjp7q9HZ4TejK2t7tdrvdrvXK62cQHplTYzbV7/iaCedxZYU7NWbWUdX0IWe9XXWixsyq6vNqWKh7FGq1BtV29S6M6mIdUwx3u12jX1F9sTcpN6TEqXFH1aDR52JHVT2tQRXu1Lijc1Vd7QsJ672UnHE4HGIVbTab+iCsKu0W+td2FbvXP6wm3n9QfXI4HObbjEcVKzz+Hs3tdNezU+OOLt5qnR3TGlThTo376qjqOHoPF4k7u1QRZJ3T+EZ61nbrZbd1XjtrNoL1eYwI1p0a82it5Dpnx7QGVbhT477OVbVIvb+sNATsJdVvNOfeb8yErqntep8hOwsqTg1o5dSYjaq+hmAdAAASZTQYAABIlGAdAAASJVgHAP5/e3eXnDoOhAHUrpp9Ya8MszLjlTEPXaPy+EfIBoKSOufhVi6xhICXj05bAiolrAMAQKUcigQA8EScrPRnFpC2Z4k5S2Y+NyT9e26Tt/WDmUnKT7SNSb7+mZb69t6RAABVi1MOftcCmp1t4/dOYd/bY34cx6NDHvvbq8fRhyXr35shM095+o2xzS85A0EbDADAeemEkHpsFr/v93vbttM0NU1zmYnf9n2/fiH3+73v+zQkjiCdD9ksZg/D0Pd9/Byj0pBpmvZGHRLzvPjOj+M4TdPri/m4b39bAACoWqawHTH0iwtYi5p0pvCcOR188atMXNw8GjYttdkqWs+L5YWvYvPK+Tz5k1D3Xu/igqeL+S6VdQCAk6LqXFV1Nqrai7J6+u/j8Vg3aqf1b9aqH1sdJntDbrdb0zSXy2X9nnRdl3L2K0Xxruse/31biKc7Lb5aVPXxrQnrAABnpMRZTydM5M5U3k4PxpeKTCN4DInL5lNlRFyeX5beh72xXdetR52T/4JRKMbW8/FtshsMAMAZqaw7z7iH3O/3YRgid6Yfuq47HR9j4LpbPX7IbH6Seca9XVPWgTuV1fMrfFcl+3K5TNN0u91eSdsxyVvW8ylfbsMBAKjbZst43DeZatX55ulNMTA6qhe18EXDd3nP+ma6i/R8YueTtJ7CLVwOXZyX6Vkvv6ZkPfHenvj4fow2GACAw6Kgm0rOR5un27ZtmuZ6vcYMMXwcx9SOcmIL8KhYrwvbUTk+MWH6CtH3fdu2r5T8P+qVUn3ac/1Na3k/YR0A4JhhGC6XS+S8lGjLA99ms3sE92EY1u3jheaHFq2dCOvDMMzb3KPnpG3btm0393k8/UTnvOWJYpKaO2GEdQCAY+Z90iduM12U4Rcpv6r7VmPrlSj5z2v2kdp/xwmgv5ywDgBwwLqAHSn2aHU2Zd915D23ZUr++hd7ReLG0BTc4/FpmjIl9k/7+Vr+VwjrAAAH9H2/2AOxtlr45uNPM3S04D99CXHNY7XTeXli7rqu67o37t74FtW2rQvrAAClNvvCz91m+rQSf65gvA6dhYX/2+02v6brurZtMxE2/WqvjWdv1DRN5+6g3VvAW1RbnhfWAQBKpRtAFw7dZrq5E/nmkZ+H1rZ3/dOzipqtM4ZOHM5acmvsu/74kE562vw4/hJhHQCgSATEzbiZHuz7/uk8T9Pz6c0WN6V5Mmtb/2rR5bK2bhlPryvTivOuhJ0WXEPr0UcJ6wAARfbK6qG8uN51XUThzfQcSXfRFl8is2V4mm2zsyVl6/mT5pP3/X6PxS/+SpDZJz4Naf6fsOOE1L0u9sWDceZr7FLfnHqXNufPn7r6Xf98ewEAAL9AKquX3Kn59JpIqNM0tW2bEmck0WmaxnE8UVbPbBnedd04jpGV+75Pm8SnUnczO6EpDbler9HI3rbt5pBmq2E9daWnUXFNGrVO2JnOmcxfA869Swv5zemr8OUTVAEA6hbV4kPF18KZx3FcTHu5XPYWUDJhzDaO497T7S34xJDNpc4XXDgkPcV8DfmS+fV6LXk38i8txDtWMtu3tI//XgkAAGvDMNxut49GpihC79XjyxcQrSbX6zXfyT3/bbSgPJ12vraSIYtRcX1mVPyF4ecr3Pl3vgbaYAAA/ogIu/MDVjcdvSmzMJ2/ZdRPiveh8ltU3WAKAPB3RAtKzaXitad19w+JvW4q/0YhrAMA/B1RJy7ZQbISca/tzzdmx/eZ1/eT+TRhHQDgT4kA+luK613XfaURZb4rTs3cYAoA8ERUfz83/9Pm6aML+AU7En7bpz/TdxHWAQCgUtpgAACgUsI6AABUSlgHAIBKCesAAFApYR0AAColrAMAQKWEdQAAqJSwDgAAlRLWAQCgUsI6AABUSlgHAIBKCesAAFApYR0AAColrAMAQKWEdQAAqJSwDgAAlRLWAQCgUsI6AABUSlgHAIBKCesAAFCpfwG94tvAlEK7rwAAAABJRU5ErkJggg==\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",
    "        if k=='data':\n",
    "            #Select OOT DT clusters to avoid unblinding\n",
    "            #cut = (dtClusterTime[k][:,0].flatten()!=-999999)#!=0)\n",
    "            cut = (dtClusterTime[k][:,0].flatten()==0)\n",
    "        if k=='signal':\n",
    "            cut = (dtClusterTime[k][:,0].flatten()!=-999999)\n",
    "        h1[k] = create_TH1D( np.abs(dPhi_csc_dt[k][cut]),title=\"\",axis_title = ['|#Delta #varphi| (CSC,DT)','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",
    "        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",
    "            leg.AddEntry(h1[k],\"data, DT OOT\",\"PE\")\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h1[k],\"signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\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",
    "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": "markdown",
   "id": "28f2c854",
   "metadata": {},
   "source": [
    "### Beam-halo events?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29953896",
   "metadata": {},
   "source": [
    "Data show some peaks at phi=0 and phi=pi. Maybe beam halo?\n",
    "* Yes, it disappears once we ask DT to be on-time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc2f3418",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2ec1897f",
   "metadata": {},
   "source": [
    "### DNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "58ef37e9",
   "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",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\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.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",
    "        if k=='data':\n",
    "            #Select OOT DT clusters to avoid unblinding\n",
    "            #cut = (dtClusterTime[k][:,0].flatten()!=-999999)#!=0)\n",
    "            cut = (dtClusterTime[k][:,0].flatten()==0)\n",
    "        if k=='signal':\n",
    "            cut = (dtClusterTime[k][:,0].flatten()!=-999999)\n",
    "        h1[k] = create_TH1D( (dtClusterDNN[k][:,0][cut]),title=\"\",axis_title = ['DT Cluster DNN','Events'], binning=[50,0,1])\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",
    "        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",
    "            leg.AddEntry(h1[k],\"data, DT OOT\",\"PE\")\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h1[k],\"signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\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",
    "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": 69,
   "id": "6056d678",
   "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",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\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.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",
    "        if k=='data':\n",
    "            #Select OOT DT clusters to avoid unblinding\n",
    "            #cut = (dtClusterTime[k][:,0].flatten()!=-999999)#!=0)\n",
    "            cut = (dtClusterTime[k][:,0].flatten()==0)\n",
    "        if k=='signal':\n",
    "            cut = (dtClusterTime[k][:,0].flatten()!=-999999)\n",
    "        h1[k] = create_TH1D( (tr_cscClusterDNN[k][:,0][cut]),title=\"\",axis_title = ['CSC trigger Cluster DNN','Events'], binning=[50,0,1])\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",
    "        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",
    "            leg.AddEntry(h1[k],\"data, DT OOT\",\"PE\")\n",
    "        else:\n",
    "            h1[k].Draw('HISTO same')\n",
    "            leg.AddEntry(h1[k],\"signal\",\"L\")\n",
    "        #h0[k].Delete()\n",
    "        #h1[k].Delete()\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",
    "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": "raw",
   "id": "c9ea8c0e",
   "metadata": {},
   "source": [
    "for k in list(dict.fromkeys(tree_keys)):\n",
    "    \n",
    "    if k==\"signal\":\n",
    "        L = lumi/NEvents['signal']*48.58\n",
    "        den = signal_gen_yield\n",
    "    else:\n",
    "        L = 1\n",
    "        den = np.sum(all_weight[k])\n",
    "    print(\"\\n\")\n",
    "    print(k)\n",
    "    print(\"\\n\")\n",
    "    print(\"Selection \\t\\t\\t Yield \\t\\t Eff.(%)\")\n",
    "    print(\"%s\\t\\t\\t\\t %.2f\\t %.2f\" % (\"No cuts\",(np.sum(all_weight[k])*L) , (100*np.sum(all_weight[k])*L)/den))\n",
    "\n",
    "    print(\"%s\\t\\t\\t\\t %.2f\\t %.3f\" % \n",
    "      (\">=1 CSC\", \n",
    "       (np.sum(n_1CSC[k])*L) , \n",
    "       (100*np.sum(n_1CSC[k])*L)/den)\n",
    "     )\n",
    "    print(\"%s\\t\\t %.2f\\t %.3f\" % \n",
    "      (\">=1 CSC (ME1 old)\", \n",
    "       (np.sum(n_1CSC_ME1_old[k])*L) , \n",
    "       (100*np.sum(n_1CSC_ME1_old[k])*L)/den)\n",
    "     )\n",
    "    print(\"%s\\t\\t\\t %.2f\\t %.3f\" % \n",
    "      (\">=1 CSC (ME1)\", \n",
    "       (np.sum(n_1CSC_ME1[k])*L) , \n",
    "       (100*np.sum(n_1CSC_ME1[k])*L)/den)\n",
    "     )\n",
    "\n",
    "    print(\"%s\\t\\t %.2f\\t %.3f\" % \n",
    "      (\">=1 CSC (ME1+L1)\", \n",
    "       (np.sum(n_1CSC_ME1_plateau[k])*L) , \n",
    "       (100*np.sum(n_1CSC_ME1_plateau[k])*L)/den)\n",
    "     )\n",
    "    \n",
    "    print(\"%s\\t\\t %.2f\\t %.3f\" % \n",
    "      (\">=1 CSC (ME1+L1+0L)\", \n",
    "       (np.sum(n_1CSC_ME1_plateau_0lep[k])*L) , \n",
    "       (100*np.sum(n_1CSC_ME1_plateau_0lep[k])*L)/den)\n",
    "     )\n",
    "    print(\"************************************************************\")\n",
    "    print(\"%s\\t\\t %.2f\\t %.3f\" % \n",
    "      (\">=2 CSC (ME1 old)\", \n",
    "       (np.sum(n_2CSC_ME1_old[k])*L) , \n",
    "       (100*np.sum(n_2CSC_ME1_old[k])*L)/den)\n",
    "     )\n",
    "    print(\"%s\\t\\t\\t %.2f\\t %.3f\" % \n",
    "      (\">=2 CSC (ME1)\", \n",
    "       (np.sum(n_2CSC_ME1[k])*L) , \n",
    "       (100*np.sum(n_2CSC_ME1[k])*L)/den)\n",
    "     )\n",
    "    \n",
    "    print(\"%s\\t\\t %.2f\\t %.3f\" % \n",
    "      (\">=2 CSC (ME1+L1)\", \n",
    "       (np.sum(n_2CSC_ME1_plateau[k])*L) , \n",
    "       (100*np.sum(n_2CSC_ME1_plateau[k])*L)/den)\n",
    "     )\n",
    "\n",
    "\n",
    "    print(\"%s\\t\\t %.2f\\t %.3f\" % \n",
    "      (\">=2 CSC (ME1+L1+0L)\", \n",
    "       (np.sum(n_2CSC_ME1_plateau_0lep[k])*L) , \n",
    "       (100*np.sum(n_2CSC_ME1_plateau_0lep[k])*L)/den)\n",
    "     )\n",
    "    print(\"%s\\t\\t %.2f\\t %.3f\" % \n",
    "      (\">=2 CSC (ME1+L1+0L+HLT)\", \n",
    "       (np.sum(n_2CSC_ME1_plateau_0lep_hlt[k])*L) , \n",
    "       (100*np.sum(n_2CSC_ME1_plateau_0lep_hlt[k])*L)/den)\n",
    "     )\n",
    "    \n",
    "    print(\"%s\\t %.2f\\t %.3f\" % \n",
    "      (\">=2 CSC (ME1+L1+0L+HLT+dPhi)\", \n",
    "       (np.sum(n_2CSC_ME1_plateau_0lep_hlt_dphi[k])*L) , \n",
    "       (100*np.sum(n_2CSC_ME1_plateau_0lep_hlt_dphi[k])*L)/den)\n",
    "     )\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "203572fd",
   "metadata": {},
   "source": [
    "## ABCD method - with cluster size"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cfc1ed0",
   "metadata": {},
   "source": [
    "### Visualization of the ABCD method\n",
    "\n",
    "This is basically a binned ABCD to check if the delta phi cut affects the shape of the DT cluster size\n",
    "\n",
    "* Black points: low delta phi, red fit performed on them\n",
    "* Yellow points: high delta phi, low size of the DT cluster, used to adjust the red fit to the SR integral\n",
    "* Light blue points: prediction from the red fit\n",
    "* Green points: actual data in the SR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "58f5abf3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 50. 150. 250. 350. 450. 550.]\n",
      "[100. 200. 300. 400. 500.]\n",
      "-0.01266339087465341 0.005765941979269565\n",
      "269.2349771086594 0.005765941979269565\n",
      "0.01786527055230133 0.005765941979269565\n",
      "x  pred  up down true \n",
      "300.0 1.2423303167100899 3.7822615401591757 -0.13536934093911349 2.0\n",
      "x  pred  up down true \n",
      "400.0 0.2797909211958022 1.3436291421796296 -0.01932793808661636 0.0\n",
      "x  pred  up down true \n",
      "500.0 0.06892962373354197 0.5479932005606069 -0.002876301117264269 1.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"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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",
    "    hnot = {}\n",
    "    hunbl = {}\n",
    "    hpred= {}\n",
    "    can.cd()\n",
    "    \n",
    "    PHI_MIN = 0.5\n",
    "    PHI_MAX = 2.\n",
    "    \n",
    "    CSC_MIN = 100\n",
    "    CSC_CUT = 500\n",
    "    CSC_MAX = 50000\n",
    "    \n",
    "    x_min = 50\n",
    "    x_max = 550\n",
    "    n_bins = 5\n",
    "    blinding_bin = 2\n",
    "    \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_MIN = x_min\n",
    "    N_MAX = x_max\n",
    "    N_CUT = bins[blinding_bin]\n",
    "    \n",
    "\n",
    "    f1 = rt.TF1(\"f1\",\"exp([0]*x + [1]/(x))/[2]\",x_min,x_max)\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",
    "    \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_dt[k] )\n",
    "        tmp_deta = np.abs(  dEta_csc_dt[k] )\n",
    "        tmp_dR = np.abs(  dR_csc_dt[k] )\n",
    "        tmp_t2 = (dtClusterTime[k][:,0].flatten())\n",
    "        tmp_sizeCSC = (tr_cscClusterSize[k][:,0].flatten())\n",
    "        \n",
    "        pre_cut_phi = (tmp_dphi<PHI_MAX) & (tmp_dphi>PHI_MIN)\n",
    "        cut_size = (tmp_sizeCSC<=CSC_CUT)\n",
    "        cut_dt = (tmp_t2==0)\n",
    "        cut_dR = (tmp_dR>0.5)\n",
    "        \n",
    "        blind = (dtClusterSize[k][:,0] < bins[blinding_bin] if do_blind else 100000 )\n",
    "        unblind = (dtClusterSize[k][:,0] >= bins[blinding_bin])\n",
    "        \n",
    "\n",
    "        leg.SetHeader('CSC-DT, presel.')\n",
    "        pre_cut = pre_cut_phi & cut_dt & cut_dR\n",
    "        cut = (cut_size==True)\n",
    "        cut_label = \"CSC size < \"+str(CSC_CUT)\n",
    "        cut_not = (cut_size==False)\n",
    "        cut_not_label = \"CSC size >= \"+str(CSC_CUT)\n",
    "\n",
    "              \n",
    "        dt_size_2 = dtClusterSize[k][ pre_cut & cut ][:,0]\n",
    "        dt_size_2_not = dtClusterSize[k][ pre_cut & cut_not & blind ][:,0]\n",
    "        dt_size_2_unbl = dtClusterSize[k][ pre_cut & cut_not & unblind ][:,0]\n",
    "        \n",
    "        h[k] = create_TH1D(dt_size_2.flatten(),title=\"\",axis_title = ['DT Cluster[0] 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",
    "        \n",
    "        hnot[k] = create_TH1D(dt_size_2_not.flatten(),title=\"\",axis_title = ['DT Cluster[0] 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(dt_size_2_unbl.flatten(),title=\"\",axis_title = ['DT Cluster[0] 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",
    "\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",
    "       \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": "19b17544",
   "metadata": {},
   "source": [
    "## ABCD functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "111977ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "PHI_MIN = 0.5\n",
    "PHI_MAX = 2.0\n",
    "\n",
    "CSC_MIN = 50\n",
    "CSC_MAX = 500000000\n",
    "CSC_CUT = 500\n",
    "    \n",
    "N_MIN = 50\n",
    "N_MAX = 500000000\n",
    "N_CUT = 120\n",
    "\n",
    "n_ev = 5000\n",
    "\n",
    "pre_cut = {}\n",
    "a = {}\n",
    "b = {}\n",
    "c = {}\n",
    "d = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "ba548928",
   "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",
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: c\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",
    "can.cd()\n",
    "can.SetRightMargin(0.15)\n",
    "can.SetLeftMargin(0.15)\n",
    "can.SetBottomMargin(0.15)\n",
    "\n",
    "vec = np.array([-1,-1,-1])#np.zeros(6)\n",
    "h = create_TH1D(vec,title=\"\",axis_title = ['',''], binning=[10,CSC_MIN,1000])#,bin_list=True)\n",
    "h.GetXaxis().SetTitle(\"N_{hits} (1^{st} CSC)\")\n",
    "h.GetYaxis().SetTitle(\"N_{hits} (1^{st} DT)\")\n",
    "h.GetXaxis().SetTitleSize(0.05)\n",
    "h.GetYaxis().SetTitleSize(0.05)\n",
    "h.Draw(\"PE\")\n",
    "\n",
    "\n",
    "phis = rt.TLine(2.2,0.005,2.2,500)\n",
    "phis.SetLineColor(860)\n",
    "phis.SetLineStyle(2)\n",
    "phis.SetLineWidth(2)\n",
    "phis.Draw(\"L sames\")\n",
    "ns = rt.TLine(CSC_MIN,200,3.2,200)\n",
    "ns.SetLineColor(418)\n",
    "ns.SetLineStyle(3)\n",
    "ns.SetLineWidth(2)\n",
    "ns.Draw(\"L sames\")\n",
    "\n",
    "phi = rt.TLine(CSC_CUT,0.005,CSC_CUT,500)\n",
    "phi.SetLineColor(881)\n",
    "phi.SetLineStyle(1)\n",
    "phi.SetLineWidth(3)\n",
    "phi.Draw(\"L sames\")\n",
    "n = rt.TLine(CSC_MIN,N_CUT,1000,N_CUT)\n",
    "n.SetLineColor(881)\n",
    "n.SetLineStyle(1)\n",
    "n.SetLineWidth(3)\n",
    "n.Draw(\"L sames\")\n",
    "\n",
    "h.SetMaximum(500)\n",
    "\n",
    "latex = rt.TLatex()\n",
    "latex.SetNDC()\n",
    "latex.SetTextAlign(33)\n",
    "latex.SetTextSize(0.06)\n",
    "latex.SetTextFont(62)\n",
    "latex.SetTextColor(2)\n",
    "latex.DrawLatex(0.8,0.75, (\"A\"))\n",
    "latex.SetTextColor(1)\n",
    "latex.DrawLatex(0.3,0.25, (\"C\"))\n",
    "latex.SetTextColor(860)\n",
    "latex.DrawLatex(0.8,0.25, (\"B\"))\n",
    "latex.SetTextColor(418)\n",
    "latex.DrawLatex(0.3,0.75, (\"D\"))\n",
    "rt.gPad.RedrawAxis()\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/ABCD_plane_scan.pdf\")\n",
    "#can.Print(\"plots/ABCD_plane_scan.png\")\n",
    "#can.Close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "75ad2838",
   "metadata": {},
   "outputs": [],
   "source": [
    "def extrapolation(vec,min_x,max_x,nbins):\n",
    "    h = create_TH1D(vec,title=\"\",axis_title = ['',''], binning=[nbins,min_x,max_x])#,bin_list=True)\n",
    "    #can = rt.TCanvas('c','c', 1000, 800)\n",
    "    #can.cd()\n",
    "    h.SetLineWidth(2)\n",
    "    h.SetMarkerStyle(20)\n",
    "    #f1 = rt.TF1(\"f1\",\"[0]*x + [1]\",min_x,max_x)\n",
    "    #f1.SetParameter(0,-2)\n",
    "    #f1.SetParameter(1,60)\n",
    "    f1 = rt.TF1(\"f1\",\"exp([0]*x + [1]/(x))/[2]\",min_x,max_x)\n",
    "    f1.SetParameter(0,-0.03)\n",
    "    f1.SetParameter(1,200)\n",
    "    f1.SetParameter(2,74)\n",
    "    h.Fit('f1', 'LRSQ+', '', min_x,max_x)\n",
    "    my_f1 = h.GetFunction(\"f1\")            \n",
    "    h.GetListOfFunctions().Remove(h.GetFunction(\"f1\"))\n",
    "    #h.Draw(\"PE\")\n",
    "    #h.GetXaxis().SetTitle(\"#Delta#varphi\")\n",
    "    ##h.SetTitle(\"High n hits region: \"+str(N_CUT)+\" < N hits < \" + str(N_MAX))\n",
    "    #my_f1.SetLineStyle(2)\n",
    "    #my_f1.Draw('L same')\n",
    "    #can.SetLogy()\n",
    "    #can.Draw()\n",
    "    #can.Print(\"test.pdf\")\n",
    "    #can.Print(\"test.png\")\n",
    "    return h, my_f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "376b04f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_abcd(var1,var2,MIN1,CUT1,MAX1,MIN2,CUT2,MAX2,sel,csc_th=400000,n_th=150,do_b_extrapolation=False):\n",
    "            \n",
    "    d = np.sum([sel & (var1>=CUT1) & (var1<MAX1) & ( var2>MIN2 ) & ( var2<CUT2 )])#high n, low phi\n",
    "    #risk of unblinding D when phi gets too large. Try to predict it instead.\n",
    "    if CUT2>=csc_th:\n",
    "        low_d = np.sum([sel & (var1>=CUT1) & (var1<MAX1) & ( var2>MIN2 ) & ( var2<csc_th )])\n",
    "        high_d_flat = (CUT2-csc_th)*low_d/( csc_th - MIN2 )\n",
    "        d_pred = low_d+high_d_flat\n",
    "        print(\"d\\t d low\\t d pred\")\n",
    "        print(\"%i\\t %i\\t  %.2f\" % (d,low_d, d_pred))\n",
    "        d = low_d+high_d_flat  \n",
    "    b = np.sum([sel & (var1>=MIN1) & (var1<CUT1) & ( var2>=CUT2 ) & ( var2<MAX2 )])#low n, high phi\n",
    "    #risk of unblinding B when n hits gets too large. Try to predict it instead.\n",
    "    if CUT1>=n_th and do_b_extrapolation:\n",
    "        low_b_vec = var1[sel & (var1>=MIN1) & (var1<n_th) & ( var2>=CUT2 ) & ( var2<MAX2 )]\n",
    "        low_b = np.sum([sel & (var1>=MIN1) & (var1<n_th) & ( var2>=CUT2 ) & ( var2<MAX2 )])\n",
    "        h,my_f1 = extrapolation(low_b_vec,MIN1,CUT1,20)\n",
    "        b_pred = my_f1.Integral(n_th,CUT1) + low_b\n",
    "        print(\"b\\t b pred\")\n",
    "        print(\"%i\\t%.2f\" % (b,b_pred))\n",
    "        #high_b_flat = (CUT2-phi_th)*low_b/( phi_th - MIN2 )\n",
    "        b = my_f1.Integral(n_th,CUT1) + low_b\n",
    "        \n",
    "    c = np.sum([sel & (var1>=MIN1) & (var1<CUT1) & ( var2>MIN2 ) & ( var2<CUT2 )])#low n, low phi \n",
    "    #if CUT2>=phi_th:\n",
    "    #    #low_c = np.sum([sel & (var1>=MIN1) & (var1<CUT1) & ( var2>MIN2 ) & ( var2<phi_th )])\n",
    "    #    #high_c_flat = (CUT2-phi_th)*low_c/( phi_th - MIN2 )\n",
    "    #    #c_pred = low_c+high_c_flat\n",
    "    #    #print(\"c\\t c low\\t c pred\")\n",
    "    #    #print(\"%i\\t %i\\t  %.2f\" % (c,low_c, c_pred))\n",
    "    #    #c = low_c+high_c_flat  \n",
    "    a = np.sum([sel & (var1>=CUT1) & (var1<MAX1) & ( var2>=CUT2 ) & ( var2<MAX2 )])#SR  \n",
    "    pred = (b*d)/c\n",
    "    unc_pred = (1./b if b>0 else 0 + 1./d if d>0 else 0 + 1./c if c>0 else 0)**0.5*pred\n",
    "    if math.isnan(unc_pred): \n",
    "        p_value = float(\"nan\")\n",
    "        z_value = float(\"nan\")\n",
    "    else:\n",
    "        mu = np.random.normal(pred, unc_pred, n_ev)\n",
    "        p_value = 0.0\n",
    "        for i in mu:\n",
    "            if i < 0:continue\n",
    "            n = np.random.poisson(i, n_ev)\n",
    "            p_value += np.count_nonzero(n>=a)\n",
    "        p_value = p_value/n_ev**2\n",
    "        z_value = (norm.ppf(p_value))\n",
    "    return a,b,c,d,pred,unc_pred, p_value, z_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "0b45e470",
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_abcd_masks(var1,var2,MIN1,CUT1,MAX1,MIN2,CUT2,MAX2,sel):\n",
    "    d = sel & (var1>=CUT1) & (var1<MAX1) & ( var2>MIN2 ) & ( var2<CUT2 )\n",
    "    b = sel & (var1>=MIN1) & (var1<CUT1) & ( var2>=CUT2 ) & ( var2<MAX2 ) \n",
    "    c = sel & (var1>=MIN1) & (var1<CUT1) & ( var2>MIN2 ) & ( var2<CUT2 )  \n",
    "    a = sel & (var1>=CUT1) & (var1<MAX1) & ( var2>=CUT2 ) & ( var2<MAX2 )\n",
    "    return a,b,c,d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "5dcca5d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_datacard_2tag(outDataCardsDir,modelName,  signal_rate, normalization, bkg_rate, observation, bkg_unc, bkg_unc_name, sig_unc, sig_unc_name,signal_region, prefix):\n",
    "    a,b,c,d = bkg_rate[0], bkg_rate[1], bkg_rate[2], bkg_rate[3]\n",
    "    nSig = len(signal_rate.keys())\n",
    "    text_file = open(outDataCardsDir+modelName+\".txt\", \"w\")\n",
    "    text_file.write('# signal norm {0} \\n'.format(normalization))\n",
    "\n",
    "    text_file.write('imax {0} \\n'.format(4))\n",
    "    text_file.write('jmax {0} \\n'.format(nSig))\n",
    "    text_file.write('kmax * \\n')\n",
    "    text_file.write('shapes * * FAKE \\n')\n",
    "\n",
    "\n",
    "    text_file.write('--------------- \\n')\n",
    "    text_file.write('--------------- \\n')\n",
    "    text_file.write('bin \\t chA \\t chB \\t chC \\t chD \\n')\n",
    "    text_file.write('observation \\t {0:6.2f} \\t {1:6.2f} \\t {2:6.2f} \\t {3:6.2f} \\n'.format(observation[0],observation[1],observation[2],observation[3]))\n",
    "    text_file.write('------------------------------ \\n')\n",
    "    text_file.write('bin '+'\\t chA ' * (1+nSig) + '\\t chB ' * (1+nSig) +'\\t chC '*(1+nSig) +'\\t chD '*(1+nSig) +'\\n')\n",
    "    process_name = '\\t '+ (' \\t ').join(list(signal_rate.keys())) + '\\t bkg '\n",
    "    text_file.write('process ' + process_name * 4 + '\\n')\n",
    "    process_number = '\\t '+ (' \\t ').join(list((np.arange(nSig)*-1).astype(str))) + '\\t 1'\n",
    "    text_file.write('process ' + process_number * 4 + '\\n')\n",
    "    rate_string = 'rate'\n",
    "    for i in range(4):# 4 bins\n",
    "        for k,v in signal_rate.items():\n",
    "            rate_string +='\\t {0:e} '.format(v[i])\n",
    "        rate_string += '\\t 1 '\n",
    "    text_file.write(rate_string+'\\n')\n",
    "    text_file.write('------------------------------ \\n')\n",
    "\n",
    "    text_file.write(prefix+'A   rateParam       chA     bkg      (@0*@2/@1)                    '+prefix+'B,'+prefix+'C,'+prefix+'D \\n')\n",
    "    if b == 0: text_file.write(prefix+'B   rateParam       chB     bkg     {0:.2f}        [0,{1:.2f}] \\n'.format(b, c*7))\n",
    "    else: text_file.write(prefix+'B   rateParam       chB     bkg     {0:.2f}        [0,{1:.2f}] \\n'.format(b, b*7))\n",
    "    text_file.write(prefix+'C   rateParam       chC     bkg     {0:.2f}        [0,{1:.2f}] \\n'.format(c, c*7))\n",
    "    if d == 0:text_file.write(prefix+'D   rateParam       chD     bkg     {0:.2f}        [0,{1:.2f}] \\n'.format(d, c*7))\n",
    "    else: text_file.write(prefix+'D   rateParam       chD     bkg     {0:.2f}        [0,{1:.2f}] \\n'.format(d, d*7))\n",
    "\n",
    "\n",
    "    #for k,v in signal_rate.items():\n",
    "    #    text_file.write('norm rateParam * {0} 1  \\n'.format(k))\n",
    "        \n",
    "    '''\n",
    "\n",
    "\n",
    "  #### uncertainties ####\n",
    "    for k,v in sig_unc.items():assert(len(sig_unc_name)==len(v))\n",
    "    for i in range(len(sig_unc_name)):\n",
    "        if 'mc_stats' in sig_unc_name[i]:\n",
    "            for j, bin in enumerate(['A', 'B', 'C', 'D']):#bin\n",
    "                    for l, k in enumerate(sig_unc.keys()): #channels\n",
    "                        before = (len(sig_unc.keys())+1)*j+l\n",
    "                        after = (len(sig_unc.keys())+1)*4-before-1\n",
    "                        if sig_unc[k][i][j] > 0.0: text_file.write(sig_unc_name[i]+'_'+k+'_'+bin+' \\t gmN ' +str(int(sig_unc[k][i][j]))+ '  '+'\\t -  '*before + str(signal_rate[k][j]/int(sig_unc[k][i][j])) + '\\t - '*after +'\\n')\n",
    "\n",
    "        else:\n",
    "\n",
    "            unc_text = sig_unc_name[i]+' \\t lnN'\n",
    "            if len(sig_unc[list(sig_unc.keys())[0]][i])==4:#symmetric uncertainties\n",
    "                for j in range(4):#bin\n",
    "                    for k,v in sig_unc.items():\n",
    "                        if v[i][j] == 0.0:unc_text += ' \\t -'\n",
    "                        else: unc_text += ' \\t '+str(v[i][j]+1)\n",
    "                    unc_text += '\\t - '\n",
    "            else:#asymmetric\n",
    "                for j in range(4):#bin A, B, C, D\n",
    "                    for k,v in sig_unc.items():\n",
    "                        if  v[i][j] == 0.0 and v[i][j+4] == 0.0: unc_text += ' \\t -'\n",
    "                        else:unc_text += ' \\t {0}/{1}'.format(1-v[i][j],1+v[i][j+4])\n",
    "                    unc_text += '\\t -'\n",
    "            text_file.write(unc_text + ' \\n')\n",
    "    '''\n",
    "    for i in range(len(bkg_unc_name)):\n",
    "        bkg_unc_text = bkg_unc_name[i] + ' \\t lnN ' + '\\t - '*(4*nSig+3) + '\\t ' + str(1+bkg_unc[i]) + ' \\n'\n",
    "        text_file.write(bkg_unc_text)\n",
    "    \n",
    "\n",
    "    text_file.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec279045",
   "metadata": {},
   "source": [
    "## Scan CSC size cut"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abfc9c97",
   "metadata": {},
   "source": [
    "Study the optimal dphi cut to get closure and low background"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "5ada1fa3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k\t csc\t B\t C\t D\t A\t pred\t\t zval\t perc\n",
      "data\t 500.00\t 179\t 573\t 151\t 42\t 47.17 +- 3.53\t 0.73\t 12.31\n",
      "data\t 600.00\t 133\t 619\t 163\t 30\t 35.02 +- 3.04\t 0.82\t 16.74\n",
      "data\t 700.00\t 97\t 655\t 174\t 19\t 25.77 +- 2.62\t 1.30\t 35.62\n",
      "data\t 800.00\t 71\t 681\t 180\t 13\t 18.77 +- 2.23\t 1.32\t 44.36\n",
      "data\t 900.00\t 58\t 694\t 183\t 10\t 15.29 +- 2.01\t 1.35\t 52.94\n",
      "signal\t 500.00\t 208.41\t 341.91\t 262.78\t 160.08\t\n",
      "signal\t 600.00\t 147.40\t 402.93\t 317.15\t 105.72\t\n",
      "signal\t 700.00\t 95.45\t 454.88\t 350.98\t 71.89\t\n",
      "signal\t 800.00\t 67.05\t 483.27\t 369.10\t 53.76\t\n",
      "signal\t 900.00\t 47.12\t 503.21\t 388.43\t 34.43\t\n"
     ]
    }
   ],
   "source": [
    "#simplification for testing purposes\n",
    "csc_cut_scan_list = [500,600,700,800,900]\n",
    "\n",
    "time_cut_string = \"OOT\"\n",
    "plot_string=\"plot_name_here\"\n",
    "plot_string_plus = plot_string+\"_\"+time_cut_string\n",
    "leghead = time_cut_string+\",\"\n",
    "\n",
    "#one per min dphi cut\n",
    "bkg_rate = {}\n",
    "#bkg_unc = {}\n",
    "observation = {}\n",
    "signal_rate = {}\n",
    "\n",
    "normalization = 1\n",
    "\n",
    "for csc_cut_scan in csc_cut_scan_list:\n",
    "    signal_rate[csc_cut_scan] = {}\n",
    "\n",
    "print('k\\t csc\\t B\\t C\\t D\\t A\\t pred\\t\\t zval\\t perc')\n",
    "if category==2:\n",
    "    #Signal\n",
    "    #Data\n",
    "    for k in ['data','signal']:\n",
    "        tmp_dphi = np.abs( dPhi_csc_dt[k] )\n",
    "        tmp_deta = np.abs(  dEta_csc_dt[k] )\n",
    "        tmp_dR = np.abs(  dR_csc_dt[k] )\n",
    "        dtDNN = dtClusterDNN[k][:,0]\n",
    "        cscDNN = tr_cscClusterDNN[k][:,0]\n",
    "        var = dtClusterSize[k][:,0]\n",
    "        t_var = dtClusterTime[k][:,0]\n",
    "        dphi = tr_cscClusterSize[k][:,0]\n",
    "        \n",
    "        #OOT in data\n",
    "        tmp_cut = (np.abs(t_var)==0) #& (dtDNN>0.2) & (cscDNN>0.2)#& (tmp_dphi>0.2)\n",
    "        for csc_cut_scan in csc_cut_scan_list:\n",
    "            if csc_cut_scan<=CSC_MIN: \n",
    "                continue\n",
    "            if 'data' in k:\n",
    "                a[k],b[k],c[k],d[k],pred,unc_pred, p_value, z_value = run_abcd(\n",
    "                    var,dphi,\n",
    "                    N_MIN,N_CUT,N_MAX,\n",
    "                    CSC_MIN,csc_cut_scan,CSC_MAX,\n",
    "                    tmp_cut\n",
    "                    )\n",
    "                print(\"%s\\t %.2f\\t %i\\t %i\\t %i\\t %i\\t %.2f +- %.2f\\t %.2f\\t %.2f\" % (k,csc_cut_scan,b[k],c[k],d[k],a[k],pred,unc_pred,z_value, 100*(pred-a[k])/a[k]))\n",
    "                observation[csc_cut_scan] = [ pred,b[k],c[k],d[k] ]\n",
    "                bkg_rate[csc_cut_scan] = [ pred,b[k],c[k],d[k] ]\n",
    "                #bkg_unc[phi_min_scan] = [ unc_pred,np.sqrt(b[k]),np.sqrt(c[k]),np.sqrt(d[k]) ]\n",
    "            else:\n",
    "                ma,mb,mc,md = return_abcd_masks(\n",
    "                    var,dphi,\n",
    "                    N_MIN,N_CUT,N_MAX,\n",
    "                    CSC_MIN,csc_cut_scan,CSC_MAX,\n",
    "                    tmp_cut\n",
    "                    )\n",
    "                L = lumi/NEvents['signal']*48.58\n",
    "                a[k] = (np.sum(weight[k][ ma ]))*L\n",
    "                b[k] = (np.sum(weight[k][ mb ]))*L\n",
    "                c[k] = (np.sum(weight[k][ mc ]))*L\n",
    "                d[k] = (np.sum(weight[k][ md ]))*L\n",
    "                print(\"%s\\t %.2f\\t %.2f\\t %.2f\\t %.2f\\t %.2f\\t\" % (k,csc_cut_scan,b[k],c[k],d[k],a[k]))#, a[k]+b[k]+c[k]+d[k]))\n",
    "                signal_rate[csc_cut_scan]['ggH'] = [ a[k]*normalization,b[k]*normalization,c[k]*normalization,d[k]*normalization ]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "f3d9a937",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k\t csc\t B\t C\t D\t A\t pred\t\t zval\t perc\n",
      "data\t 500.00\t 26\t 68\t 13\t 9\t 4.97 +- 0.97\t -1.38\t -44.77\n",
      "data\t 600.00\t 19\t 75\t 16\t 6\t 4.05 +- 0.93\t -0.72\t -32.44\n",
      "data\t 700.00\t 11\t 83\t 19\t 3\t 2.52 +- 0.76\t -0.12\t -16.06\n",
      "data\t 800.00\t 10\t 84\t 21\t 1\t 2.50 +- 0.79\t 1.21\t 150.00\n",
      "data\t 900.00\t 5\t 89\t 21\t 1\t 1.18 +- 0.53\t 0.39\t 17.98\n",
      "signal\t 500.00\t 184.85\t 308.69\t 248.28\t 144.98\t\n",
      "signal\t 600.00\t 128.67\t 364.87\t 299.63\t 93.63\t\n",
      "signal\t 700.00\t 81.55\t 411.99\t 328.62\t 64.64\t\n",
      "signal\t 800.00\t 57.39\t 436.15\t 345.54\t 47.72\t\n",
      "signal\t 900.00\t 42.29\t 451.26\t 363.66\t 29.60\t\n"
     ]
    }
   ],
   "source": [
    "#simplification for testing purposes\n",
    "csc_cut_scan_list = [500,600,700,800,900]\n",
    "\n",
    "time_cut_string = \"OOT\"\n",
    "plot_string=\"plot_name_here\"\n",
    "plot_string_plus = plot_string+\"_\"+time_cut_string\n",
    "leghead = time_cut_string+\",\"\n",
    "\n",
    "#one per min dphi cut\n",
    "bkg_rate = {}\n",
    "#bkg_unc = {}\n",
    "observation = {}\n",
    "signal_rate = {}\n",
    "\n",
    "normalization = 1\n",
    "\n",
    "for csc_cut_scan in csc_cut_scan_list:\n",
    "    signal_rate[csc_cut_scan] = {}\n",
    "\n",
    "print('k\\t csc\\t B\\t C\\t D\\t A\\t pred\\t\\t zval\\t perc')\n",
    "if category==2:\n",
    "    #Signal\n",
    "    #Data\n",
    "    for k in ['data','signal']:\n",
    "        tmp_dphi = np.abs( dPhi_csc_dt[k] )\n",
    "        tmp_deta = np.abs(  dEta_csc_dt[k] )\n",
    "        tmp_dR = np.abs(  dR_csc_dt[k] )\n",
    "        dtDNN = dtClusterDNN[k][:,0]\n",
    "        cscDNN = tr_cscClusterDNN[k][:,0]\n",
    "        var = dtClusterSize[k][:,0]\n",
    "        t_var = dtClusterTime[k][:,0]\n",
    "        dphi = tr_cscClusterSize[k][:,0]\n",
    "        \n",
    "        #OOT in data\n",
    "        tmp_cut = (np.abs(t_var)==0) & (dtDNN>0.2) & (cscDNN>0.2) \n",
    "        for csc_cut_scan in csc_cut_scan_list:\n",
    "            if csc_cut_scan<=CSC_MIN: \n",
    "                continue\n",
    "            if 'data' in k:\n",
    "                a[k],b[k],c[k],d[k],pred,unc_pred, p_value, z_value = run_abcd(\n",
    "                    var,dphi,\n",
    "                    N_MIN,N_CUT,N_MAX,\n",
    "                    CSC_MIN,csc_cut_scan,CSC_MAX,\n",
    "                    tmp_cut\n",
    "                    )\n",
    "                print(\"%s\\t %.2f\\t %i\\t %i\\t %i\\t %i\\t %.2f +- %.2f\\t %.2f\\t %.2f\" % (k,csc_cut_scan,b[k],c[k],d[k],a[k],pred,unc_pred,z_value, 100*(pred-a[k])/a[k]))\n",
    "                observation[csc_cut_scan] = [ pred,b[k],c[k],d[k] ]\n",
    "                bkg_rate[csc_cut_scan] = [ pred,b[k],c[k],d[k] ]\n",
    "                #bkg_unc[phi_min_scan] = [ unc_pred,np.sqrt(b[k]),np.sqrt(c[k]),np.sqrt(d[k]) ]\n",
    "            else:\n",
    "                ma,mb,mc,md = return_abcd_masks(\n",
    "                    var,dphi,\n",
    "                    N_MIN,N_CUT,N_MAX,\n",
    "                    CSC_MIN,csc_cut_scan,CSC_MAX,\n",
    "                    tmp_cut\n",
    "                    )\n",
    "                L = lumi/NEvents['signal']*48.58\n",
    "                a[k] = (np.sum(weight[k][ ma ]))*L\n",
    "                b[k] = (np.sum(weight[k][ mb ]))*L\n",
    "                c[k] = (np.sum(weight[k][ mc ]))*L\n",
    "                d[k] = (np.sum(weight[k][ md ]))*L\n",
    "                print(\"%s\\t %.2f\\t %.2f\\t %.2f\\t %.2f\\t %.2f\\t\" % (k,csc_cut_scan,b[k],c[k],d[k],a[k]))#, a[k]+b[k]+c[k]+d[k]))\n",
    "                signal_rate[csc_cut_scan]['ggH'] = [ a[k]*normalization,b[k]*normalization,c[k]*normalization,d[k]*normalization ]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ae0cf98",
   "metadata": {},
   "source": [
    "Sanity check plot to visualize signal in ABCD regions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "4642bf98",
   "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.2,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",
    "if category==2:\n",
    "    for k in ['signal']:\n",
    "        var = dtClusterSize[k][:,0]\n",
    "        dphi = tr_cscClusterSize[k][:,0]\n",
    "        #tmp_cut = sel_ev_post[k]  & (np.abs(tmp_deta)<1.9) & (np.abs(t_var)<15) & (np.abs(t_spread_var)<20) & (sel_jetveto_csc[k][:,1]==True) & (sel_muonveto_csc[k][:,1]==True)#& (t_var<-15) #& (t_var<-15) # #& (tmp_dR>r) #(tmp_deta>=1.9)  & ( t_var<-15  )\n",
    "        ma,mb,mc,md = return_abcd_masks(\n",
    "                        var,dphi,\n",
    "                        N_MIN,N_CUT,N_MAX,\n",
    "                        CSC_MIN,CSC_CUT,CSC_MAX,\n",
    "                        tmp_cut\n",
    "                        )\n",
    "        \n",
    "        bins = [50,1.8,3.2]\n",
    "        tit = '|#Delta #varphi| (CSC,DT)'\n",
    "        plname=\"deltaPhi\"\n",
    "        cons = dphi\n",
    "        \n",
    "        bins = [50,0,500]\n",
    "        tit = 'N_{hits}'\n",
    "        plname=\"n_hits\"\n",
    "        cons = var\n",
    "        \n",
    "        h0[k] = create_TH1D( cons[ma],title=\"\",axis_title = [tit,'Events'], binning=bins)\n",
    "        h0[k].SetLineColor(1)\n",
    "        h0[k].SetLineWidth(2)\n",
    "        h0[k].SetMarkerColor(1)\n",
    "        h0[k].SetMarkerStyle(25)\n",
    "        h0[k].SetMarkerSize(1.2)\n",
    "        if scale and h0[k].Integral()>0:h0[k].Scale(1./h0[k].Integral())\n",
    "\n",
    "        h1[k] = create_TH1D( cons[mb],title=\"\",axis_title = [tit,'Events'], binning=bins)\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(cons[mc],title=\"\",axis_title = [tit,'Events'], binning=bins)\n",
    "        h2[k].SetLineColor(8)\n",
    "        h2[k].SetLineWidth(2)\n",
    "        h2[k].SetMarkerColor(8)\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(cons[md],title=\"\",axis_title = [tit,'Events'], binning=bins)\n",
    "        h3[k].SetLineColor(4)\n",
    "        h3[k].SetLineWidth(2)\n",
    "        h3[k].SetMarkerColor(4)\n",
    "        h3[k].SetMarkerStyle(25)\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",
    "            h0[k].SetMinimum(0.1)\n",
    "            h0[k].SetMaximum(1.e5)\n",
    "        else:\n",
    "            h0[k].SetMaximum(1)\n",
    "            h0[k].SetMinimum(0.001)\n",
    "        h0[k].Draw('PE same')\n",
    "        h1[k].Draw('PE same')\n",
    "        h2[k].Draw('PE same')\n",
    "        h3[k].Draw('PE same')\n",
    "        leg.AddEntry(h0[k],\"A\",\"PE\")\n",
    "        leg.AddEntry(h1[k],\"B\",\"PE\")\n",
    "        leg.AddEntry(h2[k],\"C\",\"PE\")\n",
    "        leg.AddEntry(h3[k],\"D\",\"PE\")\n",
    "\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+\"/ABCD_\"+plname+\"_signal_distribution_small_deta\"+plot_string_plus+\".pdf\")\n",
    "#can.Print(\"plots/V1p19_\"+vers+\"/ABCD_\"+plname+\"_signal_distribution_small_deta\"+plot_string_plus+\".png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a1318f6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d24bba9c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d666226",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29d47188",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a300d00b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f88c1c87",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1e711a0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2c3e818",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "992f4db1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c6642aa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c9bac21",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0e09a8a6",
   "metadata": {},
   "source": [
    "## Write datacards and run combine"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "566b6c9a",
   "metadata": {},
   "source": [
    "#### WARNING\n",
    "This depends on your computing node!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34928910",
   "metadata": {},
   "outputs": [],
   "source": [
    "outDataCardsDir=\"/afs/desy.de/user/l/lbenato/cms-lpc-llp_repo/run3_muon_system_analysis/datacards/V1p19/v6/\"\n",
    "modelName=\"ggH_HToSSTobbbb_MH-125_MS-15_CTau1000\"\n",
    "m=15\n",
    "ct=1000\n",
    "bkg_unc = [1.]\n",
    "bkg_unc_name = [\"syst\"]\n",
    "sig_unc = {}\n",
    "sig_unc_name = []\n",
    "signal_region = 'a'\n",
    "prefix = 'csccsc_'\n",
    "\n",
    "for phi_cut_scan in phi_cut_scan_list:\n",
    "    outdir = outDataCardsDir+'phi_cut_scan/'\n",
    "    if phi_cut_scan<=PHI_MIN:\n",
    "        continue\n",
    "    if not os.path.isdir(outdir): os.mkdir(outdir)\n",
    "    make_datacard_2tag(\n",
    "        outdir,\n",
    "        modelName+\"_\"+str(phi_cut_scan).replace(\".\",\"p\"),  \n",
    "        signal_rate[phi_cut_scan], \n",
    "        normalization, \n",
    "        bkg_rate[phi_cut_scan], \n",
    "        observation[phi_cut_scan], \n",
    "        bkg_unc, \n",
    "        bkg_unc_name, \n",
    "        sig_unc, \n",
    "        sig_unc_name,\n",
    "        signal_region, \n",
    "        prefix\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12fb5c85",
   "metadata": {},
   "outputs": [],
   "source": [
    "for phi_cut_scan in phi_cut_scan_list:\n",
    "    if phi_cut_scan<=PHI_MIN:continue\n",
    "    print(\"\\n\")\n",
    "    print(\"+++  \")\n",
    "    print(\"+++  \", phi_cut_scan )\n",
    "    print(\"+++  \")\n",
    "    outdir = outDataCardsDir+'/phi_cut_scan/'\n",
    "    text_file = open(outdir+modelName+\"_\"+str(phi_cut_scan).replace(\".\",\"p\")+\".txt\", \"r\")\n",
    "    for line in text_file:\n",
    "        print(line.strip())\n",
    "    text_file.close()\n",
    "    print(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7782ee03",
   "metadata": {},
   "source": [
    "### Submit combine with condor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50080405",
   "metadata": {},
   "outputs": [],
   "source": [
    "combine_dir = \"/afs/desy.de/user/l/lbenato/cms-lpc-llp_combine/CMSSW_11_3_4/src/HiggsAnalysis/CombinedLimit/\"\n",
    "condor_dir = combine_dir + \"condor_V1p19_v6/\"\n",
    "TOYS=False\n",
    "blind = True\n",
    "NCPUS   = 1\n",
    "MEMORY  = 512\n",
    "RUNTIME = 3600\n",
    "\n",
    "if not os.path.isdir(condor_dir): os.mkdir(condor_dir)\n",
    "else:\n",
    "    print(\"Warning, directory exists, deleting old condor outputs ... \")\n",
    "    os.system(\"ls \" + condor_dir)\n",
    "    os.system(\"rm \" + condor_dir + \"/*sh\")\n",
    "    os.system(\"rm \" + condor_dir + \"/*submit\")\n",
    "    os.system(\"rm \" + condor_dir + \"/*txt\")\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"Condor stuff being stored in \", condor_dir)\n",
    "print(\"\\n\")\n",
    "original_location = os.popen(\"pwd\").read()    \n",
    "\n",
    "for phi_cut_scan in phi_cut_scan_list:\n",
    "    if phi_cut_scan<=PHI_MIN:continue\n",
    "    outdir = outDataCardsDir+'/phi_cut_scan/'\n",
    "    results = outDataCardsDir+'/phi_cut_scan/'+'combine_results/'\n",
    "    if not os.path.isdir(results): os.mkdir(results)\n",
    "    card_name = modelName+\"_\"+str(phi_cut_scan).replace(\".\",\"p\")#+\".txt\"\n",
    "    #print(card_name)\n",
    "    #os.system('cat '+card_name)\n",
    "    #print(\"\\n\")\n",
    "    \n",
    "    if TOYS:\n",
    "        print(\"Toys - to be implemented\")\n",
    "    else:\n",
    "        os.chdir(condor_dir)\n",
    "        os.system(\"pwd\")\n",
    "        print(\"----->\")\n",
    "        print(\"Doing Asymptotic!!!!!!!!!\")\n",
    "        with open('job_m'+str(m)+'_ctau'+str(ct)+'_phi'+str(phi_cut_scan).replace(\".\",\"p\")+'.sh', 'w') as fout:\n",
    "            fout.write(\"#!/bin/sh\\n\")\n",
    "            fout.write(\"source /etc/profile.d/modules.sh\\n\")\n",
    "            fout.write(\"module use -a /afs/desy.de/group/cms/modulefiles/\\n\")\n",
    "            fout.write(\"module load cmssw\\n\")\n",
    "            fout.write('cd '+combine_dir+' \\n')\n",
    "            fout.write(\"cmsenv\\n\")\n",
    "            fout.write(\"echo Running on: \" + outdir+card_name+\".txt from directory: \\n\")\n",
    "            fout.write(\"pwd \\n\")\n",
    "            if blind:\n",
    "                fout.write(\"combine -M AsymptoticLimits --datacard \" + outdir+card_name+\".txt \" + \"  --run blind -m \" + str(m) + \" -n \"+str(phi_cut_scan).replace(\".\",\"p\")+\" \\n\")\n",
    "                #--SetParameters norm=1 --freezeParameters norm\n",
    "            else:\n",
    "                fout.write(\"combine -M AsymptoticLimits --datacard \" + outdir+card_name+\".txt \" + \" -m \" + str(m) + \" -n \" +str(phi_cut_scan).replace(\".\",\"p\")+ \" \\n\")\n",
    "        os.system('chmod 755 job_m'+str(m)+'_ctau'+str(ct)+'_phi'+str(phi_cut_scan).replace(\".\",\"p\")+'.sh')\n",
    "\n",
    "        with open('submit_m'+str(m)+'_ctau'+str(ct)+'_phi'+str(phi_cut_scan).replace(\".\",\"p\")+'.submit', 'w') as fout:\n",
    "            fout.write('executable   = ' + condor_dir + '/job_m'+ str(m) +'_ctau'+str(ct)+'_phi'+str(phi_cut_scan).replace(\".\",\"p\")+ '.sh \\n')\n",
    "            fout.write('output       = ' + condor_dir + '/out_m'+ str(m) +'_ctau'+str(ct)+'_phi'+str(phi_cut_scan).replace(\".\",\"p\")+ '.txt \\n')\n",
    "            fout.write('error        = ' + condor_dir + '/error_m'+ str(m) +'_ctau'+str(ct)+'_phi'+str(phi_cut_scan).replace(\".\",\"p\")+ '.txt \\n')\n",
    "            fout.write('log          = ' + condor_dir + '/log_m'+ str(m) +'_ctau'+str(ct)+'_phi'+str(phi_cut_scan).replace(\".\",\"p\")+ '.txt \\n')\n",
    "            fout.write(' \\n')\n",
    "            fout.write('Requirements = OpSysAndVer == \"CentOS7\" \\n')\n",
    "            fout.write(' \\n')\n",
    "            fout.write('Request_Cpus = ' + str(NCPUS) + ' \\n')\n",
    "            fout.write('Request_Memory = ' + str(MEMORY) + ' \\n')\n",
    "            #fout.write('+RequestRuntime = ' + str(RUNTIME) + ' \\n')                                                                                        \n",
    "            fout.write('batch_name = m'+str(m)+'ct'+str(ct)+str(ct)+'_phi'+str(phi_cut_scan).replace(\".\",\"p\")+'\\n')\n",
    "            fout.write('queue 1 \\n')\n",
    "\n",
    "        #submit condor                                                                                                                                      \n",
    "        #os.system('condor_submit ' + 'submit_m'+str(m)+'_ctau'+str(ct)+'_phi'+str(phi_cut_scan).replace(\".\",\"p\")+'.submit' + ' \\n')\n",
    "        os.system(\"sh job_m\"+str(m)+\"_ctau\"+str(ct)+\"_phi\"+str(phi_cut_scan).replace(\".\",\"p\")+\".sh > \"+condor_dir + \"/log_m\"+ str(m) +\"_ctau\"+str(ct)+\"_phi\"+str(phi_cut_scan).replace(\".\",\"p\")+\".txt \")\n",
    "        os.system(\"cat \"+ condor_dir + \"/log_m\"+ str(m) +\"_ctau\"+str(ct)+\"_phi\"+str(phi_cut_scan).replace(\".\",\"p\")+\".txt | grep -e Observed -e Expected | awk '{print $NF}' > \" + results + \"/\" + card_name +\".txt \\n\")\n",
    "        print(\"Results saved in \"+results + card_name +\".txt\")\n",
    "        os.chdir(original_location[:-1])\n",
    "                \n",
    "#os.system(\"eval `scramv1 runtime -sh`\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "9da4d257",
   "metadata": {},
   "outputs": [],
   "source": [
    "#!cat /afs/desy.de/user/l/lbenato/cms-lpc-llp_repo/run3_muon_system_analysis/datacards/V1p19/v6//phi_cut_scan/ggH_HToSSTobbbb_MH-125_MS-15_CTau1000_2p2.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3a12d76",
   "metadata": {},
   "source": [
    "### Read and plot the limits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "923ae11d",
   "metadata": {},
   "outputs": [],
   "source": [
    "results = outDataCardsDir+'/phi_cut_scan/'+'combine_results/'\n",
    "exp = []\n",
    "xval = []\n",
    "obs = {}\n",
    "mean_val = {}\n",
    "sigma_2_up = {}\n",
    "sigma_1_up = {}\n",
    "sigma_1_down = {}\n",
    "sigma_2_down = {}\n",
    "for phi_cut_scan in phi_cut_scan_list:\n",
    "    if phi_cut_scan<=PHI_MIN:continue\n",
    "    card_name = modelName+\"_\"+str(phi_cut_scan).replace(\".\",\"p\")\n",
    "    \n",
    "    if not os.path.isfile(results+card_name+\".txt\"):\n",
    "        continue\n",
    "    card = open( results+card_name+\".txt\", 'r')\n",
    "    val = card.read().splitlines()\n",
    "    if len(val) == 0:\n",
    "        continue\n",
    "    if len(val) != 6 and not blind:\n",
    "        continue\n",
    "    print(val)\n",
    "    \n",
    "    if blind:\n",
    "        sigma_2_down[phi_cut_scan] = float(val[0])\n",
    "        sigma_1_down[phi_cut_scan] = float(val[1])\n",
    "        mean_val[phi_cut_scan]     = float(val[2])\n",
    "        exp.append(float(val[2]))\n",
    "        sigma_1_up[phi_cut_scan]   = float(val[3])\n",
    "        sigma_2_up[phi_cut_scan]   = float(val[4])\n",
    "    else:\n",
    "        obs[phi_cut_scan]          = float(val[0])\n",
    "        sigma_2_down[phi_cut_scan] = float(val[1])\n",
    "        sigma_1_down[phi_cut_scan] = float(val[2])\n",
    "        mean_val[phi_cut_scan]     = float(val[3])\n",
    "        exp.append(float(val[3]))\n",
    "        sigma_1_up[phi_cut_scan]   = float(val[4])\n",
    "        sigma_2_up[phi_cut_scan]   = float(val[5])\n",
    "        \n",
    "Obs0s = rt.TGraph()\n",
    "Exp0s = rt.TGraph()\n",
    "Exp1s = rt.TGraphAsymmErrors()\n",
    "Exp2s = rt.TGraphAsymmErrors()\n",
    "\n",
    "n=0\n",
    "for phi_cut_scan in phi_cut_scan_list:                                                                                                    \n",
    "    if phi_cut_scan not in mean_val.keys():\n",
    "        continue\n",
    "    if not blind:\n",
    "        Obs0s.SetPoint(n, phi_cut_scan, obs[phi_cut_scan])\n",
    "    Exp0s.SetPoint(n, phi_cut_scan, mean_val[phi_cut_scan])\n",
    "    Exp1s.SetPoint(n, phi_cut_scan, mean_val[phi_cut_scan])\n",
    "    Exp1s.SetPointError(n, 0., 0., mean_val[phi_cut_scan]-sigma_1_down[phi_cut_scan], sigma_1_up[phi_cut_scan]-mean_val[phi_cut_scan])\n",
    "    Exp2s.SetPoint(n, phi_cut_scan, mean_val[phi_cut_scan])\n",
    "    Exp2s.SetPointError(n, 0., 0., mean_val[phi_cut_scan]-sigma_2_down[phi_cut_scan], sigma_2_up[phi_cut_scan]-mean_val[phi_cut_scan])\n",
    "    n+=1\n",
    "    \n",
    "Exp2s.SetLineWidth(2)\n",
    "Exp2s.SetLineStyle(1)\n",
    "Exp0s.SetLineStyle(2)\n",
    "Exp0s.SetLineWidth(3)                                                                                                                            \n",
    "Obs0s.SetLineStyle(1)\n",
    "Obs0s.SetLineWidth(3)                                                                                                                          \n",
    "Exp1s.SetFillColor(417)\n",
    "Exp1s.SetLineColor(417)\n",
    "Exp2s.SetFillColor(800)\n",
    "Exp2s.SetLineColor(800)\n",
    "Exp2s.GetXaxis().SetTitle(\"#Delta #varphi cut\")\n",
    "Exp2s.GetYaxis().SetTitle(\"BR\")\n",
    "Exp2s.GetXaxis().SetNoExponent(True)\n",
    "Exp2s.GetXaxis().SetMoreLogLabels(True)\n",
    "Exp2s.GetXaxis().SetTitleSize(0.048)\n",
    "Exp2s.GetYaxis().SetTitleSize(0.048)                                                                                                                                           \n",
    "Exp2s.GetXaxis().SetTitleOffset(0.9)\n",
    "Exp2s.GetYaxis().SetTitleOffset(0.85)\n",
    "\n",
    "leg = rt.TLegend(0.55, 0.525-0.025, 0.9-0.05, 0.825-0.025)\n",
    "leg.SetBorderSize(0)\n",
    "leg.SetHeader(\"95% CL limits\")\n",
    "leg.SetTextSize(0.04)\n",
    "c1 = rt.TCanvas(\"c1\", \"Exclusion Limits\", 900, 675)\n",
    "c1.cd()\n",
    "c1.GetPad(0).SetBottomMargin(0.12)\n",
    "c1.GetPad(0).SetTopMargin(0.08)\n",
    "c1.GetPad(0).SetRightMargin(0.05)\n",
    "c1.GetPad(0).SetTicks(1, 1)\n",
    "c1.GetPad(0).SetLogy()\n",
    "\n",
    "leg.AddEntry(Exp0s,  \"Median expected\", \"l\")\n",
    "leg.AddEntry(Exp1s, \"68% expected\", \"f\")\n",
    "leg.AddEntry(Exp2s, \"95% expected\", \"f\")\n",
    "if not blind:\n",
    "    leg.AddEntry(Obs0s, \"Observed\", \"l\")\n",
    "Exp2s.GetXaxis().SetTitleSize(0.055)\n",
    "Exp2s.GetYaxis().SetTitleSize(0.055)\n",
    "Exp2s.GetXaxis().SetLabelSize(0.045)                                                                                 \n",
    "Exp2s.GetYaxis().SetLabelSize(0.045)\n",
    "\n",
    "for mv in mean_val.keys():\n",
    "    xval.append(mv)\n",
    "    exp.append(mean_val[mv])\n",
    "\n",
    "best_phi = rt.TLine(xval[ np.argmin(exp) ],0.005,xval[ np.argmin(exp) ],1)\n",
    "best_phi.SetLineColor(2)\n",
    "best_phi.SetLineStyle(2)\n",
    "best_phi.SetLineWidth(2)\n",
    "\n",
    "\n",
    "Exp2s.SetMinimum(0.005)\n",
    "Exp2s.SetMaximum(5)\n",
    "Exp2s.Draw(\"A3\")\n",
    "Exp1s.Draw(\"SAME, 3\")\n",
    "Exp0s.Draw(\"SAME, L\")\n",
    "if not blind:\n",
    "    Obs0s.Draw(\"SAME, L\")\n",
    "best_phi.Draw(\"SAME, L\")\n",
    "leg.Draw()\n",
    "\n",
    "latex = rt.TLatex()\n",
    "latex.SetNDC()\n",
    "latex.SetTextAlign(33)\n",
    "latex.SetTextSize(0.04)\n",
    "latex.SetTextFont(42)\n",
    "latex.DrawLatex(0.8,0.25, (\"Bkg @ #Delta#varphi=%s: %.2f events\" % ( str(xval[ np.argmin(exp) ]),bkg_rate[ xval[ np.argmin(exp) ] ] [0])))\n",
    "\n",
    "c1.Draw()\n",
    "drawCMS(lumi, \"Preliminary\", ERA=\"\", onTop=True,left_marg_CMS=0.2,top_marg_cms=0.97,top_marg_lumi=0.965)\n",
    "\n",
    "c1.Print(\"plots/V1p19_\"+vers+\"/ABCD_limits_scan_dphi_cut\"+plot_string_plus+\".pdf\")\n",
    "c1.Print(\"plots/V1p19_\"+vers+\"/ABCD_limits_scan_dphi_cut\"+plot_string_plus+\".png\")\n",
    "#Store graphs for future comparisons\n",
    "newFile = rt.TFile(\"plots/V1p19_\"+vers+\"/ABCD_limits_scan_dphi_cut\"+plot_string_plus+\".root\", \"RECREATE\")\n",
    "newFile.cd()\n",
    "Exp0s.Write(\"exp\")\n",
    "Exp1s.Write(\"1sigma\")\n",
    "Exp2s.Write(\"2sigma\")\n",
    "c1.Write()\n",
    "newFile.Close()\n",
    "print(\"Info: written \"+\"plots/V1p19_\"+vers+\"/ABCD_limits_scan_dphi_cut\"+plot_string_plus+\".root\")"
   ]
  }
 ],
 "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
}