diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..87620ac7e74efee566c6ee9d2ed7281ebafb4788 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.ipynb_checkpoints/ diff --git a/codigo/Project.ipynb b/codigo/Project.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..fb3bede4f98c5d248fcdb5394ff63913356e2505 --- /dev/null +++ b/codigo/Project.ipynb @@ -0,0 +1,1831 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Noé Camacho" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## La idea es extender el modelo BTD de \"How to rediscover the Higgs boson yourself - with a BDT!\" usando, data de 4lep" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Importamos librerias necesarias" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Importamos librerias a usar\n", + "import os\n", + "import matplotlib.pyplot as plt # for plotting\n", + "from matplotlib.ticker import AutoMinorLocator # for minor ticks\n", + "import pandas as pd\n", + "from tqdm import tqdm\n", + "import uproot\n", + "import infofile\n", + "import uproot3\n", + "import math # for mathematical functions such as square root\n", + "import ROOT\n", + "from ROOT import TMath\n", + "import time\n", + "import numpy as np" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "import sys\n", + "!{sys.executable} -m pip install --upgrade --user pip # update the pip package installer\n", + "!{sys.executable} -m pip install uproot3 pandas numpy matplotlib --user # install required packages" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "lumi = 10 # fb-1 # data_A,data_B,data_C,data_D\n", + "\n", + "fraction = 0.88 # reduce this is you want the code to run quicker" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Path online de donde obtener la data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "tuple_path = \"https://atlas-opendata.web.cern.ch/atlas-opendata/samples/2020/4lep/\" # web address" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sample\n", + "- 'data': Pertenece a los datos obtenido de algún experimento\n", + "- r'Background $Z,t\\bar{t}$': Pertenece a la simulación de Monte Carlo\n", + "- r'Background $ZZ^*$' : Pertenece a la simulación de Monte Carlo\n", + "- r'Signal ($m_H$ = 125 GeV)': Pertenece a la simulación de Monte Carlo" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "samples = {\n", + "\n", + " 'data': {\n", + " 'list' : ['data_A','data_B','data_C','data_D'],\n", + " },\n", + "\n", + " r'Background $Z,t\\bar{t}$' : { # Z + ttbar\n", + " 'list' : ['Zee','Zmumu','ttbar_lep'],\n", + " 'color' : \"#6b59d3\" # purple\n", + " },\n", + "\n", + " r'Background $ZZ^*$' : { # ZZ\n", + " 'list' : ['llll'],\n", + " 'color' : \"#ff0000\" # red\n", + " },\n", + "\n", + " r'Signal ($m_H$ = 125 GeV)' : { # H -> ZZ -> llll\n", + " 'list' : ['ggH125_ZZ4lep','VBFH125_ZZ4lep','WH125_ZZ4lep','ZH125_ZZ4lep'],\n", + " 'color' : \"#00cdff\" # light blue\n", + " },\n", + "\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Esta función permite establecer el path para extraer la data y MC. Y con la función read_file() hace la extracción" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def get_data_from_files():\n", + "\n", + " data = {} # define empty dictionary to hold dataframes\n", + " for s in samples: # loop over samples\n", + " print('Processing '+s+' samples') # print which sample\n", + " frames = [] # define empty list to hold data\n", + " for val in samples[s]['list']: # loop over each file\n", + " if s == 'data': \n", + " prefix = \"Data/\" # Data prefix\n", + " else: # MC prefix\n", + " prefix = \"MC/mc_\"+str(infofile.infos[val][\"DSID\"])+\".\"\n", + " fileString = tuple_path+prefix+val+\".4lep.root\" # file name to open\n", + " temp = read_file(fileString,val) # call the function read_file defined below\n", + " frames.append(temp) # append dataframe returned from read_file to list of dataframes\n", + " data[s] = pd.concat(frames) # dictionary entry is concatenated dataframes\n", + " \n", + " return data # return dictionary of dataframes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### weight of MC event" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def calc_weight(xsec_weight, mcWeight, scaleFactor_PILEUP,\n", + " scaleFactor_ELE, scaleFactor_MUON, \n", + " scaleFactor_LepTRIGGER ):\n", + " return xsec_weight*mcWeight*scaleFactor_PILEUP*scaleFactor_ELE*scaleFactor_MUON*scaleFactor_LepTRIGGER" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### get cross-section weight" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def get_xsec_weight(sample):\n", + " info = infofile.infos[sample] # open infofile\n", + " xsec_weight = (lumi*1000*info[\"xsec\"])/(info[\"sumw\"]*info[\"red_eff\"]) #*1000 to go from fb-1 to pb-1\n", + " return xsec_weight # return cross-section weight" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calcula la masa del evento" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def calc_mllll(lep_pt,lep_eta,lep_phi,lep_E):\n", + " # first lepton is [0], 2nd lepton is [1] etc\n", + " px_0 = lep_pt[0]*math.cos(lep_phi[0]) # x-component of lep[0] momentum\n", + " py_0 = lep_pt[0]*math.sin(lep_phi[0]) # y-component of lep[0] momentum\n", + " pz_0 = lep_pt[0]*math.sinh(lep_eta[0]) # z-component of lep[0] momentum\n", + " px_1 = lep_pt[1]*math.cos(lep_phi[1]) # x-component of lep[1] momentum\n", + " py_1 = lep_pt[1]*math.sin(lep_phi[1]) # y-component of lep[1] momentum\n", + " pz_1 = lep_pt[1]*math.sinh(lep_eta[1]) # z-component of lep[1] momentum\n", + " px_2 = lep_pt[2]*math.cos(lep_phi[2]) # x-component of lep[2] momentum\n", + " py_2 = lep_pt[2]*math.sin(lep_phi[2]) # y-component of lep[2] momentum\n", + " pz_2 = lep_pt[2]*math.sinh(lep_eta[2]) # z-component of lep[3] momentum\n", + " px_3 = lep_pt[3]*math.cos(lep_phi[3]) # x-component of lep[3] momentum\n", + " py_3 = lep_pt[3]*math.sin(lep_phi[3]) # y-component of lep[3] momentum\n", + " pz_3 = lep_pt[3]*math.sinh(lep_eta[3]) # z-component of lep[3] momentum\n", + " sumpx = px_0 + px_1 + px_2 + px_3 # x-component of 4-lepton momentum\n", + " sumpy = py_0 + py_1 + py_2 + py_3 # y-component of 4-lepton momentum\n", + " sumpz = pz_0 + pz_1 + pz_2 + pz_3 # z-component of 4-lepton momentum\n", + " sumE = lep_E[0] + lep_E[1] + lep_E[2] + lep_E[3] # energy of 4-lepton system\n", + " return math.sqrt(sumE**2 - sumpx**2 - sumpy**2 - sumpz**2)/1000 #/1000 to go from MeV to GeV" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Funcion para filtar eventos que no necesitmaos " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recordar: \n", + " - two pairs of isolated leptons\n", + " - two leptons with the same flavour and opposite charge" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# cut on lepton charge\n", + "# paper: \"selecting two pairs of isolated leptons, each of which is comprised of two leptons with the same flavour and opposite charge\"\n", + "def cut_lep_charge(lep_charge):\n", + "# throw away when sum of lepton charges is not equal to 0\n", + "# first lepton is [0], 2nd lepton is [1] etc\n", + " return lep_charge[0] + lep_charge[1] + lep_charge[2] + lep_charge[3] != 0\n", + "\n", + "# cut on lepton type\n", + "# paper: \"selecting two pairs of isolated leptons, each of which is comprised of two leptons with the same flavour and opposite charge\"\n", + "def cut_lep_type(lep_type):\n", + "# for an electron lep_type is 11\n", + "# for a muon lep_type is 13\n", + "# throw away when none of eeee, mumumumu, eemumu\n", + " sum_lep_type = lep_type[0] + lep_type[1] + lep_type[2] + lep_type[3]\n", + " return (sum_lep_type != 44) and (sum_lep_type != 48) and (sum_lep_type != 52)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Función que permite extraer los dataframes en un dict usando las función definidas anteriormente" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def read_file(path,sample):\n", + " start = time.time() # start the clock\n", + " print(\"\\tProcessing: \"+sample) # print which sample is being processed\n", + " data_all = pd.DataFrame() # define empty pandas DataFrame to hold all data for this sample\n", + " tree = uproot3.open(path)[\"mini\"] # open the tree called mini\n", + " numevents = uproot3.numentries(path, \"mini\") # number of events\n", + " if 'data' not in sample: xsec_weight = get_xsec_weight(sample) # get cross-section weight\n", + " for data in tree.iterate(['lep_pt','lep_eta','lep_phi',\n", + " 'lep_E','lep_charge','lep_type', \n", + " # add more variables here if you make cuts on them \n", + " 'mcWeight','scaleFactor_PILEUP',\n", + " 'scaleFactor_ELE','scaleFactor_MUON',\n", + " 'scaleFactor_LepTRIGGER'], # variables to calculate Monte Carlo weight\n", + " outputtype=pd.DataFrame, # choose output type as pandas DataFrame\n", + " entrystop=numevents*fraction): # process up to numevents*fraction\n", + "\n", + " nIn = len(data.index) # number of events in this batch\n", + "\n", + " if 'data' not in sample: # only do this for Monte Carlo simulation files\n", + " # multiply all Monte Carlo weights and scale factors together to give total weight\n", + " data['totalWeight'] = np.vectorize(calc_weight)(xsec_weight,\n", + " data.mcWeight,\n", + " data.scaleFactor_PILEUP,\n", + " data.scaleFactor_ELE,\n", + " data.scaleFactor_MUON,\n", + " data.scaleFactor_LepTRIGGER)\n", + "\n", + " # cut on lepton charge using the function cut_lep_charge defined above\n", + " fail = data[ np.vectorize(cut_lep_charge)(data.lep_charge) ].index\n", + " data.drop(fail, inplace=True)\n", + "\n", + " # cut on lepton type using the function cut_lep_type defined above\n", + " fail = data[ np.vectorize(cut_lep_type)(data.lep_type) ].index\n", + " data.drop(fail, inplace=True)\n", + "\n", + " # calculation of 4-lepton invariant mass using the function calc_mllll defined above\n", + " data['mllll'] = np.vectorize(calc_mllll)(data.lep_pt,data.lep_eta,data.lep_phi,data.lep_E)\n", + "\n", + " # dataframe contents can be printed at any stage like this\n", + " #print(data)\n", + "\n", + " # dataframe column can be printed at any stage like this\n", + " #print(data['lep_pt'])\n", + "\n", + " # multiple dataframe columns can be printed at any stage like this\n", + " #print(data[['lep_pt','lep_eta']])\n", + "\n", + " nOut = len(data.index) # number of events passing cuts in this batch\n", + " data_all = data_all.append(data) # append dataframe from this batch to the dataframe for the whole sample\n", + " elapsed = time.time() - start # time taken to process\n", + " print(\"\\t\\t nIn: \"+str(nIn)+\",\\t nOut: \\t\"+str(nOut)+\"\\t in \"+str(round(elapsed,1))+\"s\") # events before and after\n", + " \n", + " return data_all # return dataframe containing events passing all cuts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Llamamos a la función y extraermos el dict con los dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing data samples\n", + "\tProcessing: data_A\n", + "\t\t nIn: 34,\t nOut: \t23\t in 2.5s\n", + "\tProcessing: data_B\n", + "\t\t nIn: 137,\t nOut: \t76\t in 2.9s\n", + "\tProcessing: data_C\n", + "\t\t nIn: 208,\t nOut: \t126\t in 3.9s\n", + "\tProcessing: data_D\n", + "\t\t nIn: 352,\t nOut: \t216\t in 5.7s\n", + "Processing Background $Z,t\\bar{t}$ samples\n", + "\tProcessing: Zee\n", + "\t\t nIn: 790,\t nOut: \t211\t in 10.6s\n", + "\tProcessing: Zmumu\n", + "\t\t nIn: 601,\t nOut: \t227\t in 9.2s\n", + "\tProcessing: ttbar_lep\n", + "\t\t nIn: 907,\t nOut: \t293\t in 13.5s\n", + "Processing Background $ZZ^*$ samples\n", + "\tProcessing: llll\n", + "\t\t nIn: 106415,\t nOut: \t100522\t in 331.3s\n", + "\t\t nIn: 106415,\t nOut: \t100595\t in 399.3s\n", + "\t\t nIn: 106415,\t nOut: \t100580\t in 469.7s\n", + "\t\t nIn: 106415,\t nOut: \t100618\t in 544.8s\n", + "\t\t nIn: 62105,\t nOut: \t58770\t in 598.3s\n", + "Processing Signal ($m_H$ = 125 GeV) samples\n", + "\tProcessing: ggH125_ZZ4lep\n", + "\t\t nIn: 104555,\t nOut: \t102484\t in 684.2s\n", + "\t\t nIn: 40395,\t nOut: \t39590\t in 686.7s\n", + "\tProcessing: VBFH125_ZZ4lep\n", + "\t\t nIn: 102038,\t nOut: \t99807\t in 612.6s\n", + "\t\t nIn: 66152,\t nOut: \t64651\t in 655.6s\n", + "\tProcessing: WH125_ZZ4lep\n", + "\t\t nIn: 13533,\t nOut: \t8537\t in 40.6s\n", + "\tProcessing: ZH125_ZZ4lep\n", + "\t\t nIn: 12746,\t nOut: \t10537\t in 40.0s\n", + "Time taken: 2069.7s\n" + ] + } + ], + "source": [ + "start = time.time() # time at start of whole processing\n", + "data = get_data_from_files() # process all files\n", + "elapsed = time.time() - start # time after whole processing\n", + "print(\"Time taken: \"+str(round(elapsed,1))+\"s\") # print total time taken to process every file" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>lep_pt</th>\n", + " <th>lep_eta</th>\n", + " <th>lep_phi</th>\n", + " <th>lep_E</th>\n", + " <th>lep_charge</th>\n", + " <th>lep_type</th>\n", + " <th>mcWeight</th>\n", + " <th>scaleFactor_PILEUP</th>\n", + " <th>scaleFactor_ELE</th>\n", + " <th>scaleFactor_MUON</th>\n", + " <th>scaleFactor_LepTRIGGER</th>\n", + " <th>mllll</th>\n", + " </tr>\n", + " <tr>\n", + " <th>entry</th>\n", + " <th></th>\n", + " <th></th>\n", + " <th></th>\n", + " <th></th>\n", + " <th></th>\n", + " <th></th>\n", + " <th></th>\n", + " <th></th>\n", + " <th></th>\n", + " <th></th>\n", + " <th></th>\n", + " <th></th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>[175558.73, 138846.67, 106696.53, 79776.73]</td>\n", + " <td>[2.076854, 0.9641987, 0.4538123, 2.3985784]</td>\n", + " <td>[1.2929627, -2.2561386, -1.7970102, 0.5870669]</td>\n", + " <td>[711421.06, 208545.92, 117873.27, 442695.56]</td>\n", + " <td>[-1, 1, -1, 1]</td>\n", + " <td>[11, 13, 13, 11]</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>649.271931</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>[65284.066, 37290.766, 12426.926, 8804.564]</td>\n", + " <td>[0.103151694, 0.43131045, 0.98646265, 1.1151001]</td>\n", + " <td>[2.3295352, -2.4817212, 2.2234292, 2.4967396]</td>\n", + " <td>[65631.695, 40813.45, 18980.092, 14870.211]</td>\n", + " <td>[-1, 1, -1, 1]</td>\n", + " <td>[11, 11, 13, 13]</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>87.907098</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>[146784.7, 127539.97, 33562.18, 29776.129]</td>\n", + " <td>[-0.20137234, -0.26222968, -0.2997417, 0.47760...</td>\n", + " <td>[0.56058794, -2.2311037, 2.0015476, 2.9714534]</td>\n", + " <td>[149770.89, 131950.27, 35081.2, 33237.22]</td>\n", + " <td>[1, 1, -1, -1]</td>\n", + " <td>[11, 11, 11, 11]</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>344.775936</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5</th>\n", + " <td>[135680.69, 82894.8, 62508.098, 42552.906]</td>\n", + " <td>[1.4913375, 0.73802865, 1.2436671, 0.5755266]</td>\n", + " <td>[-0.7563026, -2.7576957, 2.2719328, -1.1226101]</td>\n", + " <td>[316685.9, 106514.14, 117410.016, 49797.125]</td>\n", + " <td>[-1, -1, 1, 1]</td>\n", + " <td>[13, 11, 11, 13]</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>326.583790</td>\n", + " </tr>\n", + " <tr>\n", + " <th>7</th>\n", + " <td>[67713.18, 42791.816, 12742.542, 10291.093]</td>\n", + " <td>[-1.5264179, -0.06150811, -0.6896634, -0.6163658]</td>\n", + " <td>[-1.4037814, -1.353487, -0.32475498, -0.3771284]</td>\n", + " <td>[163154.1, 42872.79, 15895.331, 12309.051]</td>\n", + " <td>[1, -1, -1, 1]</td>\n", + " <td>[11, 11, 13, 13]</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>0.0</td>\n", + " <td>107.422585</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " lep_pt \\\n", + "entry \n", + "1 [175558.73, 138846.67, 106696.53, 79776.73] \n", + "2 [65284.066, 37290.766, 12426.926, 8804.564] \n", + "4 [146784.7, 127539.97, 33562.18, 29776.129] \n", + "5 [135680.69, 82894.8, 62508.098, 42552.906] \n", + "7 [67713.18, 42791.816, 12742.542, 10291.093] \n", + "\n", + " lep_eta \\\n", + "entry \n", + "1 [2.076854, 0.9641987, 0.4538123, 2.3985784] \n", + "2 [0.103151694, 0.43131045, 0.98646265, 1.1151001] \n", + "4 [-0.20137234, -0.26222968, -0.2997417, 0.47760... \n", + "5 [1.4913375, 0.73802865, 1.2436671, 0.5755266] \n", + "7 [-1.5264179, -0.06150811, -0.6896634, -0.6163658] \n", + "\n", + " lep_phi \\\n", + "entry \n", + "1 [1.2929627, -2.2561386, -1.7970102, 0.5870669] \n", + "2 [2.3295352, -2.4817212, 2.2234292, 2.4967396] \n", + "4 [0.56058794, -2.2311037, 2.0015476, 2.9714534] \n", + "5 [-0.7563026, -2.7576957, 2.2719328, -1.1226101] \n", + "7 [-1.4037814, -1.353487, -0.32475498, -0.3771284] \n", + "\n", + " lep_E lep_charge \\\n", + "entry \n", + "1 [711421.06, 208545.92, 117873.27, 442695.56] [-1, 1, -1, 1] \n", + "2 [65631.695, 40813.45, 18980.092, 14870.211] [-1, 1, -1, 1] \n", + "4 [149770.89, 131950.27, 35081.2, 33237.22] [1, 1, -1, -1] \n", + "5 [316685.9, 106514.14, 117410.016, 49797.125] [-1, -1, 1, 1] \n", + "7 [163154.1, 42872.79, 15895.331, 12309.051] [1, -1, -1, 1] \n", + "\n", + " lep_type mcWeight scaleFactor_PILEUP scaleFactor_ELE \\\n", + "entry \n", + "1 [11, 13, 13, 11] 0.0 0.0 0.0 \n", + "2 [11, 11, 13, 13] 0.0 0.0 0.0 \n", + "4 [11, 11, 11, 11] 0.0 0.0 0.0 \n", + "5 [13, 11, 11, 13] 0.0 0.0 0.0 \n", + "7 [11, 11, 13, 13] 0.0 0.0 0.0 \n", + "\n", + " scaleFactor_MUON scaleFactor_LepTRIGGER mllll \n", + "entry \n", + "1 0.0 0.0 649.271931 \n", + "2 0.0 0.0 87.907098 \n", + "4 0.0 0.0 344.775936 \n", + "5 0.0 0.0 326.583790 \n", + "7 0.0 0.0 107.422585 " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['data'].head()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def calc_lep_pt_i(lep_pt,i):\n", + " return lep_pt[i]/1000 # /1000 to go from MeV to GeV" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(0,4):\n", + " for s in samples:\n", + " data[s][f'lep_pt_{i}'] = np.vectorize(calc_lep_pt_i)(data[s].lep_pt,i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### checamos las dimensiones" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "data\n", + "(441, 16)\n", + "Background $Z,t\\bar{t}$\n", + "(731, 17)\n", + "Background $ZZ^*$\n", + "(461085, 17)\n", + "Signal ($m_H$ = 125 GeV)\n", + "(325606, 17)\n" + ] + } + ], + "source": [ + "for column in data:\n", + " print(column)\n", + " print(data[column].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Checamos las columnas " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "data\n", + "Index(['lep_pt', 'lep_eta', 'lep_phi', 'lep_E', 'lep_charge', 'lep_type',\n", + " 'mcWeight', 'scaleFactor_PILEUP', 'scaleFactor_ELE', 'scaleFactor_MUON',\n", + " 'scaleFactor_LepTRIGGER', 'mllll', 'lep_pt_0', 'lep_pt_1', 'lep_pt_2',\n", + " 'lep_pt_3'],\n", + " dtype='object')\n", + "Background $Z,t\\bar{t}$\n", + "Index(['lep_pt', 'lep_eta', 'lep_phi', 'lep_E', 'lep_charge', 'lep_type',\n", + " 'mcWeight', 'scaleFactor_PILEUP', 'scaleFactor_ELE', 'scaleFactor_MUON',\n", + " 'scaleFactor_LepTRIGGER', 'totalWeight', 'mllll', 'lep_pt_0',\n", + " 'lep_pt_1', 'lep_pt_2', 'lep_pt_3'],\n", + " dtype='object')\n", + "Background $ZZ^*$\n", + "Index(['lep_pt', 'lep_eta', 'lep_phi', 'lep_E', 'lep_charge', 'lep_type',\n", + " 'mcWeight', 'scaleFactor_PILEUP', 'scaleFactor_ELE', 'scaleFactor_MUON',\n", + " 'scaleFactor_LepTRIGGER', 'totalWeight', 'mllll', 'lep_pt_0',\n", + " 'lep_pt_1', 'lep_pt_2', 'lep_pt_3'],\n", + " dtype='object')\n", + "Signal ($m_H$ = 125 GeV)\n", + "Index(['lep_pt', 'lep_eta', 'lep_phi', 'lep_E', 'lep_charge', 'lep_type',\n", + " 'mcWeight', 'scaleFactor_PILEUP', 'scaleFactor_ELE', 'scaleFactor_MUON',\n", + " 'scaleFactor_LepTRIGGER', 'totalWeight', 'mllll', 'lep_pt_0',\n", + " 'lep_pt_1', 'lep_pt_2', 'lep_pt_3'],\n", + " dtype='object')\n" + ] + } + ], + "source": [ + "for column in data:\n", + " print(column)\n", + " print(data[column].columns)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Este plot es grafica histogramas de la signal, fondo, data, y errores estadisticos" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_data(data):\n", + "\n", + " xmin = 80 # GeV\n", + " xmax = 250 # GeV\n", + " step_size = 5 # GeV\n", + "\n", + " bin_edges = np.arange(start=xmin, # The interval includes this value\n", + " stop=xmax+step_size, # The interval doesn't include this value\n", + " step=step_size ) # Spacing between values\n", + " bin_centres = np.arange(start=xmin+step_size/2, # The interval includes this value\n", + " stop=xmax+step_size/2, # The interval doesn't include this value\n", + " step=step_size ) # Spacing between values\n", + "\n", + " data_x,_ = np.histogram(data['data']['mllll'], \n", + " bins=bin_edges ) # histogram the data\n", + " data_x_errors = np.sqrt( data_x ) # statistical error on the data\n", + "\n", + " signal_x = data[r'Signal ($m_H$ = 125 GeV)']['mllll'] # histogram the signal\n", + " signal_weights = data[r'Signal ($m_H$ = 125 GeV)'].totalWeight # get the weights of the signal events\n", + " signal_color = samples[r'Signal ($m_H$ = 125 GeV)']['color'] # get the colour for the signal bar\n", + "\n", + " mc_x = [] # define list to hold the Monte Carlo histogram entries\n", + " mc_weights = [] # define list to hold the Monte Carlo weights\n", + " mc_colors = [] # define list to hold the colors of the Monte Carlo bars\n", + " mc_labels = [] # define list to hold the legend labels of the Monte Carlo bars\n", + "\n", + " for s in samples: # loop over samples\n", + " if s not in ['data', r'Signal ($m_H$ = 125 GeV)']: # if not data nor signal\n", + " mc_x.append( data[s]['mllll'] ) # append to the list of Monte Carlo histogram entries\n", + " mc_weights.append( data[s].totalWeight ) # append to the list of Monte Carlo weights\n", + " mc_colors.append( samples[s]['color'] ) # append to the list of Monte Carlo bar colors\n", + " mc_labels.append( s ) # append to the list of Monte Carlo legend labels\n", + " \n", + "\n", + "\n", + " # *************\n", + " # Main plot \n", + " # *************\n", + " main_axes = plt.gca() # get current axes\n", + " \n", + " # plot the data points\n", + " main_axes.errorbar(x=bin_centres, y=data_x, yerr=data_x_errors,\n", + " fmt='ko', # 'k' means black and 'o' is for circles \n", + " label='Data') \n", + " \n", + " # plot the Monte Carlo bars\n", + " mc_heights = main_axes.hist(mc_x, bins=bin_edges, \n", + " weights=mc_weights, stacked=True, \n", + " color=mc_colors, label=mc_labels )\n", + " \n", + " mc_x_tot = mc_heights[0][-1] # stacked background MC y-axis value\n", + " mc_x_err = np.sqrt( mc_x_tot ) # statistical error on the MC bars\n", + " \n", + " # plot the signal bar\n", + " main_axes.hist(signal_x, bins=bin_edges, bottom=mc_x_tot, \n", + " weights=signal_weights, color=signal_color,\n", + " label=r'Signal ($m_H$ = 125 GeV)')\n", + " \n", + " # plot the statistical uncertainty\n", + " main_axes.bar(bin_centres, # x\n", + " 2*mc_x_err, # heights\n", + " alpha=0.5, # half transparency\n", + " bottom=mc_x_tot-mc_x_err, color='none', \n", + " hatch=\"////\", width=step_size, label='Stat. Unc.' )\n", + "\n", + " # set the x-limit of the main axes\n", + " main_axes.set_xlim( left=xmin, right=xmax ) \n", + " \n", + " # separation of x axis minor ticks\n", + " main_axes.xaxis.set_minor_locator( AutoMinorLocator() ) \n", + " \n", + " # set the axis tick parameters for the main axes\n", + " main_axes.tick_params(which='both', # ticks on both x and y axes\n", + " direction='in', # Put ticks inside and outside the axes\n", + " top=True, # draw ticks on the top axis\n", + " right=True ) # draw ticks on right axis\n", + " \n", + " # x-axis label\n", + " main_axes.set_xlabel(r'4-lepton invariant mass $\\mathrm{m_{4l}}$ [GeV]',\n", + " fontsize=13, x=1, horizontalalignment='right' )\n", + " \n", + " # write y-axis label for main axes\n", + " main_axes.set_ylabel('Events / '+str(step_size)+' GeV',\n", + " y=1, horizontalalignment='right') \n", + " \n", + " # set y-axis limits for main axes\n", + " main_axes.set_ylim( bottom=0, top=np.amax(data_x)*1.6 )\n", + " \n", + " # add minor ticks on y-axis for main axes\n", + " main_axes.yaxis.set_minor_locator( AutoMinorLocator() ) \n", + "\n", + " # Add text 'ATLAS Open Data' on plot\n", + " plt.text(0.05, # x\n", + " 0.93, # y\n", + " 'ATLAS Open Data', # text\n", + " transform=main_axes.transAxes, # coordinate system used is that of main_axes\n", + " fontsize=13 ) \n", + " \n", + " # Add text 'for education' on plot\n", + " plt.text(0.05, # x\n", + " 0.88, # y\n", + " 'for education', # text\n", + " transform=main_axes.transAxes, # coordinate system used is that of main_axes\n", + " style='italic',\n", + " fontsize=8 ) \n", + " \n", + " # Add energy and luminosity\n", + " lumi_used = str(lumi*fraction) # luminosity to write on the plot\n", + " plt.text(0.05, # x\n", + " 0.82, # y\n", + " '$\\sqrt{s}$=13 TeV,$\\int$L dt = '+lumi_used+' fb$^{-1}$', # text\n", + " transform=main_axes.transAxes ) # coordinate system used is that of main_axes\n", + " \n", + " # Add a label for the analysis carried out\n", + " plt.text(0.05, # x\n", + " 0.76, # y\n", + " r'$H \\rightarrow ZZ^* \\rightarrow 4\\ell$', # text \n", + " transform=main_axes.transAxes ) # coordinate system used is that of main_axes\n", + "\n", + " # draw the legend\n", + " main_axes.legend( frameon=False ) # no box around the legend\n", + " \n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_data(data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Vamos a usar los 4 leptones que tiene la data, para ello definimos un dict con algunos parametros que serán utliles" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "lep_pt_2 = { # dictionary containing plotting parameters for the lep_pt_2 histogram\n", + " # change plotting parameters\n", + " 'bin_width':1, # width of each histogram bin\n", + " 'num_bins':13, # number of histogram bins\n", + " 'xrange_min':7, # minimum on x-axis\n", + " 'xlabel':r'$lep\\_pt$[2] [GeV]', # x-axis label\n", + "}\n", + "\n", + "lep_pt_1 = { # dictionary containing plotting parameters for the lep_pt_1 histogram\n", + " # change plotting parameters\n", + " 'bin_width':1, # width of each histogram bin\n", + " 'num_bins':28, # number of histogram bins\n", + " 'xrange_min':7, # minimum on x-axis\n", + " 'xlabel':r'$lep\\_pt$[1] [GeV]', # x-axis label\n", + "}\n", + "\n", + "lep_pt_0 = { # dictionary containing plotting parameters for the lep_pt_0 histogram\n", + " # change plotting parameters\n", + " 'bin_width':1, # width of each histogram bin\n", + " 'num_bins':19, # number of histogram bins\n", + " 'xrange_min':7, # minimum on x-axis\n", + " 'xlabel':r'$lep\\_pt$[0] [GeV]', # x-axis label\n", + "}\n", + "\n", + "lep_pt_3 = { # dictionary containing plotting parameters for the lep_pt_3 histogram\n", + " # change plotting parameters\n", + " 'bin_width':1, # width of each histogram bin\n", + " 'num_bins':30, # number of histogram bins\n", + " 'xrange_min':7, # minimum on x-axis\n", + " 'xlabel':r'$lep\\_pt$[3] [GeV]', # x-axis label\n", + "}\n", + "\n", + "SoverB_hist_dict = {'lep_pt_2':lep_pt_2,'lep_pt_1':lep_pt_1,'lep_pt_3':lep_pt_3,'lep_pt_0':lep_pt_0} \n", + "# add a histogram here if you want it plotted" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### plot_SoverB nos permite graficas histogramas tanto de signal como de fondo para comparar la SNR" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_SoverB(data):\n", + " \n", + " signal = r'Signal ($m_H$ = 125 GeV)' # which sample is the signal\n", + "\n", + " # *******************\n", + " # general definitions (shouldn't need to change)\n", + "\n", + " for x_variable,hist in SoverB_hist_dict.items(): # access the dictionary of histograms defined in the cell above\n", + "\n", + " h_bin_width = hist['bin_width'] # get the bin width defined in the cell above\n", + " h_num_bins = hist['num_bins'] # get the number of bins defined in the cell above\n", + " h_xrange_min = hist['xrange_min'] # get the x-range minimum defined in the cell above\n", + " h_xlabel = hist['xlabel'] # get the x-axis label defined in the cell above\n", + " \n", + " bin_edges = [ h_xrange_min + x*h_bin_width for x in range(h_num_bins+1) ] # bin limits\n", + " bin_centres = [ h_xrange_min+h_bin_width/2 + x*h_bin_width for x in range(h_num_bins) ] # bin centres\n", + " \n", + " signal_x = data[signal][x_variable] # histogram the signal\n", + " \n", + " mc_x = [] # define list to hold the Monte Carlo histogram entries\n", + "\n", + " for s in samples: # loop over samples\n", + " if s not in ['data', signal]: # if not data nor signal\n", + " mc_x = [*mc_x, *data[s][x_variable] ] # append to the list of Monte Carlo histogram entries\n", + "\n", + " \n", + " \n", + " # *************\n", + " # Signal and background distributions\n", + " # *************\n", + " distributions_axes = plt.gca() # get current axes\n", + " \n", + " mc_heights = distributions_axes.hist(mc_x, bins=bin_edges, color='red', \n", + " label='Total background',\n", + " histtype='step', # lineplot that's unfilled\n", + " density=True ) # normalize to form probability density\n", + " signal_heights = distributions_axes.hist(signal_x, bins=bin_edges, color='blue',\n", + " label=signal, \n", + " histtype='step', # lineplot that's unfilled\n", + " density=True, # normalize to form probability density\n", + " linestyle='--' ) # dashed line\n", + " \n", + " distributions_axes.set_xlim( left=bin_edges[0], right=bin_edges[-1] ) # x-limits of the distributions axes\n", + " distributions_axes.set_ylabel('Arbitrary units' ) # y-axis label for distributions axes\n", + " distributions_axes.set_ylim( top=max(signal_heights[0])*1.3 ) # set y-axis limits\n", + " plt.title('Signal and background '+x_variable+' distributions') # add title\n", + " distributions_axes.legend() # draw the legend\n", + " distributions_axes.set_xlabel( h_xlabel ) # x-axis label\n", + " \n", + " # Add text 'ATLAS Open Data' on plot\n", + " plt.text(0.05, # x\n", + " 0.93, # y\n", + " 'ATLAS Open Data', # text\n", + " transform=distributions_axes.transAxes, # coordinate system used is that of distributions_axes\n", + " fontsize=13 ) \n", + " # Add text 'for education' on plot\n", + " plt.text(0.05, # x\n", + " 0.88, # y\n", + " 'for education', # text\n", + " transform=distributions_axes.transAxes, # coordinate system used is that of distributions_axes\n", + " style='italic',\n", + " fontsize=8 ) \n", + " \n", + " plt.show() # show the Signal and background distributions\n", + " \n", + " \n", + " # *************\n", + " # Signal to background ratio\n", + " # *************\n", + " plt.figure() # start new figure\n", + " SoverB = [] # list to hold S/B values\n", + " for cut_value in bin_edges: # loop over bins\n", + " signal_weights_passing_cut = sum(data[signal][data[signal][x_variable]>cut_value].totalWeight)\n", + " background_weights_passing_cut = 0 # start counter for background weights passing cut\n", + " for s in samples: # loop over samples\n", + " if s not in ['data', signal]: # if not data nor signal\n", + " background_weights_passing_cut += sum(data[s][data[s][x_variable]>cut_value].totalWeight)\n", + " if background_weights_passing_cut!=0: # some background passes cut\n", + " SoverB_value = signal_weights_passing_cut/background_weights_passing_cut\n", + " SoverB_percent = 100*SoverB_value # multiply by 100 for percentage\n", + " SoverB.append(SoverB_percent) # append to list of S/B values\n", + " \n", + " SoverB_axes = plt.gca() # get current axes\n", + " SoverB_axes.plot( bin_edges[:len(SoverB)], SoverB ) # plot the data points\n", + " SoverB_axes.set_xlim( left=bin_edges[0], right=bin_edges[-1] ) # set the x-limit of the main axes\n", + " SoverB_axes.set_ylabel( 'S/B (%)' ) # write y-axis label for main axes\n", + " plt.title('Signal to background ratio for different '+x_variable+' cut values', family='sans-serif')\n", + " SoverB_axes.set_xlabel( h_xlabel ) # x-axis label \n", + " \n", + " plt.show() # show S/B plot\n", + " \n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEbCAYAAADJWrOxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAA4kklEQVR4nO3dd3gU5fbA8e9JIyShE3ogUqT3oNgR7KIg9nb1XpWr16ui2PV67WLvjWtBfyqKgl0URQQbIL33KkUCoQZC2vn9MRNdlmx2k+xmssn5PE+ebHl35szs7JyZ9515X1FVjDHGmGBivA7AGGNMdLCEYYwxJiSWMIwxxoTEEoYxxpiQWMIwxhgTEksYxhhjQhI1CUNELhaRCRUwn34i8nuEpp0uIioicWGe7r0i8k44p1kRRORyEfkpwvNYKCL9yvjZB0Vkq4hsDm9Uf07/BxG50n18wPYtIkeJyHIR2SMig0WksYhMEZHdIvJkJOIpD99lMZEVqf1IKCpVwhCRo0XkFxHZKSJZIvKziPQBUNV3VfWkShCjikhbr+MwBxORUSLyoO9rqtpZVX8ow7RaAsOBTqraJEwhBlTM9n0/8IKqpqjqJ8BQYCtQW1WHRzoeXxWR2Msr1IQlIo1EZLSIbHT3Mz+LyOERiKfSr7OyqDQJQ0RqA18AzwP1gebAfcB+L+OqTrw4YgmVB7G1BLap6pbSfjBMsbYCFvo9X6RluNO2Mn+vHkgBfgN64+xn3gK+FJEUT6OKFqpaKf6ADGBHCe9fDvzk8/wkYCmwE3gJmAxc6VsWeALYDqwGTvX57N+BxcBuYBXwT5/3+gG/B4hhCqBANrAHON99/SpgBZAFfAY0C/D5dPfzQ4GNwCbgZp/3DwN+BXa4770AJPi83xn41p3PH8Cd7uv3Au+4j+OB0cBYIAGoifOj2O4u862+ywesAW4D5uEk5zjgTJyd1Q7gB6CjT3kF2vo8HwU86LvucI7Mt7jL8Hefsg3c9bMLmA484PudBlhXVwDrgCnu6x8Cm93vfQrQ2X19KJAH5Lrfzec+y3eC+7gG8Iy77je6j2sUM+8TgH1AoTutUe7rJa2Xg9ZjMdM9EVjixv4CxWyz7uOV7rz3ufMf7bdsJ+Ac7N3ult0GjAHqB1l3/3C3ge3AN0Arv+/1amC5u3wvAgJ0BHKAAnfexf5G3fVxpc/zYPO6Hue3txV4HIgJsn+4HPjZXW873fU4wH3vITe+HDfGF0q579kF9A7wXixwp7uedwMzgTSfdRznvw5CWWfA+cAMv9duBD5zH58OzHZjWw/cW8xvI85/G/ffH7jP+wK/uN/rXKCf33pd5S7bauDiEtdVaVZsJP+A2u6G/xZwKlCvmA2m6AfV0F2RQ3B2cDfg/KB8f3x5ODvyWOAanB2E+HwZbXB+EMcBe4Fe6rPTKyFO/x1mf3ej74WzQ3oe9wdazGeLvujRQDLQFcjkrx1ab/fLjXPLLgaGue/VwtkBDwcS3eeH+24gOMnhS5ydeKz73gicHVM9oAXODs0/YczB+RHUBA7FSYgn4iSfW3GSYUKA5R/FgQkjH6c6JR44zV239dz338fZsSUDXYANBE8Yb7vla/rsiGrx185/TnGx+C1f0fq9H5gKNAJScX5EDwSY/wHbQQjr5YD1WMz0GuL8KM9xP3+ju64OShgBdgIHLBvONj/V/U5rAK8CowOtO2CQG29HnO3rbuAXv+36C6AuztlVJnBKcbEFWF8/+CxLKPOahHOE3xJYhk+yCTD9y931daO7/s7HSRz1/edfyv1OD5yde50A798CzAfa4+wvuuMc+BSt44MSRijrDEhyt4d2Pq/9Blzgs/11xTkw6IZzgDjY7/sNmjBwamq24fwWY3C23204238yzn60vVu2Ke4BWMC4S7uCI/nnbmCjcI5S83GORhv7fwHA34BffT4nOFnY98ta4fflKNAkwHw/AW4obkdRTFn/HebrwGM+z1NwklV6MZ8t+qI7+Lz2GPB6gHkNAz52H18IzA5Q7l53XU0GnsNNjO57q4CTfZ5fycEJ4x8+z/8DjPF5HoOzY+8XYPlHcWDC2MeBP6ItOEkw1l0vvsv+MMETRusSvou6bpk6/rH4LV9RwlgJnObz3snAmgDTPmA7CGG9HLAei5ne34Cpftvs75Q9YSzGPcJ2nzd112/RwcYB6w4YD1zhF/9e3CN/t/zRPu+PAW4vLrYAy/eDz7KEMq9TfN7/FzAxyPQvx+egz31tOnCp//xD/cM5SJ0P3FFCmaXAoBK2zzIlDLfMO8A97uN2OAkkKUDZZ4Cni5t3MdvKvfyVMG4D/s9vWt8Al+EkjB3A2RRzkFPcX6VpwwBQ1cWqermqtsA5Am2Gs6L8NcNJEEWfU5wfn6/NPu/vdR+mAIjIqSIy1W1Y34GTfRuWMexmwFqfee3ByeDNS/jMep/Ha91pICKHisgXIrJZRHbh7FCL4krD2eEF0hfnSGSEuz584/Od33oO5vua//IUuu+XtDy+tqlqvs/zvTjrPRVnZ+a/7MH8WV5EYkVkhIisdNfPGvetUL+7A5YNn3Vf2s8GWC/FrVvfz/tvsyWVD6YV8LGI7HC34cU4VSCNA8TTCnjWp3wWTtLyjd/3arCi762ssQWbV7G/gSA2+G3bpfn+DiAiNYHPcZL4IyUUDfa7K4/3cA4EAS4CPinaV4nI4SIySUQyRWQnTnVhWfZRrYBzi74L9/s4Gmiqqtk4Z2pXA5tE5EsR6VDSxCpVwvClqktwjqq6FPP2JpxTcQBERHyfl0REauDU7z+Bc/ZSF/gKZ4Mui404X0rR9JNxTlk3lPCZNJ/HLd1pALyMUzfbTlVr49SdFsW1HmhdwjQnAI8AE0XEd6dxwLrym3cR3x+h//KI+5mi5dmLc8ZWJNQriDJxzhr9lz0Y39guwqnuOAGog3OkBX+tI9+yxTlg2Thw3QcTbL0Em/8mfJbd5/NltR6nXa6uz1+iqgaKZz1OW51v+Zqq+ksI8wq2XouLLdi8Av0GStLcXW/FfS7kGN19wCc4B5n/DFJ8PU71tb9s93+g30Io8XwLpIpID5zE8Z7Pe+/h1BqkqWod4BUC76OyS4hjPc4Zhu93kayqIwBU9RtVPRHnDHUJ8L+SAq40CUNEOojIcBFp4T5Pw1mJU4sp/iXQ1b0+PQ64ltB3XAk4db6ZQL6InIrTgB6qPzhwxz0a+LuI9HA3xIeBaaq6poRp/EdEkkSkM04D/Afu67Vw6hT3uJn+Gp/PfAE0FZFhIlJDRGr5Xw6oqo/hbGgTRaToaGQMcIeI1BOR5sC/gyzfGOB0ERkgIvE4bSb7cer7wamnv8g92j8Fpw0oKFUtAMYB97rL3gnntLg0armxbMP5gTzs977/d+NvNHC3iKS66+cenGqBUARbL8F8CXQWkSHuNns9oW+zxXkFeEhEWgG4yzQoSPk73G0OEakjIueGOK8/gBYiklCK2ILN6xZ3m0zDaY/5wH8ixWgEXC8i8e70OuIc7BXFWNJ3jxtLPPARTtXpZe6ZYkleAx4QkXbi6CYiDVQ1E+dg4RL3t/APDkwsQdeZqubhXMTxOE57zrc+b9cCslQ1R0QOwzlYCmQOcIG7XjJw2smKvAOcISInu3EminOvWQtx7u0Z5B7k7sdpoC9xfVSahIFTf3c4ME1EsnESxQKcH+YBVHUrcC5O/f82oBMwgxAuwVXV3Tg/1jE4V3BchJPJQ3Uv8JZ7eneeqn6HU789Fucosg1wQZBpTMZpFJwIPKGqRTds3ezGsxsn0//5I3LjPhE4A6fqYDlwfDHL9wDO0dN3IlIfp6H3d5wrIL7D+bEEXE+quhS4BKfxfqs7vzNUNdctcoP72g7gYndeofo3TjXHZpyzxzdL8VlwGnHX4vxQF3HwwcTrQCf3uykurgdxtpN5OHXXs9zXggphvQT7fNE2OwJnm22Hc9VPWT2Ls91OEJHdOOsi4P0Eqvox8CjwvludtwDn4pJQfI9zddhmEdkarHCI8/oU54qjOTjJ9PUQ4piGs9624lwZdY6qbnPfexY4R0S2i8hzJUzjSGAgzkHiDnFujNwjIscEKP8Uzr5iAs7B3Os4FxGAc1HNLTjfZ2cOPHgIdZ29h3PG/KFfVe6/gPvd7/YeN4ZA/oOz39mOcyvCn2cqqroe56z8TpyD5PVuzDHu3004Z2lZOAd/vgepBym6aiiqiUgMzk7xYlWd5HU8lZmIXINzJUZIZwbGhJuIKE6164pSfOZynAbloyMWmAmqMp1hlIp7ilXXrQYqqusvrvqqWhORpuJ0MxEjIu1xztg+9jouY0z0idqEARyBc/VCUfXAYFXd521IlVICzjX6u3FOkz/FudHRmEpFRF7xqSLy/XullNM5JsB09kQq9uqiSlRJGWOMibxoPsMwxhhTgSxhGGOMCUnU9WLZsGFDTU9P9zoMY4yJKjNnztyqqqnlmUbUJYz09HRmzJjhdRjGGBNVRCSUrnhKZFVSxhhjQmIJwxhjTEgsYRhjjAmJJQxjjDEhsYRhjDEmJJYwjDHGhCTqLqs1JhIKC5Wd+/LI2pvL9uxcdu7Lo0FKDVqnJlM7Md7r8IypFCxhmCqnsFDZnZNP1t5csrJz2eH+3743l6zsPLZn5/6ZGLbvzWX73jx27M2lMEC3aqm1atC6YTJtGqU4/1NTaJ2aTIt6ScTGlHWgRmOijyUME1XWZ+1l+uosd+ef+9f/7Dx35+8kgIIAe//4WKFeUgL1kxOol5RAhya1qZsU/+fz+skJ1EtOoHZiHJm797MyM5tVmXtYtTWbr+ZvYsfevD+nlRAXQ3qDJFo3TKFNo2RaN3QSSevUFOrUtLMSU/VELGGISCIwBWc41DjgI1X9r1+ZGjijqPXGGbXq/CBDm5pqbMWW3Qx56Rd25TgDk8XGFO3846mXlEDbRinUS06gXlL8ATv/+u7juknxpNSI48BhoUsnKzuXVZl7WJm5h1WZ2azMzGbZH7v5dvEfBySphm51VpvUv85IWjdMoUW9msTFWtOhiU6RPMPYD/RX1T3uOLo/ich4VfUd5OgKYLuqthWRC3CGdTw/gjGZKLVldw6XvfEbCXGxfP7vvrRqmEStcu78y6J+cgL1k+uTkV7/gNfzCgpZl7WXlVucsxEnqWTz9YLNbPc9K4mNoVWDpD/PRDo0qcUpXZpQIy62QpfDmLKIWMJQZ6CNogFL4t0//3qCQThjZIMz1vQLIiJqg3QYH9n78/nHqN/Iys5lzD+PoGuLOl6HdJD42BjapKbQJjXloPe2Z+eyauseVm7JZuVW58xk+ZY9TFy8hfxCpU1qMg+d1ZW+rRt4ELkxoYtoG4aIxOIM9N4WeFFVp/kVaY4zKDmqmi8iO4EGOKPoGUN+QSHXjZ7Noo27eO2yjEqZLIKpl5xA7+T69G518FnJlGWZ/PezhVwwcirn9m7BHad1pH5ygkeRGlOyiFamqmqBqvYAWgCHiUiXskxHRIaKyAwRmZGZmRnWGE3lpar897OFfL9kCw8M7kL/Do29Dims4mNjGNCxMd/eeBxXH9eGj2dvYMCTP/DhjPXYSbapjCqk9U1VdwCTgFP83toApAGISBxQB6fx2//zI1U1Q1UzUlPL1Z27iSKvTF7Fu9PWcU2/Nlx8eCuvw4mYmgmx3H5qB764/mhap6Zwy0fzuGDkVFZssSGoTeUSsYQhIqkiUtd9XBM4EVjiV+wz4DL38TnA99Z+YQA+nbOBR79ewpndm3HLSe29DqdCdGhSmw//eQSPDOnK4k27OPXZKTw1YSk5eQVeh2YMENkzjKbAJBGZB/wGfKuqX4jI/SJyplvmdaCBiKwAbgJuj2A8JkpMXbWNWz6cx+GH1Ofxc7sRU41ujouJES48rCUTh/fj9K5Nee77FZzyzBR+Wm7NesZ7Em0H9BkZGWoj7lVdRfdaNKqdyNirj6ROUvW+Ae6n5Vu5+5P5rNm2l8E9mnHX6Z1IrVXD67BMFBKRmaqaUZ5p2B1EptLwvdfizcv7VPtkAXB0u4Z8PexYru/fli/nb2LAkz/w3rR1FAbqx8SYCLKEYSoF33st3ry8D2n1k7wOqdJIjI/lppPaM/6GY+nYtDZ3fjyfc1/9lSWbd3kdmqlmLGEYz/nea/HixT2j8l6LitC2UQrvD+3L4+d0Y1XmHgY+9xMjxi9hX641ipuKYQnDeMr3Xov7B1W9ey3CTUQ4NyONicP7cVbP5rwyeSUnPj2ZSUu3eB2aqQYsYRhPFd1rcfVxbbikb9W91yLc6icn8Pi53Xl/aF9qxMXw9zd/49p3Z/HHrhyvQzNVmCUM45miey3O6N6MW0+uHvdahFvf1g346oZjGH7ioXy7+A9OeHIyb/+6JmD37saUhyUM44miey0OO6Q+T1Szey3CrUZcLNcNaMeEYcfSo2Vd7vl0IUNe+pkFG3Z6HZqpYixhmAq3Ystuhr49g7T6NRl5aW/r2jtM0hsm8/Y/DuPZC3qwYcc+znzhJx74YhHZ+/O9Ds1UEZYwTIXyvddi1N8Po26S9cwaTiLCoB7NmXhTPy44rCWv/7SaE5+azMTFf3gdmqkCLGGYCpO9P58rRs0gKzuXNy7PsHstIqhOUjwPn9WVsdccSe2a8Vzx1gw++G2d12GZKGcJw1SI/IJCrh89m4Ubd/LCRT3p1qKu1yFVC71b1eOTa4/iuENTuW3sfEsaplwsYZiIU1Xu/XwhE917LQZ0tHstKlJifCyvXtrbkoYpN0sYJuJenbKKd6bavRZesqRhwsEShomoz+ZuZMR4u9eiMrCkYcrLEoaJmGmrtnHzmLl2r0UlYknDlIclDBMRK7bs5iq716JS8k0at4+bz5jf1nsdkokSljBM2G3ZncPlb/5GQlyM3WtRSRUljWPapXLbuHmWNExILGGYsNqb69xrsW1PLm/YuBaVWmJ8LCMtaZhSsIRhwia/oJDr3nPutXj+QrvXIhpY0jClYQnDhIXvvRb3ndmZEzrZvRbRwpKGCZUlDFNu67P2MnzMXN6Zuo5/HteaS49I9zokU0qWNEwo4rwOwESvDTv28eKkFYz5bT0xMcLVx7Wxey2iWFHSGPp/M7lt3DwAzuuT5nFUpjKxhGFKbfPOHF76YQXvT1+Polx0eEv+1a8tTeokeh2aKSdLGqYkljBMyLbszuHlH1by7rR1FBYq5/VJ49rj29K8bk2vQzNhZEnDBGIJwwS1dc9+Xp28kv+bupa8AuXsXs25rn87u2S2CjsoaQicl2FJo7qzhGECysrOZeSUVbz1yxr25xcwuGdzru/fjvSGyV6HZipAUdK46u0Z3DbWPdOwpFGtWcIwB9mxN5fXflzNmz+vZm9eAWd2b8b1A9rRJjXF69BMBUuMj+V/f8uwpGEASxjGx66cPN74aTWv/7ia3fvzOb1bU4YNaEe7xrW8Ds14yJKGKWIJw7Bnfz6jfl7NyCmr2JWTzymdm3DDCe3o2LS216GZSsKShgFLGNVa9v583v51La9OWcmOvXmc0LExw05oR5fmdbwOzVRC/klDgHMtaVQrljCqoX25BbwzdS2vTF7Jtuxcjm+fyrATDqV7Wl2vQzOVnG/SuNU907CkUX1ELGGISBrwNtAYUGCkqj7rV6YO8A7Q0o3lCVV9M1IxVXc5eQW8N20dL/2wkq179nNMu4bceOKh9GpZz+vQTBSxpFF9RfIMIx8YrqqzRKQWMFNEvlXVRT5lrgUWqeoZIpIKLBWRd1U1N4JxVTv78wv44Lf1vDhpBX/s2s+RbRrw8iW96JNe3+vQTJSypFE9RSxhqOomYJP7eLeILAaaA74JQ4FaIiJACpCFk2hMGKgqn87ZyGNfL2Hjzhz6pNfjmfN7ckSbBl6HZqoASxrVT4W0YYhIOtATmOb31gvAZ8BGoBZwvqoWFvP5ocBQgJYtW0Y01qpiwYad3PvZQmas3U7X5nV47JzuHNW2AU5uNiY8/JNGbIwwpFcLr8MyESKqGtkZiKQAk4GHVHWc33vnAEcBNwFtgG+B7qq6K9D0MjIydMaMGRGMOLpt27OfJyYs4/3f1lE/KYHbTunAOb1bEBNjicJETk5eAf8Y9Rsz1mxn3L+OtCvtKiERmamqGeWZRkTHwxCReGAs8K5/snD9HRinjhXAaqBDJGOqqvIKCnnz59Uc/8QPfDhjPf846hC+v7kf5/VJs2RhIi4xPpYXLupFg5QE/vXuLHbl5HkdkomAiCUMt13idWCxqj4VoNg6YIBbvjHQHlgVqZiqqp9XbOX0537kvs8X0T2tLl8PO4b/DOxEnZrxXodmqpH6yQk8f2FPNuzYx20fzSPStRem4kWyDeMo4FJgvojMcV+7E+cSWlT1FeABYJSIzAcEuE1Vt0YwpiplfdZeHv5qMeMXbCatfk1GXtqbEzs1tnYK45mM9PrcenJ7Hhm/hLd+WcPlRx3idUgmjCJ5ldRPOEmgpDIbgZMiFUNVtS+3gJcnr+TVySuJEeHmkw7lymNakxgf63VoxnDVMa2ZvjqLh75aTM+W9eyG0CrExvSOIqrKl/M2MeDJH3hu4nJO7tyE728+jn/3b2fJwlQaMTHCk+d1p1GtRK59bxY791p7RlVhCSNKLNm8iwv/N5Vr35tFnaQEPhjal+cu7EnTOjbanal86iYl8PxFPdm8M4ebP5pr7RlVhPUlVcnt2JvLU98u452pa6ldM54HB3fhwsNaEmtXPplKrlfLetx+agce/HIxr/+0miuPae11SKacLGFUUgWFyujp63hywlJ27svjkr6tuOnEQ6mblOB1aMaE7IqjD2H66ixGjF9Cr1b1rN+yKGdVUpXQ9NVZDHz+J+7+ZAHtm9Tiy+uP4f5BXSxZmKgjIjx+Tnea1Enkuvdms2OvdRMXzSxhVCIbd+zjutGzOe/VX9m5N5cXL+rF6Kv62kBGJqrVSYrnxYt6sWV3DsPHzKWw0NozopVVSVUCOXkFvPbjKl6ctJJCVW4Y0I6rj2tDzQS78slUDd3T6nLXaR259/NF/O/HVfzzuDZeh2TKwBKGh1SVCYv+4MEvF7E+ax+ndmnCnad1JK1+ktehGRN2lx2ZzvQ1WTz2zVJ6t6pHhnWvH3WsSsojRZ21/fP/ZlIzPpZ3rzycly/pbcnCVFkiwoizu9GiXk3+/d5ssrKtPSPaWMLwyH2fL2LS0kzuOq0jX15/DEe1beh1SMZEXO1Epz0jKzuXGz+YY+0ZUcYShgfGzfqd0dPXcU2/Nlx1bGviY+1rMNVHl+Z1+M8ZnZi8LJOXJ6/0OhxTCranqmDL/tjNXR8v4PBD6jP8xEO9DscYT1xyeEsGdmvKkxOWMm3VNq/DMSGyhFGB9uzP5+p3ZpJcI47nL+xJnJ1ZmGpKRHhkSFdaNUjmutGz2bpnv9chmRDYHquCqCp3jJvPmq3ZPH9hTxrVTvQ6JGM8Vcttz9i5L48bP5hDgbVnVHqWMCrIO1PX8vncjQw/qT1HtGngdTjGVAqdmtXm3jM78+Pyrbw4aYXX4ZggLGFUgLnrd/DAF4s5vn0q19gNS8Yc4II+aQzu0YxnvlvGLytt/LTKzBJGhO3Ym8u/3p1Faq0aPHVeDxtf2xg/IsJDZ3XlkIbJXD96Dlt253gdkgnAEkYEFRYqw8fMZcvuHF68uBf1kq3zQGOKk1wjjpcu7s2e/XncMNraMyorSxgR9OqUVUxcsoW7T+9EDxum0pgStW9Si/sHdeHXVdt4duJyr8MxxbCEESFTV23j8W+WcHq3pvztiFZeh2NMVDgvI42ze7Xg+e+X8+PyTK/DMX4sYUTAlt05XDd6NukNk3n07G6IWLuFMaF6YHBn2qamMOz9Ofyxy9ozKhNLGGGWX1DIDaPnsDsnj5cv7k1KDesQ2JjSSEqI46WLe7E3t4DrRs8mv6DQ65CMyxJGmD393TJ+XbWNBwd3pX2TWl6HY0xUate4Fg+d1YXpq7N4+rtlXodjXJYwwmjSki28OGklF/RJ45zeLbwOx5ioNqRXC87PSOPFSSv5YekWr8MxWMIIm9+37+XGMXPo1NS5c9UYU373DepMhya1uPGDOWzauc/rcKo9SxhhkJtfyLXvzaagQHnp4l4kxtvQqsaEQ2J8LC9e3Ivc/EKue282edae4SlLGGHw8FeLmbt+B4+f2430hsleh2NMldImNYWHh3RlxtrtPPHNUq/DqdYsYZTTF/M2MuqXNVxx9CGc0qWp1+EYUyUN6tGciw5v6dwMu/gPr8OptixhlMPKzD3c9tE8erWsy+2ndvA6HGOqtHsGdqJj09rcNGYuv2/f63U41ZIljDLal1vAv96ZRY34WF64qJcNs2pMhCXGx/LSxb0oKFRu/nCujQfugYjt5UQkTUQmicgiEVkoIjcEKNdPROa4ZSZHKp5wUlXu/mQBy7bs5pnze9Csbk2vQzKmWjikYTJ3nd6RqauyeGfaWq/DqXYieVicDwxX1U5AX+BaEenkW0BE6gIvAWeqamfg3AjGEzZjZqxn7Kzfua5/O449NNXrcIypVi7ok8Yx7RryyFdLWLfNqqYqUtCEISJHiMiLIjJPRDJFZJ2IfCUi14pInUCfU9VNqjrLfbwbWAw09yt2ETBOVde55Sr93TmLNu7ink8XcnTbhtwwoJ3X4RhT7YgII87uRmyMcMtHVjVVkUpMGCIyHrgS+AY4BWgKdALuBhKBT0XkzGAzEZF0oCcwze+tQ4F6IvKDiMwUkb+Vegkq0K6cPP717kzqJsXzzAU9iLXBkIzxRPO6Nbn79I5MW53F/021qqmKEqxnvEtV1X/MxD3ALPfvSRFpWNIERCQFGAsMU9Vdxcy/NzAAqAn8KiJTVXWZ3zSGAkMBWrZsGSTkyFBVbv1wHuu37+P9oX1pmFLDkziMMY7z+6Tx1YLNjBi/hH7tU2nVwO6BirQSzzCKSRaIyAAROUNE4gOV8Skbj5Ms3lXVccUU+R34RlWz3elMAboXE8dIVc1Q1YzUVG/aDN74eQ1fL9zMbae0p096fU9iMMb8RUQYMaQrcTHCLR/Ns6qpClCqRm8ReRI4Cmen/mmQsgK8DixW1acCFPsUOFpE4kQkCTgcp62jUpm5djuPfLWYkzo15qpjWnsdjjHG1axuTe4e2JHpq7N4+9c1XodT5ZVYJeUmiAdUdYf7UkvgPPfx/CDTPgq4FJgvInPc1+50p4GqvqKqi0Xka2AeUAi8pqoLSrsQkZSVncu/35tFs7o1efzc7jYYkjGVzHkZaXw1fzOPfr2U4zs0sqqpCArWhjEOeF9EvgJeBN4GJuE0eP+vpA+q6k9A0L2rqj4OPB5StBWssFAZ9sEctmXnMu6aI6lTM97rkIwxfpyrprpy0lNTuOWjebx/VV9i7IKUiAjWhvGzqp4CZOFcKSWq2k9V+6rqsxUSoYdemLSCKcsyufeMznRpHvAKYmOMx5rWqcl/BnZi+uos3rKqqYgJdlltnIicDmwBBgPdReQzETmoYbqq+Wn5Vp7+bhln9WzOhYeleR2OMSaIczNa0K99Ko9+vYQ1W7O9DqdKCtbo/QnQAzgOeFFVHwCuBq4TkRKrpKLZ5p053PD+bNqmpvDQWV2s3cKYKCAiPDKkK/GxMdxqV01FRLCE0UpVHwLuA7oCqOpGVb0Sp02jSlFVJi3ZwkWvTWVfXgEvX9KLpIRgzTzGmMriz6qpNVmM+mWN1+FUOcH2hiNF5Ff38QGXxqrqnIhE5JHZ67YzYvwSpq3OolWDJEZemkHbRrW8DssYU0rn9m7B+PmbeOybJRzfoRGH2KBmYSOq0XXalpGRoTNmzAjb9FZm7uGJb5YyfsFmGqYkcMOAdpzfpyUJcdZduTHRavPOHE58ejIdmtTig6FH2FVTgIjMVNWM8kwjWKP33SJSr4T3+4vIwPIE4JUtu3K48+P5nPT0FKYsy2TYCe2YfMvxXHpEuiULY6JckzqJ3DOwE7+t2c6bVjUVNsGqpOYDX4hIDk7fUZk492C0w2kM/w54OJIBhtvunDxGTlnFaz+uJq+gkEsOb8m/+7cjtZb1DWVMVXJO7xaMX7CZx79ZQn+rmgqLkKqkRKQdzp3bTYF9ON13TFHVfZEN72BlrZLan1/Au1PX8cKkFWRl5zKwW1NuPqk96bYRGVNlFVVNtW9ciw/+eUS17mE6HFVSIV0CpKrLgeXlmZFXCguVz+Zu5Mlvl7I+ax9HtmnA7ad2oFuLul6HZoyJsCZ1EvnvGZ25+cO5vPnzaq60vuDKpcpeM6qq/Lh8KyPGL2HRpl10alqbt//RlWPaNbT7KoypRs7u1Zzx8zfx+DdL6d+hEa1TU7wOKWpVydbd+b/v5JLXp/G3N6azKyePZy/owRfXHc2xh6ZasjCmmhERHh7SlRpxMdzy0TwK7Ia+MqtSZxhrt2Xz+DdL+WLeJuolxXPPwE5c3LclNeJivQ7NGOOhxrUTuffMztw0xqqmyiNY9+aJwPnAduBz4FbgGGAlTrfnAQdPqkhb9+zn+YnLeXfaOuJjY7iuf1uuOrY1tROtd1ljjOOsns35yq2aOr5DI9pY1VSplXiVlIiMAfKAZKAesAAncRwN9FDVCr8Hw/cqqT3783ntx1X8b8oqcvILOb9PGsMGtKNR7cSKDssYEwW27MrhxKen0CY1mQ+vPrJaXTVVEVdJdVLVLiISB/yuqse5r38tInPLM+PyyCso5P3p63h24nK27snl1C5NuPnk9nbEYIwpUaPaidx7Zidu/GAub/y0mquOtaqp0giWMHIBVDVfRDb6vVcQmZBKtnNfHic+NZk12/Zy2CH1Gfm3DvRqGfBmdGOMOcDgHs35ct5mnpiwlP4drWqqNIIljBYi8hzOyHlFj3GfN49oZAGsy9pL67hY3rg8g+PbN7KrnowxpSIiPHxWF058egq3fDi32lVNlUewNozLSvqwqr4V9oiCaNOpmy5bMNe+YGNMuXwyewPDPpjDnad1YOixbbwOJ+Iqog2jOTBeVWeXZybhVC8pwZKFMabcBvVoxpfzN/HEhGX079CYto2saiqYYDfurQRuEJHZIjJKRM4vqfdaY4yJFiLCQ2d1ISkhlls+mms39IWgxIShqh+o6uWq2hN4FmgNjBORKSJyj4gcViFRGmNMBDSqlch9Z3Zm9rodvPbjKq/DqfRC7hpEVWer6iOqejwwEFgIXBmxyIwxpgKc2b0ZJ3VqzJPfLmPFlt1eh1OpBRtAqY+INPF5/jcR+RR4EJikqkMjHaAxxkSSiPCgWzV184fW11RJgp1hvIp7L4aIHAuMAN4GdgIjIxuaMcZUjKKqqTnrd/A/q5oKKFjCiFXVLPfx+cBIVR2rqv8B2kY2NGOMqThndm/GyZ0b85RVTQUUNGG43YIADAC+93mvSvV0a4yp3kSEBwd3JTkhluEfziO/oNDrkCqdYAljNDDZbbfYB/wIICJtcaqljDGmykitVYP7BnVh7vod/O/H1V6HU+kEu6z2IWA4MAo4Wv+6LTwGuC6yoRljTMU7o1tTTunchKe/XcbyP6xqylfQy2pVdaqqfqyq2T6vLVPVWZENzRhjKl7RVVPJNWK5daxdNeWrSg7Raowx5dEwpQb3ujf0vfmzVU0ViVjCEJE0EZkkIotEZKGI3FBC2T4iki8i50QqHmOMKY0zuzdjQIdGPDFhKWu2Zgf/QDUQyTOMfGC4qnYC+gLXikgn/0IiEgs8CkyIYCzGGFMqTl9TXYmPieH2cfMotKqpyCUMVd1U1M6hqruBxRQ/hsZ1wFhgS6RiMcaYsmhSJ5G7B3Zk6qos3pu+zutwPFchbRgikg70BKb5vd4cOAt4Ocjnh4rIDBGZkZmZGbE4jTHG33kZaRzdtiGPfLWYDTv2eR2OpyKeMEQkBecMYpiq7vJ7+xngNlUt8Q4ZVR2pqhmqmpGamhqhSI0x5mAiwiNDuqLAnePmU9Kgc1VdRBOGiMTjJIt3VXVcMUUygPdFZA1wDvCSiAyOZEzGGFNaafWTuO2UDkxelsnYWRu8DsczkbxKSoDXgcWq+lRxZVT1EFVNV9V04CPgX6r6SaRiMsaYsrq0byv6pNfj/s8XsmVXjtfheCKSZxhHAZcC/UVkjvt3mohcLSJXR3C+xhgTdjExwqNnd2N/fiF3f7KgWlZNRawDQVX9CQh58G1VvTxSsRhjTDi0Tk3hphMP5ZHxS/hy/iYGdmvmdUgVyu70NsaYUrji6EPo1qIO//10IVnZuV6HU6EsYRhjTCnExcbw2Dnd2JWTx32fL/Q6nAplCcMYY0qpQ5Pa/Pv4dnw6ZyPfLfrD63AqjCUMY4wpg2v6taFDk1rc9cl8du7L8zqcCmEJwxhjyiAhLobHz+nO1j25PPzlYq/DqRCWMIwxpoy6tqjDVce05oMZ6/lxedXvtsgShjHGlMOwE9rROjWZ28fOJ3t/vtfhRJQlDGOMKYfE+FgeO7sbG3fu47Gvl3gdTkRZwjDGmHLKSK/PZUek89ava5m+OsvrcCLGEoYxxoTBrae0J61+TW4bO4+cvAKvw4kISxjGGBMGSQlxjBjSjdVbs3n622VehxMRljCMMSZMjmrbkAsPS+N/P65i7vodXocTdpYwjDEmjO44rSONaiVyy0dz2Z9ftaqmLGEYY0wY1U6M5+EhXVj2xx5enLTS63DCyhKGMcaEWf8OjTmrZ3NemrSCxZv8R6aOXpYwjDEmAu4Z2Im6SfHc8tFc8gsKvQ4nLCxhGGNMBNRLTuCBQV1YsGEXI39c5XU4YWEJwxhjIuTUrk05tUsTnvluOSu27PE6nHKzhGGMMRF036DOJCXEcutHcykojO5xwC1hGGNMBDWqlch/z+jErHU7eOuXNV6HUy6WMIwxJsIG92jO8e1TefybpazbttfrcMrMEoYxxkSYiPDwkK7ExQi3jZ2HanRWTVnCMMaYCtC0Tk3uOK0jv67axujp670Op0wsYRhjTAW58LA0jmzTgIe/WszGHfu8DqfULGEYY0wFERFGDOlGQaFy18fzo65qyhKGMcZUoJYNkrjl5PZMWprJx7M3eB1OqVjCMMaYCnbZken0blWP+z5fxJbdOV6HEzJLGMYYU8FiY4RHz+7GvrwC/vvpQq/DCZklDGOM8UDbRikMO6Ed4xds5usFm7wOJySWMIwxxiNXHdOazs1q859PF7Jzb57X4QQVsYQhImkiMklEFonIQhG5oZgyF4vIPBGZLyK/iEj3SMVjjDGVTXxsDI+e3Y2s7Fwe+mqR1+EEFckzjHxguKp2AvoC14pIJ78yq4HjVLUr8AAwMoLxGGNMpdOleR2uOqY1Y2b8zs8rtnodTokiljBUdZOqznIf7wYWA839yvyiqtvdp1OBFpGKxxhjKqthJ7TjkIbJ3DFuPntz870OJ6AKacMQkXSgJzCthGJXAOMrIh5jjKlMEuNjGTGkK+uy9vLUhGVehxNQxBOGiKQAY4Fhqlrs4LYicjxOwrgtwPtDRWSGiMzIzMyMXLDGGOORw1s34KLDW/LGz6uZu36H1+EUK6IJQ0TicZLFu6o6LkCZbsBrwCBV3VZcGVUdqaoZqpqRmpoauYCNMcZDt5/agUa1Erlt7Dxy8yvfOOCRvEpKgNeBxar6VIAyLYFxwKWqWnnPw4wxpgLUToznwcFdWLJ5N69OXul1OAeJi+C0jwIuBeaLyBz3tTuBlgCq+gpwD9AAeMnJL+SrakYEYzLGmErthE6NGditKc9/v4JTuzahbaNaXof0J4m23hIzMjJ0xowZXodhjDERs3XPfk54ajJtUlP48J9HEBMj5Z6miMws7wG53eltjDGVTMOUGtwzsBMz127n/6au9TqcP1nCMMaYSuisns059tBUHv16Cb9vrxzjgFvCMMaYSkhEePisLgDc9fGCSjHYkiUMY4yppFrUS+LWk9szeVkmn8zxfrAlSxjGGFOJXXpEOr1a1uX+zxexdc9+T2OxhGGMMZVY0WBL2fsLuO9zb3u0tYRhjDGVXLvGtbj2+LZ8PncjExf/4VkcljCMMSYKXNOvDe0b1+KujxewO8ebwZYsYRhjTBRIiIvh0XO6sWV3DiPGL/EkBksYxhgTJXqk1eXvRx3Cu9PWMW1VsX21RpQlDGOMiSLDTzqUtPo1uWPcfHLyCip03pYwjDEmiiQlxPHIWd1YtTWb5yYur9B5W8Iwxpgoc3S7hpzbuwWvTlnFgg07K2y+ljCMMSYK3X16J+onJ3D7uHnkF1TMYEuWMIwxJgrVSYrn/jM7s2DDLl77aXWFzNMShjHGRKlTuzbl5M6NefrbZazemh3x+VnCMMaYKHb/oC4kxMVw+9h5FBZGtkdbSxjGGBPFGtdO5O7TOzJtdRbv/7Y+ovOyhGGMMVHuvIw0jmzTgEe+WszmnTkRm48lDGOMiXIiwiNDupJXWMjdn0RusCVLGMYYUwW0apDM8BPb893iP/hy/qaIzMMShjHGVBF/Pyqdbi3qcO9nC9menRv26VvCMMaYKiIuNoZHz+7Gjr15PPBl+AdbsoRhjDFVSMemtbn6uDaMm7WBycsywzptSxjGGFPF/Lt/W9qkJnPnuPlk788P23QtYRhjTBWTGB/Lo2d3Y+POfTwxYWnYpmsJwxhjqqCM9Ppc2rcVo35Zw8y128MyTUsYxhhTRd16Sgea1k7k9rHzwjI9SxjGGFNFpdSI46EhXVm+ZU9YpmcJwxhjqrDj2zdicI9mYZmWJQxjjKniHjune1imE7GEISJpIjJJRBaJyEIRuaGYMiIiz4nIChGZJyK9IhWPMcZUVwlx4dnVx4VlKsXLB4ar6iwRqQXMFJFvVdX39sNTgXbu3+HAy+5/Y4wxlUzEzjBUdZOqznIf7wYWA839ig0C3lbHVKCuiDSNVEzGGGPKrkLaMEQkHegJTPN7qzngO+LH7xycVBCRoSIyQ0RmZGaG91Z3Y4wxoYl4whCRFGAsMExVd5VlGqo6UlUzVDUjNTU1vAEaY4wJSUQThojE4ySLd1V1XDFFNgBpPs9buK8ZY4ypZCJ5lZQArwOLVfWpAMU+A/7mXi3VF9ipqpEZ+cMYY0y5RPIqqaOAS4H5IjLHfe1OoCWAqr4CfAWcBqwA9gJ/j2A8xhhjykEiNfZrpIhIJrC2AmbVENhaAfOpCFVpWaBqLU9VWhaoWstTlZYFoL2q1irPBCJ5hhERqlohrd4iMkNVMypiXpFWlZYFqtbyVKVlgaq1PFVpWcBZnvJOw7oGMcYYExJLGMYYY0JiCSOwkV4HEEZVaVmgai1PVVoWqFrLU5WWBcKwPFHX6G2MMcYbdoZhjDEmJJYwjDHGhMQShh8RudEdv2OBiIwWkUSvYyoNEXlDRLaIyAKf1+qLyLcistz9X8/LGEsjwPI8LiJL3DFUPhaRuh6GGLLilsXnveEioiLS0IvYyiLQ8ojIde73s1BEHvMqvtIIsJ31EJGpIjLH7fz0MC9jDFWgsYjCsR+whOFDRJoD1wMZqtoFiAUu8DaqUhsFnOL32u3ARFVtB0x0n0eLURy8PN8CXVS1G7AMuKOigyqjURy8LIhIGnASsK6iAyqnUfgtj4gcjzNsQXdV7Qw84UFcZTGKg7+bx4D7VLUHcI/7PBoUjUXUCegLXCsinQjDfsASxsHigJoiEgckARs9jqdUVHUKkOX38iDgLffxW8DgioypPIpbHlWdoKr57tOpOJ1WVnoBvhuAp4Fbgai6AiXA8lwDjFDV/W6ZLRUeWBkEWBYFaruP6xAl+4ISxiIq937AEoYPVd2Ac0S0DtiE0xniBG+jCovGPp06bgYaexlMmP0DGO91EGUlIoOADao61+tYwuRQ4BgRmSYik0Wkj9cBlcMw4HERWY+zX4iWM9k/+Y1FVO79gCUMH26d3iDgEKAZkCwil3gbVXipcx11VB3JBiIid+Gcfr/rdSxlISJJOB1y3uN1LGEUB9THqQq5BRjj9lwdja4BblTVNOBGnN63o0ZJYxGVdT9gCeNAJwCrVTVTVfOAccCRHscUDn8UDX3r/o+KaoKSiMjlwEDgYo3em4na4ByczBWRNThVa7NEpImnUZXP78A4d9jl6UAhTid+0egynH0AwIdAVDR6Q8CxiMq9H7CEcaB1QF8RSXKPigbg1P9Fu89wNn7c/596GEu5icgpOHX+Z6rqXq/jKStVna+qjVQ1XVXTcXa2vVR1s8ehlccnwPEAInIokED09vi6ETjOfdwfWO5hLCErYSyi8u8HVNX+fP6A+4AlwALg/4AaXsdUyvhH47S/5OHsgK4AGuBcFbEc+A6o73Wc5VyeFThjwc9x/17xOs6yLovf+2uAhl7HWc7vJgF4x/39zAL6ex1nOZblaGAmMBenDaC313GGuCxH41Q3zfP5jZwWjv2AdQ1ijDEmJFYlZYwxJiSWMIwxxoTEEoYxxpiQWMIwxhgTEksYxhhjQmIJwxhjTEgsYZioJSIDROSdCphPCxE5332cLiL7RGSO+zxQV9I13W6xc/27LPefhvtaYxF5T0RWichMEflVRM4KEtckETnZ77VhIvJySfM3pqwsYZho1h3npqRIGwD08nm+Up0uryFAV9Kqus8tE6iH0z+n4d6Z+wkwRVVbq2pvnG71g/XCO5qDu9+/ABgdwvyNKTVLGCaadcfph+kQEfnUHeRmuoi0B3AHwPrAfW2tiJxe0sSKKy8iRwNPAee4ZwQH/GY0cFfSpdEfyFXVV3ymu1ZVn/eJ7RI3rjki8qqIxAIfAaeLSIJbJh2n08wfSzl/Y0JiCcNEs6IzjNeAm1Q1A7iXvwaG6Q6sUtXDgIuB/4YwvQPKq+pPwG/AIPeIvTDQh/26ki6NzjjdaASabkfgfOAoN4YCnE4Xs4DpwKlu0QuAMWrdN5gIifM6AGPKwu2Nsw7QD2eHO9btRTsO+FGcoXVTcfoGA1gEBBySMkj59jj9i5UUT8CupEtLRF7E6Q8oV1X74FSJ9QZ+c5exJn/1NFpULfWp+/+K8szbmJJYwjDRqiNO9U934C5VPWCsAhHJAJarao77Ui+cTuQC6VJcebfBeKf+NcLfQQJ0JV0aC4Gzi56o6rXufGcUzQJ4S1WLG8DnU+BpEekFJKnqzDLM35iQWJWUiVbdcRLAJuBkEYkBEJGubiNyd6CliCSKSDLOmcPTQaZXXPl0Smg4LqEr6dL4HkgUkWt8XkvyeTwRpw2lkTvP+iLSCkBV9wCTgDdwzjaMiRhLGCZaFbVfvIGzHS92G6Vvc+vwu+MMfjMNpw3iZVX9Ocj0iiu/BGgoIgtEpLjBtI4CLgX6uw3Sc0TktNIsiBvvYOA4EVktItNxxly+zX1/EXA3MEFE5gHfAk19JjHajd8Shoko697cVEkiMhkYqqpLw1nebdj+QlW7hDjdNUCGqm71ea1U0yiP4uZvTFnZGYapqtpQuhHSQi1fANTxvemuOEU3zgHxHHxlVUjTKI8g8zemTOwMw1QrIlI06pi/Aaq6raLjMSaaWMIwxhgTEquSMsYYExJLGMYYY0JiCcMYY0xILGEYY4wJiSUMY4wxIbGEYYwxJiSWMIwxxoTEEoYxxpiQ/D9feYKUQ77CKQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_SoverB(data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Se hace una copia de la data y se la prepara para el metodo ensamblado AdaBoost" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "data_for_BDT = {} # define empty dictionary to hold dataframes that will be used to train the BDT\n", + "BDT_inputs = ['lep_pt_1','lep_pt_2', 'lep_pt_0', 'lep_pt_3'] # list of features for BDT\n", + "for key in data: # loop over the different keys in the dictionary of dataframes\n", + " data_for_BDT[key] = data[key][BDT_inputs].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['data', 'Background $Z,t\\\\bar{t}$', 'Background $ZZ^*$', 'Signal ($m_H$ = 125 GeV)'])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.keys()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Se establece cuales seran los inputs par el entrenamiento" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "En X se almacenan toda la data proveniente de MC, esto incluye signal and backgrouds \n", + "\n", + "En y se almacenan 0 y 1 dependiento si es background o signal respectivamente" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# for sklearn data is usually organised \n", + "# into one 2D array of shape (n_samples x n_features) \n", + "# containing all the data and one array of categories \n", + "# of length n_samples \n", + "\n", + "all_MC = [] # define empty list that will contain all features for the MC\n", + "for key in data: # loop over the different keys in the dictionary of dataframes\n", + " if key!='data': # only MC should pass this\n", + " all_MC.append(data_for_BDT[key]) # append the MC dataframe to the list containing all MC features\n", + "X = np.concatenate(all_MC) # concatenate the list of MC dataframes into a single 2D array of features, called X\n", + "\n", + "all_y = [] # define empty list that will contain labels whether an event in signal or background\n", + "for key in data: # loop over the different keys in the dictionary of dataframes\n", + " if key!=r'Signal ($m_H$ = 125 GeV)' and key!='data': # only background MC should pass this\n", + " all_y.append(np.zeros(data_for_BDT[key].shape[0])) # background events are labelled with 0\n", + "all_y.append(np.ones(data_for_BDT[r'Signal ($m_H$ = 125 GeV)'].shape[0])) # signal events are labelled with 1\n", + "y = np.concatenate(all_y) # concatenate the list of lables into a single 1D array of labels, called y" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(787422, 4)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Usamos train test split para hacer la división respectiva de la data" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "# make train and test sets\n", + "X_train,X_test, y_train,y_test = train_test_split(X, y, \n", + " test_size=0.33, \n", + " random_state=492 )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Buscamos el max_depth con mejor accuracy " + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time taken to fit BDT: 2069.7s\n", + "Mi árbol da un accuracy de: 0.7208697325380027 cuando su max_depth es: 1\n", + "Time taken to fit BDT: 2069.7s\n", + "Mi árbol da un accuracy de: 0.7623051760631133 cuando su max_depth es: 2\n", + "Time taken to fit BDT: 2069.7s\n", + "Mi árbol da un accuracy de: 0.7623936886665383 cuando su max_depth es: 3\n", + "Time taken to fit BDT: 2069.7s\n", + "Mi árbol da un accuracy de: 0.7664075428131615 cuando su max_depth es: 4\n", + "Time taken to fit BDT: 2069.7s\n", + "Mi árbol da un accuracy de: 0.7749009043679046 cuando su max_depth es: 5\n", + "Time taken to fit BDT: 2069.7s\n", + "Mi árbol da un accuracy de: 0.7758668462574563 cuando su max_depth es: 6\n", + "Time taken to fit BDT: 2069.7s\n", + "Mi árbol da un accuracy de: 0.7783413507792958 cuando su max_depth es: 7\n", + "Time taken to fit BDT: 2069.7s\n", + "Mi árbol da un accuracy de: 0.7773292284010006 cuando su max_depth es: 8\n", + "Time taken to fit BDT: 2069.7s\n", + "Mi árbol da un accuracy de: 0.7777256109293823 cuando su max_depth es: 9\n" + ] + } + ], + "source": [ + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn.ensemble import AdaBoostClassifier\n", + "from sklearn.metrics import accuracy_score\n", + "\n", + "for i in range(1,10):\n", + " dt = DecisionTreeClassifier(max_depth=i) # maximum depth of the tree\n", + " bdt = AdaBoostClassifier(dt,\n", + " algorithm='SAMME', # SAMME discrete boosting algorithm\n", + " n_estimators=12, # max number of estimators at which boosting is terminated\n", + " learning_rate=0.5) # shrinks the contribution of each classifier by learning_rate\n", + " bdt.fit(X_train, y_train)\n", + "\n", + " y_pred = bdt.predict(X_test)\n", + " print(\"Time taken to fit BDT: \"+str(round(elapsed,1))+\"s\") # print total time taken to fit BDT\n", + " print(\"Mi árbol da un accuracy de:\", accuracy_score(y_test,y_pred), \"cuando su max_depth es: \", i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SE entrena con un max_depth 7" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time taken to fit BDT: 70.8s\n", + "AdaBoostClassifier(algorithm='SAMME',\n", + " base_estimator=DecisionTreeClassifier(ccp_alpha=0.0,\n", + " class_weight=None,\n", + " criterion='gini',\n", + " max_depth=7,\n", + " max_features=None,\n", + " max_leaf_nodes=None,\n", + " min_impurity_decrease=0.0,\n", + " min_impurity_split=None,\n", + " min_samples_leaf=1,\n", + " min_samples_split=2,\n", + " min_weight_fraction_leaf=0.0,\n", + " presort='deprecated',\n", + " random_state=None,\n", + " splitter='best'),\n", + " learning_rate=0.5, n_estimators=12, random_state=None)\n" + ] + } + ], + "source": [ + "dt = DecisionTreeClassifier(max_depth=7) # maximum depth of the tree\n", + "bdt = AdaBoostClassifier(dt,\n", + " algorithm='SAMME', # SAMME discrete boosting algorithm\n", + " n_estimators=12, # max number of estimators at which boosting is terminated\n", + " learning_rate=0.5) # shrinks the contribution of each classifier by learning_rate\n", + "\n", + "start = time.time() # time at start of BDT fit\n", + "bdt.fit(X_train, y_train) # fit BDT to training set\n", + "elapsed = time.time() - start # time after fitting BDT\n", + "print(\"Time taken to fit BDT: \"+str(round(elapsed,1))+\"s\") # print total time taken to fit BDT\n", + "print(bdt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Metricas para test_data" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " background 0.82 0.79 0.81 152635\n", + " signal 0.72 0.76 0.74 107215\n", + "\n", + " accuracy 0.78 259850\n", + " macro avg 0.77 0.78 0.77 259850\n", + "weighted avg 0.78 0.78 0.78 259850\n", + "\n", + "Area under ROC curve for test data: 0.8437\n" + ] + } + ], + "source": [ + "from sklearn.metrics import classification_report, roc_auc_score\n", + "y_predicted = bdt.predict(X_test) # get predicted y for test set\n", + "print (classification_report(y_test, y_predicted,\n", + " target_names=[\"background\", \"signal\"]))\n", + "print (\"Area under ROC curve for test data: %.4f\"%(roc_auc_score(y_test,\n", + " bdt.decision_function(X_test))) )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Metricas para train_data" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " background 0.83 0.79 0.81 309181\n", + " signal 0.72 0.76 0.74 218391\n", + "\n", + " accuracy 0.78 527572\n", + " macro avg 0.78 0.78 0.78 527572\n", + "weighted avg 0.78 0.78 0.78 527572\n", + "\n", + "Area under ROC curve for training data: 0.8483\n" + ] + } + ], + "source": [ + "y_predicted = bdt.predict(X_train) # get predicted y for train set\n", + "print (classification_report(y_train, y_predicted,\n", + " target_names=[\"background\", \"signal\"]))\n", + "print (\"Area under ROC curve for training data: %.4f\"%(roc_auc_score(y_train,\n", + " bdt.decision_function(X_train))))" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# we first plot the Neural Network output\n", + "signal_decisions = bdt.decision_function(X[y>0.5]).ravel() # get probabilities on signal\n", + "background_decisions = bdt.decision_function(X[y<0.5]).ravel() # get decisions on background\n", + "\n", + "plt.hist(background_decisions, color='red', label='background', \n", + " histtype='step', # lineplot that's unfilled\n", + " density=True ) # normalize to form a probability density\n", + "plt.hist(signal_decisions, color='blue', label='signal', \n", + " histtype='step', # lineplot that's unfilled\n", + " density=True, # normalize to form a probability density\n", + " linestyle='--' ) # dashed line\n", + "plt.xlabel('BDT output') # add x-axis label\n", + "plt.ylabel('Arbitrary units') # add y-axis label\n", + "plt.legend() # add legend\n", + "\n", + "\n", + "# we then plot the ROC\n", + "plt.figure() # make new figure \n", + "\n", + "from sklearn.metrics import roc_curve, auc\n", + "\n", + "decisions = bdt.decision_function(X_test).ravel() # get probabilities on test set\n", + "\n", + "# Compute ROC curve and area under the curve\n", + "fpr, tpr, _ = roc_curve(y_test, # actual\n", + " decisions ) # predicted\n", + "\n", + "# Compute area under the curve for training set\n", + "roc_auc = auc(fpr, # false positive rate \n", + " tpr) # true positive rate\n", + "\n", + "plt.plot(fpr, tpr, label='ROC (area = %0.2f)'%(roc_auc)) # plot test ROC curve\n", + "plt.plot([0, 1], # x from 0 to 1\n", + " [0, 1], # y from 0 to 1\n", + " '--', # dashed line\n", + " color='grey', label='Luck')\n", + "\n", + "plt.xlabel('False Positive Rate') # x-axis label\n", + "plt.ylabel('True Positive Rate') # y-axis label\n", + "plt.title('Receiver operating characteristic (ROC) curve') # title\n", + "plt.legend() # add legend\n", + "plt.grid() # add grid" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### histograma construido en base a las probabilidades de ser signal o background y usado para comparar train con test" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def compare_train_test(clf, X_train, y_train, X_test, y_test):\n", + " decisions = [] # list to hold decisions of classifier\n", + " for X,y in ((X_train, y_train), (X_test, y_test)): # train and test\n", + " d1 = clf.decision_function(X[y<0.5]).ravel() # background\n", + " d2 = clf.decision_function(X[y>0.5]).ravel() # signal\n", + " decisions += [d1, d2] # add to list of classifier decision\n", + " \n", + " highest_decision = max(np.max(d) for d in decisions) # get maximum score\n", + " bin_edges = [] # list to hold bin edges\n", + " bin_edge = -1.1 # start counter for bin_edges\n", + " while bin_edge < highest_decision: # up to highest score\n", + " bin_edge += 0.1 # increment\n", + " bin_edges.append(bin_edge)\n", + " \n", + " plt.hist(decisions[0], # background in train set\n", + " bins=bin_edges, # lower and upper range of the bins\n", + " density=True, # area under the histogram will sum to 1\n", + " histtype='stepfilled', # lineplot that's filled\n", + " color='red', label='B (train)', # Background (train)\n", + " alpha=0.5 ) # half transparency\n", + " plt.hist(decisions[1], # background in train set\n", + " bins=bin_edges, # lower and upper range of the bins\n", + " density=True, # area under the histogram will sum to 1\n", + " histtype='stepfilled', # lineplot that's filled\n", + " color='blue', label='S (train)', # Signal (train)\n", + " alpha=0.5 ) # half transparency\n", + "\n", + " hist_background, bin_edges = np.histogram(decisions[2], # background test\n", + " bins=bin_edges, # number of bins in function definition\n", + " density=True ) # area under the histogram will sum to 1\n", + " \n", + " scale = len(decisions[2]) / sum(hist_background) # between raw and normalised\n", + " err_background = np.sqrt(hist_background * scale) / scale # error on test background\n", + "\n", + " width = 0.1 # histogram bin width\n", + " center = (bin_edges[:-1] + bin_edges[1:]) / 2 # bin centres\n", + " \n", + " plt.errorbar(x=center, y=hist_background, yerr=err_background, fmt='o', # circles\n", + " c='red', label='B (test)' ) # Background (test)\n", + " \n", + " hist_signal, bin_edges = np.histogram(decisions[3], # siganl test\n", + " bins=bin_edges, # number of bins in function definition\n", + " density=True ) # area under the histogram will sum to 1\n", + " scale = len(decisions[3]) / sum(hist_signal) # between raw and normalised\n", + " err_signal = np.sqrt(hist_signal * scale) / scale # error on test background\n", + " \n", + " plt.errorbar(x=center, y=hist_signal, yerr=err_signal, fmt='o', # circles\n", + " c='blue', label='S (test)' ) # Signal (test)\n", + " \n", + " plt.xlabel(\"BDT output\") # write x-axis label\n", + " plt.ylabel(\"Arbitrary units\") # write y-axis label\n", + " plt.legend() # add legend\n", + " \n", + "compare_train_test(bdt, X_train, y_train, X_test, y_test) # call compare_train_test" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-0.76979747, 0.04682479, 0.3681577 , ..., 0.12596993,\n", + " 0.8307519 , 0.80869312])" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_predicted = bdt.decision_function(X)\n", + "y_predicted" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "entry\n", + "3 -0.769797\n", + "11 0.046825\n", + "14 0.368158\n", + "16 -0.024561\n", + "17 -0.806111\n", + " ... \n", + "899 0.060281\n", + "902 0.539441\n", + "904 0.062948\n", + "905 0.227023\n", + "906 0.549131\n", + "Name: BDT_output, Length: 731, dtype: float64\n", + "entry\n", + "0 -1.000000\n", + "1 0.652437\n", + "2 -1.000000\n", + "3 0.596184\n", + "4 -0.943748\n", + " ... \n", + "487760 -1.000000\n", + "487761 -0.862027\n", + "487762 -1.000000\n", + "487763 -1.000000\n", + "487764 -0.290415\n", + "Name: BDT_output, Length: 461085, dtype: float64\n", + "entry\n", + "0 0.600798\n", + "1 0.632055\n", + "2 0.345057\n", + "3 0.596520\n", + "4 -0.220235\n", + " ... \n", + "12738 0.497827\n", + "12739 -1.000000\n", + "12741 0.125970\n", + "12744 0.830752\n", + "12745 0.808693\n", + "Name: BDT_output, Length: 325606, dtype: float64\n" + ] + } + ], + "source": [ + "cumulative_events = 0 # start counter for total number of events for which output is saved\n", + "for key in data: # loop over samples\n", + " if key != 'data':\n", + " data[key]['BDT_output'] = y_predicted[cumulative_events:cumulative_events+len(data[key])]\n", + " cumulative_events += len(data[key]) # increment counter for total number of events\n", + " print(data[key]['BDT_output']) # print the dataframe column BDT_output" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "BDT_output = { # dictionary containing plotting parameters for the mllll histogram\n", + " # change plotting parameters\n", + " 'bin_width':0.1, # width of each histogram bin\n", + " 'num_bins':14, # number of histogram bins\n", + " 'xrange_min':-1, # minimum on x-axis\n", + " 'xlabel':'BDT output', # x-axis label\n", + "}\n", + "\n", + "SoverB_hist_dict = {'BDT_output':BDT_output}" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_SoverB(data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Quiero volver a entrenar pero esta vez con la data experimental usando el aprendizaje del entrenamiento previo con el MC" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Preparon la data_Exp" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "all_data = [] # define empty list that will contain all features for the MC\n", + "for key in data: # loop over the different keys in the dictionary of dataframes\n", + " if key =='data': # only MC should pass this\n", + " all_data.append(data_for_BDT[key]) # append the MC dataframe to the list containing all MC features\n", + "data_exp = np.concatenate(all_data) # concatenate the list of MC dataframes into a single 2D array of features, called X" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Obtengo predicciones para data_exp" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "y_predicted_data = bdt.predict(data_exp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Grafico los histogramas para comparar, pero no obtengo lo que esperaba :((" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7f23bb593b70>" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# we first plot the Neural Network output\n", + "signal_decisions = bdt.decision_function(data_exp) # get probabilities on signal\n", + "background_decisions = bdt.decision_function(data_exp) # get decisions on background\n", + "\n", + "plt.hist(background_decisions[y_predicted_data < 0.5], color='red', label='background', \n", + " histtype='step', # lineplot that's unfilled\n", + " density=True ) # normalize to form a probability density\n", + "plt.hist(signal_decisions[y_predicted_data > 0.5], color='blue', label='signal', \n", + " histtype='step', # lineplot that's unfilled\n", + " density=True, # normalize to form a probability density\n", + " linestyle='--' ) # dashed line\n", + "plt.xlabel('BDT output') # add x-axis label\n", + "plt.ylabel('Arbitrary units') # add y-axis label\n", + "plt.legend() # add legend" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/codigo/__pycache__/infofile.cpython-36.pyc b/codigo/__pycache__/infofile.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d7d02a7a52cce301fe9609c775f3da7c86667303 Binary files /dev/null and b/codigo/__pycache__/infofile.cpython-36.pyc differ diff --git a/codigo/infofile.py b/codigo/infofile.py new file mode 100644 index 0000000000000000000000000000000000000000..103ac8109d21fb02abdb7ab9e6046e76a5a5ab5b --- /dev/null +++ b/codigo/infofile.py @@ -0,0 +1,2507 @@ +infos = { + + # ZPrime -> ee + + 'ZPrime2000_ee': {'DSID' : 301215, + 'events' : 19800, + 'red_eff' :1, + 'sumw' :19800, + 'xsec' :0.0088432}, + + 'ZPrime3000_ee': {'DSID' : 301216, + 'events' : 19600, + 'red_eff' :1, + 'sumw' :19600, + 'xsec' :0.00080617}, + + 'ZPrime4000_ee': {'DSID' : 301217, + 'events' : 19800, + 'red_eff' :1, + 'sumw' :19800, + 'xsec' :0.00010351}, + + 'ZPrime5000_ee': {'DSID' : 301218, + 'events' : 18000, + 'red_eff' :1, + 'sumw' :18000, + 'xsec' :0.000018319}, + + + # ZPrime -> mumu 2lep + + 'ZPrime2000_mumu': {'DSID' : 301220, + 'events' : 983000, + 'red_eff' :1, + 'sumw' :983000, + 'xsec' :0.0088801}, + + 'ZPrime3000_mumu': {'DSID' : 301221, + 'events' : 988000, + 'red_eff' :1, + 'sumw' :988000, + 'xsec' :0.00080295}, + + 'ZPrime4000_mumu': {'DSID' : 301222, + 'events' : 986000, + 'red_eff' :1, + 'sumw' :986000, + 'xsec' :0.00010332}, + + 'ZPrime5000_mumu': {'DSID' : 1, + 'events' : 999000, + 'red_eff' :1, + 'sumw' :999000, + 'xsec' :0.000018334}, + + + # ZPrime -> tt + + 'ZPrime400_tt': {'DSID' : 301322, + 'events' : 199200, + 'red_eff' : 1, + 'sumw' : 199200, + 'xsec' : 8.9857}, + + 'ZPrime500_tt': {'DSID' : 301323, + 'events' : 199600, + 'red_eff' : 1, + 'sumw' : 199600, + 'xsec' : 8.7385}, + + 'ZPrime750_tt': {'DSID' : 301324, + 'events' : 199000, + 'red_eff' : 1, + 'sumw' : 199000, + 'xsec' : 3.1201}, + + 'ZPrime1000_tt': {'DSID' : 301325, + 'events' : 199800, + 'red_eff' : 1, + 'sumw' : 199800, + 'xsec' : 1.1261}, + + 'ZPrime1250_tt': {'DSID' : 301326, + 'events' : 199200, + 'red_eff' : 1, + 'sumw' : 199200, + 'xsec' : 0.45981}, + + 'ZPrime1500_tt': {'DSID' : 301327, + 'events' : 198800, + 'red_eff' : 1, + 'sumw' : 198800, + 'xsec' : 0.20685}, + + 'ZPrime1750_tt': {'DSID' : 301328, + 'events' : 199800, + 'red_eff' : 1, + 'sumw' : 199800, + 'xsec' : 0.10016}, + + 'ZPrime2000_tt': {'DSID' : 301329, + 'events' : 199800, + 'red_eff' : 1, + 'sumw' : 199800, + 'xsec' : 0.051346}, + + 'ZPrime2250_tt': {'DSID' : 301330, + 'events' : 199200, + 'red_eff' : 1, + 'sumw' : 199200, + 'xsec' : 0.027481}, + + 'ZPrime2500_tt': {'DSID' : 301331, + 'events' : 198200, + 'red_eff' : 1, + 'sumw' : 198200, + 'xsec' : 0.015226}, + + 'ZPrime2750_tt': {'DSID' : 301332, + 'events' : 199800, + 'red_eff' : 1, + 'sumw' : 199800, + 'xsec' : 0.0086884}, + + 'ZPrime3000_tt': {'DSID' : 301333, + 'events' : 195800, + 'red_eff' : 1, + 'sumw' : 195800, + 'xsec' : 0.0050843}, + + + # Graviton + + 'RS_G_ZZ_llll_c10_m0200': {'DSID' : 307431, + 'events' : 29000, + 'red_eff' : 1, + 'sumw' : 29000, + 'xsec' : 1.86}, + + 'RS_G_ZZ_llll_c10_m0500': {'DSID' : 307434, + 'events' : 27000, + 'red_eff' : 1, + 'sumw' : 27000, + 'xsec' : 0.02373}, + + 'RS_G_ZZ_llll_c10_m1000': {'DSID' : 303329, + 'events' : 3000, + 'red_eff' : 1, + 'sumw' : 3000, + 'xsec' : 0.0004122}, + + 'RS_G_ZZ_llll_c10_m1500': {'DSID' : 307439, + 'events' : 30000, + 'red_eff' : 1, + 'sumw' : 30000, + 'xsec' : 0.00003702}, + + 'RS_G_ZZ_llll_c10_m2000': {'DSID' : 303334, + 'events' : 5000, + 'red_eff' : 1, + 'sumw' : 5000, + 'xsec' : 0.0000057}, + + + # Mono Z + + 'dmV_Zll_MET40_DM1_MM10': {'DSID' : 303511, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10000, + 'xsec' : 11.55}, + + 'dmV_Zll_MET40_DM1_MM100': {'DSID' : 303512, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10000, + 'xsec' : 0.4682}, + + 'dmV_Zll_MET40_DM1_MM200': {'DSID' : 306085, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10000, + 'xsec' : 0.1424}, + + 'dmV_Zll_MET40_DM1_MM300': {'DSID' : 303513, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10000, + 'xsec' : 0.063965}, + + 'dmV_Zll_MET40_DM1_MM400': {'DSID' : 306093, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10000, + 'xsec' : 0.031865}, + + 'dmV_Zll_MET40_DM1_MM500': {'DSID' : 305710, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10000, + 'xsec' : 0.018275}, + + 'dmV_Zll_MET40_DM1_MM600': {'DSID' : 306103, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10000, + 'xsec' : 0.01136}, + + 'dmV_Zll_MET40_DM1_MM700': {'DSID' : 305711, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10000, + 'xsec' : 0.007416}, + + 'dmV_Zll_MET40_DM1_MM800': {'DSID' : 306109, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10000, + 'xsec' : 0.005016}, + + 'dmV_Zll_MET40_DM1_MM2000': {'DSID' : 303514, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10000, + 'xsec' : 0.0001636}, + + + # gluino-gluino -> stop-stop -> tttt + DM + + 'GG_ttn1_1200_5000_1': {'DSID' : 370114, + 'events' : 100000, + 'red_eff' : 1, + 'sumw' : 101591.347734, + 'xsec' : 0.057037}, + + 'GG_ttn1_1200_5000_600': {'DSID' : 370118, + 'events' : 100000, + 'red_eff' : 1, + 'sumw' : 101591.282303, + 'xsec' : 0.057002}, + + 'GG_ttn1_1400_5000_1': {'DSID' : 370129, + 'events' : 100000, + 'red_eff' : 1, + 'sumw' : 101197.830825, + 'xsec' : 0.015756}, + + 'GG_ttn1_1600_5000_1': {'DSID' : 370144, + 'events' : 99000, + 'red_eff' : 1, + 'sumw' : 99850.3055654, + 'xsec' : 0.004747}, + + + # stop-stop -> tt + DM + + 'TT_directTT_450_1': {'DSID' : 388240, + 'events' : 50000, + 'red_eff' : 1, + 'sumw' : 52247.301193, + 'xsec' : 0.88424}, + + 'TT_directTT_500_1': {'DSID' : 387154, + 'events' : 20000, + 'red_eff' : 1, + 'sumw' : 20793.7352104, + 'xsec' : 0.46603}, + + 'TT_directTT_500_200': {'DSID' : 387157, + 'events' : 50000, + 'red_eff' : 1, + 'sumw' : 51998.4134001, + 'xsec' : 0.46702}, + + 'TT_directTT_600_1': {'DSID' : 387163, + 'events' : 49000, + 'red_eff' : 1, + 'sumw' : 50709.6451392, + 'xsec' : 0.15518}, + + + # chargino-neutralino -> WZ(->lvll) + + 'C1N2_WZ_100p0_0p0_3L_2L7': {'DSID' : 392226, + 'events' : 20000, + 'red_eff' : 1, + 'sumw' : 21798.5046117, + 'xsec' : 15.82879625}, + + 'C1N2_WZ_350p0_0p0_3L_2L7': {'DSID' : 392220, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10346.0705611, + 'xsec' : 0.1418528975}, + + 'C1N2_WZ_400p0_0p0_3L_2L7': {'DSID' : 392217, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10327.8154224, + 'xsec' : 0.080689712}, + + 'C1N2_WZ_500p0_0p0_3L_2L7': {'DSID' : 392223, + 'events' : 5000, + 'red_eff' : 1, + 'sumw' : 5130.27250254, + 'xsec' : 0.0301334215}, + + + # chargino-neutralino -> WZ(->qqll) + + 'C1N2_WZ_500p0_100p0_2L2J_2L7': {'DSID' : 392302, + 'events' : 5000, + 'red_eff' : 1, + 'sumw' : 5123.94193453, + 'xsec' : 0.025481788}, + + 'C1N2_WZ_300p0_100p0_2L2J_2L7': {'DSID' : 392304, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10419.6442093, + 'xsec' : 0.2182152585}, + + 'C1N2_WZ_300p0_200p0_2L2J_2L7': {'DSID' : 392308, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10414.1419529, + 'xsec' : 0.218912097}, + + 'C1N2_WZ_400p0_0p0_2L2J_2L7': {'DSID' : 392317, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10324.0226582, + 'xsec' : 0.068632923}, + + 'C1N2_WZ_500p0_0p0_2L2J_2L7': {'DSID' : 392323, + 'events' : 5000, + 'red_eff' : 1, + 'sumw' : 5135.2308228, + 'xsec' : 0.0257187712}, + + 'C1N2_WZ_400p0_300p0_2L2J_2L7': {'DSID' : 392324, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10318.5426682, + 'xsec' : 0.067068856}, + + 'C1N2_WZ_100p0_0p0_2L2J_2L7': {'DSID' : 392326, + 'events' : 20000, + 'red_eff' : 1, + 'sumw' : 21807.0756063, + 'xsec' : 12.3557577}, + + 'C1N2_WZ_200p0_100p0_2L2J_2L7': {'DSID' : 392330, + 'events' : 20000, + 'red_eff' : 1, + 'sumw' : 21100.6583921, + 'xsec' : 0.3120280476}, + + 'C1N2_WZ_500p0_300p0_2L2J_2L7': {'DSID' : 392332, + 'events' : 5000, + 'red_eff' : 1, + 'sumw' : 5136.04743809, + 'xsec' : 0.0255630137}, + + 'C1N2_WZ_600_100_2L2J_2L7': {'DSID' : 392354, + 'events' : 5000, + 'red_eff' : 1, + 'sumw' : 5130.17177922, + 'xsec' : 0.0110981746}, + + 'C1N2_WZ_600_0_2L2J_2L7': {'DSID' : 392356, + 'events' : 5000, + 'red_eff' : 1, + 'sumw' : 5115.96802914, + 'xsec' : 0.01106208}, + + 'C1N2_WZ_700_400_2L2J_2L7': {'DSID' : 392361, + 'events' : 4000, + 'red_eff' : 1, + 'sumw' : 4069.40415132, + 'xsec' : 0.00518059472}, + + 'C1N2_WZ_700_100_2L2J_2L7': {'DSID' : 392364, + 'events' : 5000, + 'red_eff' : 1, + 'sumw' : 5093.62593496, + 'xsec' : 0.00511756038}, + + 'C1N2_WZ_700_0_2L2J_2L7': {'DSID' : 392365, + 'events' : 5000, + 'red_eff' : 1, + 'sumw' : 5100.51524758, + 'xsec' : 0.0052089336}, + + + # chargino-chargino + + 'C1C1_SlepSnu_x0p50_200p0_100p0_2L8': {'DSID' : 392501, + 'events' : 25000, + 'red_eff' : 1, + 'sumw' : 26095.2892522, + 'xsec' : 0.438382903}, + + 'C1C1_SlepSnu_x0p50_200p0_150p0_2L8': {'DSID' : 392502, + 'events' : 14000, + 'red_eff' : 1, + 'sumw' : 14610.1961992, + 'xsec' : 0.3788318576}, + + 'C1C1_SlepSnu_x0p50_300p0_100p0_2L8': {'DSID' : 392504, + 'events' : 24000, + 'red_eff' : 1, + 'sumw' : 24769.4974021, + 'xsec' : 0.0999784056}, + + 'C1C1_SlepSnu_x0p50_300p0_250p0_2L8': {'DSID' : 392506, + 'events' : 14000, + 'red_eff' : 1, + 'sumw' : 14461.581905, + 'xsec' : 0.080525632}, + + 'C1C1_SlepSnu_x0p50_400p0_100p0_2L8': {'DSID' : 392507, + 'events' : 25000, + 'red_eff' : 1, + 'sumw' : 25655.2504594, + 'xsec' : 0.0311401198}, + + 'C1C1_SlepSnu_x0p50_400p0_300p0_2L8': {'DSID' : 392509, + 'events' : 25000, + 'red_eff' : 1, + 'sumw' : 25632.581066, + 'xsec' : 0.0285856272}, + + 'C1C1_SlepSnu_x0p50_500p0_300p0_2L8': {'DSID' : 392513, + 'events' : 25000, + 'red_eff' : 1, + 'sumw' : 25567.3058318, + 'xsec' : 0.0114399795}, + + 'C1C1_SlepSnu_x0p50_600p0_300p0_2L8': {'DSID' : 392517, + 'events' : 25000, + 'red_eff' : 1, + 'sumw' : 25472.8026792, + 'xsec' : 0.004885755904}, + + 'C1C1_SlepSnu_x0p50_700p0_1p0_2L8': {'DSID' : 392518, + 'events' : 25000, + 'red_eff' : 1, + 'sumw' : 25410.7097093, + 'xsec' : 0.00231816666}, + + 'C1C1_SlepSnu_x0p50_700p0_300p0_2L8': {'DSID' : 392521, + 'events' : 25000, + 'red_eff' : 1, + 'sumw' : 25397.7880948, + 'xsec' : 0.002285652872}, + + + # slepton + + 'SlepSlep_direct_100p5_1p0_2L8': {'DSID' : 392916, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 12744.8491732, + 'xsec' : 0.806723}, + + 'SlepSlep_direct_200p5_1p0_2L8': {'DSID' : 392918, + 'events' : 8000, + 'red_eff' : 1, + 'sumw' : 9384.14328927, + 'xsec' : 0.06466635}, + + 'SlepSlep_direct_300p5_1p0_2L8': {'DSID' : 392920, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 11199.5583518, + 'xsec' : 0.01244275305}, + + 'SlepSlep_direct_500p5_1p0_2L8': {'DSID' : 392924, + 'events' : 9000, + 'red_eff' : 1, + 'sumw' : 9692.91836751, + 'xsec' : 0.001223162955}, + + 'SlepSlep_direct_100p0_50p0_2L8': {'DSID' : 392925, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 12817.7130976, + 'xsec' : 0.81656133}, + + 'SlepSlep_direct_200p0_100p0_2L8': {'DSID' : 392936, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 11683.0100918, + 'xsec' : 0.064644393}, + + 'SlepSlep_direct_500p0_100p0_2L8': {'DSID' : 392942, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10774.6592166, + 'xsec' : 0.001229322225}, + + 'SlepSlep_direct_300p0_200p0_2L8': {'DSID' : 392951, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 11237.8868441, + 'xsec' : 0.01243520595}, + + 'SlepSlep_direct_400p0_300p0_2L8': {'DSID' : 392962, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10944.9245315, + 'xsec' : 0.0034380269}, + + 'SlepSlep_direct_500p0_300p0_2L8': {'DSID' : 392964, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10772.8356151, + 'xsec' : 0.00121170732}, + + 'SlepSlep_direct_600p0_1p0_2L8': {'DSID' : 392982, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10448.2514935, + 'xsec' : 0.0004647888015}, + + 'SlepSlep_direct_600p0_300p0_2L8': {'DSID' : 392985, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10457.5703245, + 'xsec' : 0.000464769511}, + + 'SlepSlep_direct_700p0_1p0_2L8': {'DSID' : 392996, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10367.2338168, + 'xsec' : 0.000204735222}, + + 'SlepSlep_direct_700p0_300p0_2L8': {'DSID' : 392999, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10370.1994236, + 'xsec' : 0.000204884372}, + + 'ttH125_gamgam': {'DSID' : 341081, + 'events' : 927400, + 'red_eff' : 1, + 'sumw' : 485440, + 'xsec' : 0.0000026433864}, + + 'ggH125_gamgam': {'DSID' : 343981, + 'events' : 1976000, + 'red_eff' : 1, + 'sumw' : 55922617.6297, + 'xsec' : 0.102}, + + 'VBFH125_gamgam': {'DSID' : 345041, + 'events' : 921000, + 'red_eff' : 1, + 'sumw' : 3441426.13711, + 'xsec' : 0.008518764}, + + 'WpH125J_Wincl_gamgam': {'DSID' : 345318, + 'events' : 248000, + 'red_eff' : 1, + 'sumw' : 213799.958463, + 'xsec' : 0.0019654512}, + + 'ZH125J_Zincl_gamgam': {'DSID' : 345319, + 'events' : 471000, + 'red_eff' : 1, + 'sumw' : 358401.082034, + 'xsec' : 0.0017347836}, + + 'ggH125_tautaull':{'DSID':341122, + 'events':1522300, + 'red_eff':1, + 'sumw':20207228.675, + 'xsec':0.3407921994}, + + 'VBFH125_tautaull':{'DSID':341155, + 'events':2078800, + 'red_eff':1, + 'sumw':2078800, + 'xsec':0.02906767389}, + + 'ggH125_tautaulh': {'DSID' : 341123, + 'events' : 1446900, + 'red_eff' : 1, + 'sumw' : 46547831.1387, + 'xsec' : 1.262373851}, + + 'VBFH125_tautaulh': {'DSID' : 341156, + 'events' : 2087900, + 'red_eff' : 1, + 'sumw' : 2087900, + 'xsec' : 0.1078731107}, + + 'ZH125_ZZ4lep':{'DSID':341947, + 'events':150000, + 'red_eff':1, + 'sumw':150000, + 'xsec':0.0000021424784}, + + 'WH125_ZZ4lep':{'DSID':341964, + 'events':149400, + 'red_eff':1, + 'sumw':149400, + 'xsec':0.0003769}, + + 'VBFH125_ZZ4lep':{'DSID':344235, + 'events':985000, + 'red_eff':1, + 'sumw':3680490.83243, + 'xsec':0.0004633012}, + + 'ggH125_ZZ4lep':{'DSID':345060, + 'events':985000, + 'red_eff':1, + 'sumw':27881776.6536, + 'xsec':0.0060239}, + + 'VBFH125_WW2lep':{'DSID':345323, + 'events':1175000, + 'red_eff':1, + 'sumw':4389990.08913, + 'xsec':0.02020229148}, + + 'ggH125_WW2lep':{'DSID':345324, + 'events':1972000, + 'red_eff':1, + 'sumw':55832659.6908, + 'xsec':0.1481173588}, + + 'WpH125J_qqWW2lep':{'DSID':345325, + 'events':246000, + 'red_eff':1, + 'sumw':212083.006669, + 'xsec':0.009137412}, + + 'WpH125J_lvWW2lep':{'DSID':345327, + 'events':99000, + 'red_eff':1, + 'sumw':27654.9427524, + 'xsec':0.002953584}, + + 'ZH125J_qqWW2lep':{'DSID':345336, + 'events':245000, + 'red_eff':1, + 'sumw':186418.164907, + 'xsec':0.008065858}, + + 'ZH125J_llWW2lep':{'DSID':345337, + 'events':297000, + 'red_eff':1, + 'sumw':22685.3119437, + 'xsec':0.0008078684}, + + 'ZH125J_vvWW2lep':{'DSID':345445, + 'events':198000, + 'red_eff':1, + 'sumw':29701.769871, + 'xsec':0.00159106}, + + 'Zee_PTV0_70_CVetoBVeto': {'DSID' : 364114, + 'events' :7900000, + 'red_eff' :1, + 'sumw' :5307644.52827, + 'xsec' :1587.021595}, + + 'Zee_PTV0_70_CFilterBVeto': {'DSID' : 364115, + 'events' :4940500, + 'red_eff' :1, + 'sumw' :2839137.81561, + 'xsec' :219.9958116}, + + 'Zee_PTV0_70_BFilter': {'DSID' : 364116, + 'events' :7883600, + 'red_eff' :1, + 'sumw' :4053053.52848, + 'xsec' :127.0857614}, + + 'Zee_PTV70_140_CVetoBVeto': {'DSID' : 364117, + 'events' :5885000, + 'red_eff' :1, + 'sumw' :2149611.09271, + 'xsec' :74.90381742}, + + 'Zee_PTV70_140_CFilterBVeto': {'DSID' : 364118, + 'events' :1972600, + 'red_eff' :1, + 'sumw' :715162.089738, + 'xsec' :20.3159891}, + + 'Zee_PTV70_140_BFilter': {'DSID' : 364119, + 'events' :5855000, + 'red_eff' :1, + 'sumw' :2043192.28295, + 'xsec' :12.73880801}, + + 'Zee_PTV140_280_CVetoBVeto': {'DSID' : 364120, + 'events' :4949000, + 'red_eff' :1, + 'sumw' :2966342.61469, + 'xsec' :24.44184978}, + + 'Zee_PTV140_280_CFilterBVeto': {'DSID' : 364121, + 'events' :2922600, + 'red_eff' :1, + 'sumw' :1949820.29674, + 'xsec' :9.237605979}, + + 'Zee_PTV140_280_BFilter': {'DSID' : 364122, + 'events' :12010900, + 'red_eff' :1, + 'sumw' :8328729.48708, + 'xsec' :6.081254464}, + + 'Zee_PTV280_500_CVetoBVeto': {'DSID' : 364123, + 'events' :1932800, + 'red_eff' :1, + 'sumw' :1665734.2346, + 'xsec' :4.796836771}, + + 'Zee_PTV280_500_CFilterBVeto': {'DSID' : 364124, + 'events' :988900, + 'red_eff' :1, + 'sumw' :908261.497964, + 'xsec' :2.249186051}, + + 'Zee_PTV280_500_BFilter': {'DSID' : 364125, + 'events' :1976850, + 'red_eff' :1, + 'sumw' :1854184.55614, + 'xsec' :1.49219843}, + + 'Zee_PTV500_1000': {'DSID' : 364126, + 'events' :2973000, + 'red_eff' :1, + 'sumw' :2942740.91362, + 'xsec' :1.76415092}, + + 'Zee_PTV1000_E_CMS': {'DSID' : 364127, + 'events' :988000, + 'red_eff' :1, + 'sumw' :1004312.18015, + 'xsec' :0.145046125}, + + 'Zmumu_PTV0_70_CVetoBVeto': {'DSID' : 364100, + 'events' :7891000, + 'red_eff' :1, + 'sumw' :5319367.44387, + 'xsec' :1588.474174}, + + 'Zmumu_PTV0_70_CFilterBVeto': {'DSID' : 364101, + 'events' :4917000, + 'red_eff' :1, + 'sumw' :2834664.0856, + 'xsec' :219.4826028}, + + 'Zmumu_PTV0_70_BFilter': {'DSID' : 364102, + 'events' :7902000, + 'red_eff' :1, + 'sumw' :4078710.85229, + 'xsec' :127.1303743}, + + 'Zmumu_PTV70_140_CVetoBVeto': {'DSID' : 364103, + 'events' :5917000, + 'red_eff' :1, + 'sumw' :2143575.01278, + 'xsec' :73.36940289}, + + 'Zmumu_PTV70_140_CFilterBVeto': {'DSID' : 364104, + 'events' :1969800, + 'red_eff' :1, + 'sumw' :722736.703003, + 'xsec' :20.90606833}, + + 'Zmumu_PTV70_140_BFilter': {'DSID' : 364105, + 'events' :5900600, + 'red_eff' :1, + 'sumw' :2053470.59226, + 'xsec' :12.50542972}, + + 'Zmumu_PTV140_280_CVetoBVeto': {'DSID' : 364106, + 'events' :4943000, + 'red_eff' :1, + 'sumw' :2940060.231, + 'xsec' :23.43735064}, + + 'Zmumu_PTV140_280_CFilterBVeto': {'DSID' : 364107, + 'events' :2954400, + 'red_eff' :1, + 'sumw' :1961708.95573, + 'xsec' :9.145130781}, + + 'Zmumu_PTV140_280_BFilter': {'DSID' : 364108, + 'events' :11924400, + 'red_eff' :1, + 'sumw' :8276965.60895, + 'xsec' :6.076989874}, + + 'Zmumu_PTV280_500_CVetoBVeto': {'DSID' : 364109, + 'events' :1973000, + 'red_eff' :1, + 'sumw' :1705022.00352, + 'xsec' :4.657367095}, + + 'Zmumu_PTV280_500_CFilterBVeto': {'DSID' : 364110, + 'events' :986000, + 'red_eff' :1, + 'sumw' :906361.047826, + 'xsec' :2.214827532}, + + 'Zmumu_PTV280_500_BFilter': {'DSID' : 364111, + 'events' :1971400, + 'red_eff' :1, + 'sumw' :1854208.83636, + 'xsec' :1.468357812}, + + 'Zmumu_PTV500_1000': {'DSID' : 364112, + 'events' :2960500, + 'red_eff' :1, + 'sumw' :2944710.97814, + 'xsec' :1.74260121}, + + 'Zmumu_PTV1000_E_CMS': {'DSID' : 364113, + 'events' :988000, + 'red_eff' :1, + 'sumw' :1007977.7298, + 'xsec' :0.14392476}, + + 'Ztautau_PTV0_70_CVetoBVeto': {'DSID' : 364128, + 'events' :7907000, + 'red_eff' :1, + 'sumw' :5322698.33479, + 'xsec' :1612.531483}, + + 'Ztautau_PTV0_70_CFilterBVeto': {'DSID' : 364129, + 'events' :4941000, + 'red_eff' :1, + 'sumw' :2848153.01809, + 'xsec' :211.7088872}, + + 'Ztautau_PTV0_70_BFilter': {'DSID' : 364130, + 'events' :7890600, + 'red_eff' :1, + 'sumw' :4060541.5209, + 'xsec' :127.0915597}, + + 'Ztautau_PTV70_140_CVetoBVeto': {'DSID' : 364131, + 'events' :5935500, + 'red_eff' :1, + 'sumw' :2168444.60741, + 'xsec' :74.70740605}, + + 'Ztautau_PTV70_140_CFilterBVeto': {'DSID' : 364132, + 'events' :1961200, + 'red_eff' :1, + 'sumw' :717613.996532, + 'xsec' :20.50813626}, + + 'Ztautau_PTV70_140_BFilter': {'DSID' : 364133, + 'events' :5912550, + 'red_eff' :1, + 'sumw' :2071490.99782, + 'xsec' :11.96510571}, + + 'Ztautau_PTV140_280_CVetoBVeto': {'DSID' : 364134, + 'events' :4956000, + 'red_eff' :1, + 'sumw' :2969289.71879, + 'xsec' :24.57266372}, + + 'Ztautau_PTV140_280_CFilterBVeto': {'DSID' : 364135, + 'events' :2973000, + 'red_eff' :1, + 'sumw' :1983172.64602, + 'xsec' :9.301821784}, + + 'Ztautau_PTV140_280_BFilter': {'DSID' : 364136, + 'events' :4932950, + 'red_eff' :1, + 'sumw' :3430451.22731, + 'xsec' :6.192971739}, + + 'Ztautau_PTV280_500_CVetoBVeto': {'DSID' : 364137, + 'events' :1923000, + 'red_eff' :1, + 'sumw' :1613067.78257, + 'xsec' :4.759698353}, + + 'Ztautau_PTV280_500_CFilterBVeto': {'DSID' : 364138, + 'events' :986000, + 'red_eff' :1, + 'sumw' :905387.206237, + 'xsec' :2.236223236}, + + 'Ztautau_PTV280_500_BFilter': {'DSID' : 364139, + 'events' :1974950, + 'red_eff' :1, + 'sumw' :1853029.9701, + 'xsec' :1.491840072}, + + 'Ztautau_PTV500_1000': {'DSID' : 364140, + 'events' :2744800, + 'red_eff' :1, + 'sumw' :2725664.32001, + 'xsec' :1.76249325}, + + 'Ztautau_PTV1000_E_CMS':{'DSID' : 364141, + 'events' :980000, + 'red_eff' :1, + 'sumw' :997974.838867, + 'xsec' :0.144568326}, + + 'ZqqZll' : {'DSID' : 363356, + 'events' : 5317000, + 'red_eff' : 1, + 'sumw' : 3439266.11559, + 'xsec' : 2.20355112}, + + 'WqqZll' : {'DSID':363358, + 'events':5124000, + 'red_eff' : 1, + 'sumw' : 241438.72705, + 'xsec' : 3.4328}, + + 'WpqqWmlv' : {'DSID':363359, + 'events':6673000, + 'red_eff' : 1, + 'sumw' : 998250.783475, + 'xsec' : 24.708}, + + 'WplvWmqq' : {'DSID':363360, + 'events':7115000, + 'red_eff' : 1, + 'sumw' : 1069526.41899, + 'xsec' : 24.724}, + + 'WlvZqq' : {'DSID':363489, + 'events':7100000, + 'red_eff' : 1, + 'sumw' : 1111991.15979, + 'xsec' : 11.42}, + + 'llll' : {'DSID':363490, + 'events':17825300, + 'red_eff' : 1, + 'sumw' : 7538705.8077, + 'xsec' : 1.2578}, + + 'lllv' : {'DSID':363491, + 'events':15772084, + 'red_eff' : 1, + 'sumw' : 5441475.00407, + 'xsec' : 4.6049}, + + 'llvv' : {'DSID':363492, + 'events':14803000, + 'red_eff' : 1, + 'sumw' : 5039259.9696, + 'xsec' : 12.466}, + + 'lvvv' : {'DSID':363493, + 'events':5922600, + 'red_eff' : 1, + 'sumw' : 1727991.07441, + 'xsec' : 3.2286}, + + 'single_top_tchan': {'DSID' : 410011, + 'events' : 4986200, + 'red_eff' : 1, + 'sumw' : 0.218165148808, + 'xsec' : 44.152}, + + 'single_antitop_tchan': {'DSID' : 410012, + 'events' : 4989800, + 'red_eff' : 1, + 'sumw' : 0.128694693283, + 'xsec' : 26.276}, + + 'single_top_schan': {'DSID' : 410025, + 'events' : 997800, + 'red_eff' : 1, + 'sumw' : 0.00204856751068, + 'xsec' : 2.06121}, + + 'single_antitop_schan': {'DSID' : 410026, + 'events' : 995400, + 'red_eff' : 1, + 'sumw' : 0.00125651986173, + 'xsec' : 1.288662}, + + 'single_top_wtchan': {'DSID' : 410013, + 'events' : 4985800, + 'red_eff' : 1, + 'sumw' : 4865800, + 'xsec' : 35.845486}, + + 'single_antitop_wtchan': {'DSID' : 410014, + 'events' : 4985600, + 'red_eff' : 1, + 'sumw' : 4945600, + 'xsec' : 35.824406}, + + 'ttbar_lep': {'DSID' : 410000, + 'events' : 49386600, + 'red_eff' : 1, + 'sumw' : 49386600, + 'xsec' : 452.693559}, + + 'ttW':{'DSID':410155, + 'red_eff' : 1, + 'sumw':4075279.75386, + 'xsec':0.60084912}, + + 'ttee':{'DSID':410218, + 'red_eff': 1, + 'sumw':51968.9384584, + 'xsec':0.0412888}, + + 'ttmumu':{'DSID':410219, + 'red_eff':1, + 'sumw':52007.5311319, + 'xsec':0.04129216}, + + # Inclusive MC + 'Wplusenu': {'DSID' : 361100, + 'events':41870000, + 'red_eff' : 1, + 'sumw' : 473389396815, + 'xsec' : 11500.4632}, + + 'Wplusmunu': {'DSID' : 361101, + 'events' : 39493600, + 'red_eff': 1, + 'sumw' : 446507925520, + 'xsec' : 11500.4632}, + + 'Wplustaunu': {'DSID' : 361102, + 'events' : 59343600, + 'red_eff': 1, + 'sumw' : 670928468875, + 'xsec' : 11500.4632}, + + 'Wminusenu': {'DSID' : 361103, + 'events' : 29886000, + 'red_eff': 1, + 'sumw' : 247538642447, + 'xsec' : 8579.63498}, + + 'Wminusmunu': {'DSID' : 361104, + 'events' : 31915400, + 'red_eff': 1, + 'sumw' : 264338188182, + 'xsec' : 8579.63498}, + + 'Wminustaunu': {'DSID' : 361105, + 'events' : 19945400, + 'red_eff': 1, + 'sumw' : 165195850954, + 'xsec' : 8579.63498}, + + 'Zee': {'DSID' : 361106, + 'events' : 79045597, + 'red_eff' : 1, + 'sumw' : 150277594200, + 'xsec' : 1950.5295}, + + 'Zmumu': {'DSID' : 361107, + 'events' : 77497800, + 'red_eff' : 1, + 'sumw' : 147334691090, + 'xsec' : 1950.6321}, + + 'Ztautau': {'DSID' : 361108, + 'events' : 29546000, + 'red_eff' : 1, + 'sumw' : 56171652547.3, + 'xsec' : 1950.6321}, + + 'Wenu_PTV0_70_BFilter': {'DSID' : 364172, + 'events' : 17242400, + 'red_eff' : 1, + 'sumw' : 10407897.8772, + 'xsec' : 832.203758}, + + 'Wenu_PTV0_70_CFilterBVeto': {'DSID' : 364171, + 'events' : 9853500, + 'red_eff' : 1, + 'sumw' : 5647044.71225, + 'xsec' : 2430.656322}, + + 'Wenu_PTV0_70_CVetoBVeto': {'DSID' : 364170, + 'events' : 24740000, + 'red_eff': 1, + 'sumw' : 16615214.8608, + 'xsec' : 15324.216356}, + + 'Wenu_PTV70_140_BFilter': {'DSID' : 364175, + 'events' : 9801900, + 'red_eff' : 1, + 'sumw' : 3980401.78673, + 'xsec' : 94.875534}, + + 'Wenu_PTV70_140_CFilterBVeto': {'DSID' : 364174, + 'events' : 9813400, + 'red_eff' : 1, + 'sumw' : 3714792.41865, + 'xsec' : 223.63946}, + + 'Wenu_PTV70_140_CVetoBVeto': {'DSID' : 364173, + 'events' : 14660500, + 'red_eff': 1, + 'sumw' : 5359689.22316, + 'xsec' : 618.6882}, + + 'Wenu_PTV140_280_BFilter': {'DSID' : 364178, + 'events' : 24677800, + 'red_eff' : 1, + 'sumw' : 18298138.5816, + 'xsec' : 35.917295}, + + 'Wenu_PTV140_280_CFilterBVeto': {'DSID' : 364177, + 'events' : 7410000, + 'red_eff' : 1, + 'sumw' : 5263243.42582, + 'xsec' : 96.277568}, + + 'Wenu_PTV140_280_CVetoBVeto': {'DSID' : 364176, + 'events' : 9879000, + 'red_eff': 1, + 'sumw' : 6159276.028, + 'xsec' : 197.343129}, + + 'Wenu_PTV280_500_BFilter': {'DSID' : 364181, + 'events' : 2958000, + 'red_eff' : 1, + 'sumw' : 2835314.68179, + 'xsec' : 9.586345}, + + 'Wenu_PTV280_500_CFilterBVeto': {'DSID' : 364180, + 'events' : 2963400, + 'red_eff' : 1, + 'sumw' : 2778654.28759, + 'xsec' : 22.36999}, + + 'Wenu_PTV280_500_CVetoBVeto': {'DSID' : 364179, + 'events' : 4923800, + 'red_eff': 1, + 'sumw' : 4312357.01458, + 'xsec' : 38.340533}, + + 'Wenu_PTV500_1000': {'DSID' : 364182, + 'events' : 5911800, + 'red_eff' : 1, + 'sumw' : 6003269.52809, + 'xsec' : 14.598599}, + + 'Wenu_PTV1000_E_CMS': {'DSID' : 364183, + 'events' : 3947000, + 'red_eff' : 1, + 'sumw' : 4075236.23897, + 'xsec' : 1.197518}, + + 'Wmunu_PTV0_70_BFilter': {'DSID' : 364158, + 'events' : 17226200, + 'red_eff' : 1, + 'sumw' : 10403012.6599, + 'xsec' : 828.465384}, + + 'Wmunu_PTV0_70_CFilterBVeto': {'DSID' : 364157, + 'events' : 9847000, + 'red_eff' : 1, + 'sumw' : 5643599.11526, + 'xsec' : 2431.204019}, + + 'Wmunu_PTV0_70_CVetoBVeto': {'DSID' : 364156, + 'events' : 24723000, + 'red_eff' : 1, + 'sumw' : 16619290.3298, + 'xsec' : 15317.171239}, + + 'Wmunu_PTV70_140_BFilter': {'DSID' : 364161, + 'events' : 19639000, + 'red_eff' : 1, + 'sumw' : 7990084.35926, + 'xsec' : 76.213179}, + + 'Wmunu_PTV70_140_CFilterBVeto': {'DSID' : 364160, + 'events' : 9853800, + 'red_eff' : 1, + 'sumw' : 3693885.78953, + 'xsec' : 225.006704}, + + 'Wmunu_PTV70_140_CVetoBVeto': {'DSID' : 364159, + 'events' : 14788000, + 'red_eff' : 1, + 'sumw' : 5418398.88082, + 'xsec' : 617.439593}, + + 'Wmunu_PTV140_280_BFilter': {'DSID' : 364164, + 'events' : 24585000, + 'red_eff' : 1, + 'sumw' : 18222434.0789, + 'xsec' : 36.348467}, + + 'Wmunu_PTV140_280_CFilterBVeto': {'DSID' : 364163, + 'events' : 7408000, + 'red_eff' : 1, + 'sumw' : 5260811.17463, + 'xsec' : 96.233222}, + + 'Wmunu_PTV140_280_CVetoBVeto': {'DSID' : 364162, + 'events' : 9882000, + 'red_eff' : 1, + 'sumw' : 6155495.28527, + 'xsec' : 198.635592}, + + 'Wmunu_PTV280_500_BFilter': {'DSID' : 364167, + 'events' : 2959500, + 'red_eff' : 1, + 'sumw' : 2835707.22044, + 'xsec' : 8.768196}, + + 'Wmunu_PTV280_500_CFilterBVeto': {'DSID' : 364166, + 'events' : 2958000, + 'red_eff' : 1, + 'sumw' : 2783968.68238, + 'xsec' : 22.395647}, + + 'Wmunu_PTV280_500_CVetoBVeto': {'DSID' : 364165, + 'events' : 4940000, + 'red_eff' : 1, + 'sumw' : 4325283.67358, + 'xsec' : 38.299835}, + + 'Wmunu_PTV500_1000': {'DSID' : 364168, + 'events' : 5910500, + 'red_eff' : 1, + 'sumw' : 5941704.99235, + 'xsec' : 14.558821}, + + 'Wmunu_PTV1000_E_CMS': {'DSID' : 364169, + 'events' : 3959000, + 'red_eff' : 1, + 'sumw' : 3882898.99675, + 'xsec' : 1.198003}, + + 'Wtaunu_PTV0_70_BFilter': {'DSID' : 364186, + 'events' : 17273200, + 'red_eff' : 1, + 'sumw' : 10498770.1084, + 'xsec' : 837.531038}, + + 'Wtaunu_PTV0_70_CFilterBVeto': {'DSID' : 364185, + 'events' : 9865600, + 'red_eff' : 1, + 'sumw' : 5671521.55269, + 'xsec' : 2443.425881}, + + 'Wtaunu_PTV0_70_CVetoBVeto': {'DSID' : 364184, + 'events' : 24784000, + 'red_eff' : 1, + 'sumw' : 16726425.0218, + 'xsec' : 15324.887336}, + + 'Wtaunu_PTV70_140_BFilter': {'DSID' : 364189, + 'events' : 9857000, + 'red_eff' : 1, + 'sumw' : 3969118.20687, + 'xsec' : 95.365521}, + + 'Wtaunu_PTV70_140_CFilterBVeto': {'DSID' : 364188, + 'events' : 9860000, + 'red_eff' : 1, + 'sumw' : 3719117.16117, + 'xsec' : 222.595303}, + + 'Wtaunu_PTV70_140_CVetoBVeto': {'DSID' : 364187, + 'events' : 14808500, + 'red_eff' : 1, + 'sumw' : 5427023.47527, + 'xsec' : 620.166885}, + + 'Wtaunu_PTV140_280_BFilter': {'DSID' : 364192, + 'events' : 24595900, + 'red_eff' : 1, + 'sumw' : 7291603.73991, + 'xsec' : 34.639523}, + + 'Wtaunu_PTV140_280_CFilterBVeto': {'DSID' : 364191, + 'events' : 7415000, + 'red_eff' : 1, + 'sumw' : 5184365.13393, + 'xsec' : 93.808553}, + + 'Wtaunu_PTV140_280_CVetoBVeto': {'DSID' : 364190, + 'events' : 9899000, + 'red_eff' : 1, + 'sumw' : 6166514.76606, + 'xsec' : 197.370776}, + + 'Wtaunu_PTV280_500_BFilter': {'DSID' : 364195, + 'events' : 2954100, + 'red_eff' : 1, + 'sumw' : 2830341.62344, + 'xsec' : 9.490847}, + + 'Wtaunu_PTV280_500_CFilterBVeto': {'DSID' : 364194, + 'events' : 2956400, + 'red_eff' : 1, + 'sumw' : 2772305.06916, + 'xsec' : 22.268425}, + + 'Wtaunu_PTV280_500_CVetoBVeto': {'DSID' : 364193, + 'events' : 4931200, + 'red_eff' : 1, + 'sumw' : 4322848.66983, + 'xsec' : 38.34009}, + + 'Wtaunu_PTV500_1000': {'DSID' : 364196, + 'events' : 5945000, + 'red_eff' : 1, + 'sumw' : 5389084.10064, + 'xsec' : 14.60345}, + + 'Wtaunu_PTV1000_E_CMS': {'DSID' : 364197, + 'events' : 3946000, + 'red_eff' : 1, + 'sumw' : 4057477.95297, + 'xsec' : 1.197324}, + + 'Wplusenu_1lep1tau':{'DSID':361100, + 'events':25544800, + 'red_eff':1, + 'sumw':288804806460, + 'xsec':11500.4632}, + + 'Wplusmunu_1lep1tau':{'DSID':361101, + 'events':1996000, + 'red_eff':1, + 'sumw':22564856148.4, + 'xsec':11500.4632}, + + 'Wplustaunu_1lep1tau':{'DSID':361102, + 'events':1979400, + 'red_eff':1, + 'sumw':22377037617.7, + 'xsec':11500.4632}, + + 'Wminusenu_1lep1tau':{'DSID':361103, + 'events':17905400, + 'red_eff':1, + 'sumw':148301360014, + 'xsec':8579.63498}, + + 'Wminusmunu_1lep1tau':{'DSID':361104, + 'events':1997000, + 'red_eff':1, + 'sumw':16541864239.9, + 'xsec':8579.63498}, + + 'Wminustaunu_1lep1tau':{'DSID':361105, + 'events':1999800, + 'red_eff':1, + 'sumw':16563331847, + 'xsec':8579.63498}, + + 'Zee_1lep1tau':{'DSID':361106, + 'events':61106597, + 'red_eff':1, + 'sumw':116172063285, + 'xsec':1950.5295}, + + 'Zmumu_1lep1tau':{'DSID':361107, + 'events':1998400, + 'red_eff':1, + 'sumw':3799531630.02, + 'xsec':1950.6321}, + + 'Ztautau_1lep1tau':{'DSID':361108, + 'events':29546000, + 'red_eff':1, + 'sumw':56171652547.3, + 'xsec':1950.6321}, + + 'ttbar_lep_1lep1tau':{'DSID':410000, + 'events':49296600, + 'red_eff':1, + 'sumw':49296600, + 'xsec':452.693559}, + + 'single_top_tchan_1lep1tau':{'DSID':410011, + 'events':1996600, + 'red_eff':1, + 'sumw':0.0873624212691, + 'xsec':44.152}, + + 'single_antitop_tchan_1lep1tau':{'DSID':410012, + 'events':1994200, + 'red_eff':1, + 'sumw':0.051427775374, + 'xsec':26.276}, + + 'single_top_wtchan_1lep1tau':{'DSID':410013, + 'events':1994200, + 'red_eff':1, + 'sumw':1994200, + 'xsec':35.845486}, + + 'single_antitop_wtchan_1lep1tau':{'DSID':410014, + 'events':1994000, + 'red_eff':1, + 'sumw':1994000, + 'xsec':35.824406}, + + 'single_top_schan_1lep1tau':{'DSID':410025, + 'events':997800, + 'red_eff':1, + 'sumw':0.00204856751068, + 'xsec':2.06111}, + + 'single_antitop_schan_1lep1tau':{'DSID':410026, + 'events':995400, + 'red_eff':1, + 'sumw':0.00125651986173, + 'xsec':1.288662}, + + 'Zmumu_PTV0_70_CVetoBVeto_1lep1tau':{'DSID':364100, + 'events':7891000, + 'red_eff':1, + 'sumw':5319367.44387, + 'xsec':1588.474174}, + + 'Zmumu_PTV0_70_CFilterBVeto_1lep1tau':{'DSID':364101, + 'events':4917000, + 'red_eff':1, + 'sumw':2834664.0856, + 'xsec':219.4826028}, + + 'Zmumu_PTV0_70_BFilter_1lep1tau':{'DSID':364102, + 'events':7902000, + 'red_eff':1, + 'sumw':4078710.85229, + 'xsec':127.1303743}, + + 'Zmumu_PTV70_140_CVetoBVeto_1lep1tau':{'DSID':364103, + 'events':5917000, + 'red_eff':1, + 'sumw':2143575.01278, + 'xsec':73.36940289}, + + 'Zmumu_PTV70_140_CFilterBVeto_1lep1tau':{'DSID':364104, + 'events':1969800, + 'red_eff':1, + 'sumw':722736.703003, + 'xsec':20.90606833}, + + 'Zmumu_PTV70_140_BFilter_1lep1tau':{'DSID':364105, + 'events':5900600, + 'red_eff':1, + 'sumw':2053470.59226, + 'xsec':12.50542972}, + + 'Zmumu_PTV140_280_CVetoBVeto_1lep1tau':{'DSID':364106, + 'events':4943000, + 'red_eff':1, + 'sumw':2940060.231, + 'xsec':23.43735064}, + + 'Zmumu_PTV140_280_CFilterBVeto_1lep1tau':{'DSID':364107, + 'events':2954400, + 'red_eff':1, + 'sumw':1961708.95573, + 'xsec':9.145130781}, + + 'Zmumu_PTV140_280_BFilter_1lep1tau':{'DSID':364108, + 'events':4942300, + 'red_eff':1, + 'sumw':3441102.46707, + 'xsec':6.076989874}, + + 'Zmumu_PTV280_500_CVetoBVeto_1lep1tau':{'DSID':364109, + 'events':1973000, + 'red_eff':1, + 'sumw':1705022.00352, + 'xsec':4.657367095}, + + 'Zmumu_PTV280_500_CFilterBVeto_1lep1tau':{'DSID':364110, + 'events':986000, + 'red_eff':1, + 'sumw':906361.047826, + 'xsec':2.214827532}, + + 'Zmumu_PTV280_500_BFilter_1lep1tau':{'DSID':364111, + 'events':1971400, + 'red_eff':1, + 'sumw':1854208.83636, + 'xsec':1.468357812}, + + 'Zmumu_PTV500_1000_1lep1tau':{'DSID':364112, + 'events':2960500, + 'red_eff':1, + 'sumw':2944710.97814, + 'xsec':1.74260121}, + + 'Zmumu_PTV1000_E_CMS_1lep1tau':{'DSID':364113, + 'events':988000, + 'red_eff':1, + 'sumw':1007977.7298, + 'xsec':0.14392476}, + + 'Zee_PTV0_70_CVetoBVeto_1lep1tau':{'DSID':364114, + 'events':7900000, + 'red_eff':1, + 'sumw':5307644.52827, + 'xsec':1587.021595}, + 'Zee_PTV0_70_CFilterBVeto_1lep1tau':{'DSID':364115, + 'events':4940500, + 'red_eff':1, + 'sumw':2839137.81561, + 'xsec':219.9958116}, + 'Zee_PTV0_70_BFilter_1lep1tau':{'DSID':364116, + 'events':7883600, + 'red_eff':1, + 'sumw':4053053.52848, + 'xsec':127.0857614}, + 'Zee_PTV70_140_CVetoBVeto_1lep1tau':{'DSID':364117, + 'events':5925000, + 'red_eff':1, + 'sumw':2164248.98844, + 'xsec':74.90381742}, + 'Zee_PTV70_140_CFilterBVeto_1lep1tau':{'DSID':364118, + 'events':1972600, + 'red_eff':1, + 'sumw':715162.089738, + 'xsec':20.3159891}, + 'Zee_PTV70_140_BFilter_1lep1tau':{'DSID':364119, + 'events':5855000, + 'red_eff':1, + 'sumw':2043192.28295, + 'xsec':12.73880801}, + 'Zee_PTV140_280_CVetoBVeto_1lep1tau':{'DSID':364120, + 'events':4949000, + 'red_eff':1, + 'sumw':2966342.61469, + 'xsec':24.44184978}, + 'Zee_PTV140_280_CFilterBVeto_1lep1tau':{'DSID':364121, + 'events':2962600, + 'red_eff':1, + 'sumw':1976624.57582, + 'xsec':9.237605979}, + 'Zee_PTV140_280_BFilter_1lep1tau':{'DSID':364122, + 'events':4890000, + 'red_eff':1, + 'sumw':3396476.98264, + 'xsec':6.081254464}, + 'Zee_PTV280_500_CVetoBVeto_1lep1tau':{'DSID':364123, + 'events':1882800, + 'red_eff':1, + 'sumw':1622207.75969, + 'xsec':4.796836771}, + 'Zee_PTV280_500_CFilterBVeto_1lep1tau':{'DSID':364124, + 'events':988900, + 'red_eff':1, + 'sumw':908261.497964, + 'xsec':2.249186051}, + 'Zee_PTV280_500_BFilter_1lep1tau':{'DSID':364125, + 'events':1976850, + 'red_eff':1, + 'sumw':1854184.55614, + 'xsec':1.49219843}, + 'Zee_PTV500_1000_1lep1tau':{'DSID':364126, + 'events':2973000, + 'red_eff':1, + 'sumw':2942740.91362, + 'xsec':1.76415092}, + 'Zee_PTV1000_E_CMS_1lep1tau':{'DSID':364127, + 'events':978000, + 'red_eff':1, + 'sumw':994142.027341, + 'xsec':0.145046125}, + + 'Ztautau_PTV0_70_CVetoBVeto_1lep1tau':{'DSID':364128, + 'events':7817000, + 'red_eff':1, + 'sumw':5261983.52635, + 'xsec':1612.531483}, + + 'Ztautau_PTV0_70_CFilterBVeto_1lep1tau':{'DSID':364129, + 'events':4941000, + 'red_eff':1, + 'sumw':2848153.01809, + 'xsec':211.7088872}, + + 'Ztautau_PTV0_70_BFilter_1lep1tau':{'DSID':364130, + 'events':7890600, + 'red_eff':1, + 'sumw':4060541.5209, + 'xsec':127.0915597}, + + 'Ztautau_PTV70_140_CVetoBVeto_1lep1tau':{'DSID':364131, + 'events':5935500, + 'red_eff':1, + 'sumw':2168444.60741, + 'xsec':74.70740605}, + + 'Ztautau_PTV70_140_CFilterBVeto_1lep1tau':{'DSID':364132, + 'events':1961200, + 'red_eff':1, + 'sumw':717613.996532, + 'xsec':20.50813626}, + + 'Ztautau_PTV70_140_BFilter_1lep1tau':{'DSID':364133, + 'events':5912550, + 'red_eff':1, + 'sumw':2071490.99782, + 'xsec':11.96510571}, + + 'Ztautau_PTV140_280_CVetoBVeto_1lep1tau':{'DSID':364134, + 'events':4956000, + 'red_eff':1, + 'sumw':2969289.71879, + 'xsec':24.57266372}, + + 'Ztautau_PTV140_280_CFilterBVeto_1lep1tau':{'DSID':364135, + 'events':2973000, + 'red_eff':1, + 'sumw':1983172.64602, + 'xsec':9.301821784}, + + 'Ztautau_PTV140_280_BFilter_1lep1tau':{'DSID':364136, + 'events':4932950, + 'red_eff':1, + 'sumw':3430451.22731, + 'xsec':6.192971739}, + + 'Ztautau_PTV280_500_CVetoBVeto_1lep1tau':{'DSID':364137, + 'events':1973000, + 'red_eff':1, + 'sumw':1656090.74518, + 'xsec':4.759698353}, + + 'Ztautau_PTV280_500_CFilterBVeto_1lep1tau':{'DSID':364138, + 'events':986000, + 'red_eff':1, + 'sumw':905387.206237, + 'xsec':2.236223236}, + + 'Ztautau_PTV280_500_BFilter_1lep1tau':{'DSID':364139, + 'events':1974950, + 'red_eff':1, + 'sumw':1853029.9701, + 'xsec':1.491840072}, + + 'Ztautau_PTV500_1000_1lep1tau':{'DSID':364140, + 'events':2944800, + 'red_eff':1, + 'sumw':2923750.21933, + 'xsec':1.76249325}, + + 'Ztautau_PTV1000_E_CMS_1lep1tau':{'DSID':364141, + 'events':980000, + 'red_eff':1, + 'sumw':997974.838867, + 'xsec':0.144568326}, + + 'Wmunu_PTV0_70_CVetoBVeto_1lep1tau':{'DSID':364156, + 'events':24723000, + 'red_eff':1, + 'sumw':16619290.3298, + 'xsec':15317.171239}, + 'Wmunu_PTV0_70_CFilterBVeto_1lep1tau':{'DSID':364157, + 'events':9847000, + 'red_eff':1, + 'sumw':5643599.11526, + 'xsec':2431.204019}, + 'Wmunu_PTV0_70_BFilter_1lep1tau':{'DSID':364158, + 'events':17226200, + 'red_eff':1, + 'sumw':10403012.6599, + 'xsec':828.465384}, + 'Wmunu_PTV70_140_CVetoBVeto_1lep1tau':{'DSID':364159, + 'events':14788000, + 'red_eff':1, + 'sumw':5418398.88082, + 'xsec':617.439593}, + 'Wmunu_PTV70_140_CFilterBVeto_1lep1tau':{'DSID':364160, + 'events':9853800, + 'red_eff':1, + 'sumw':3693885.78953, + 'xsec':225.006704}, + 'Wmunu_PTV70_140_BFilter_1lep1tau':{'DSID':364161, + 'events':19639000, + 'red_eff':1, + 'sumw':7990084.35926, + 'xsec':76.213179}, + 'Wmunu_PTV140_280_CVetoBVeto_1lep1tau':{'DSID':364162, + 'events':9882000, + 'red_eff':1, + 'sumw':6155495.28527, + 'xsec':198.635592}, + 'Wmunu_PTV140_280_CFilterBVeto_1lep1tau':{'DSID':364163, + 'events':7408000, + 'red_eff':1, + 'sumw':5260811.17463, + 'xsec':96.233222}, + 'Wmunu_PTV140_280_BFilter_1lep1tau':{'DSID':364164, + 'events':9826000, + 'red_eff':1, + 'sumw':7271557.26566, + 'xsec':36.348467}, + 'Wmunu_PTV280_500_CVetoBVeto_1lep1tau':{'DSID':364165, + 'events':4940000, + 'red_eff':1, + 'sumw':4325283.67358, + 'xsec':38.299835}, + 'Wmunu_PTV280_500_CFilterBVeto_1lep1tau':{'DSID':364166, + 'events':2958000, + 'red_eff':1, + 'sumw':2783968.68238, + 'xsec':22.395647}, + 'Wmunu_PTV280_500_BFilter_1lep1tau':{'DSID':364167, + 'events':2959500, + 'red_eff':1, + 'sumw':2835707.22044, + 'xsec':8.768196}, + 'Wmunu_PTV500_1000_1lep1tau':{'DSID':364168, + 'events':5910500, + 'red_eff':1, + 'sumw':5941704.99235, + 'xsec':14.558821}, + 'Wmunu_PTV1000_E_CMS_1lep1tau':{'DSID':364169, + 'events':3959000, + 'red_eff':1, + 'sumw':4068015.22447, + 'xsec':1.198003}, + + 'Wenu_PTV0_70_CVetoBVeto_1lep1tau':{'DSID':364170, + 'events':24740000, + 'red_eff':1, + 'sumw':16615214.8608, + 'xsec':15324.216356}, + + 'Wenu_PTV0_70_CFilterBVeto_1lep1tau':{'DSID':364171, + 'events':9853500, + 'red_eff':1, + 'sumw':5647044.71225, + 'xsec':2430.656322}, + + 'Wenu_PTV0_70_BFilter_1lep1tau':{'DSID':364172, + 'events':17242400, + 'red_eff':1, + 'sumw':10407897.8772, + 'xsec':832.203758}, + + 'Wenu_PTV70_140_CVetoBVeto_1lep1tau':{'DSID':364173, + 'events':13950500, + 'red_eff':1, + 'sumw':5098540.19503, + 'xsec':618.6882}, + + 'Wenu_PTV70_140_CFilterBVeto_1lep1tau':{'DSID':364174, + 'events':9678400, + 'red_eff':1, + 'sumw':3661915.17878, + 'xsec':223.63946}, + + 'Wenu_PTV70_140_BFilter_1lep1tau':{'DSID':364175, + 'events':9801900, + 'red_eff':1, + 'sumw':3980401.78673, + 'xsec':94.875534}, + + 'Wenu_PTV140_280_CVetoBVeto_1lep1tau':{'DSID':364176, + 'events':9819000, + 'red_eff':1, + 'sumw':6121546.03361, + 'xsec':197.343129}, + + 'Wenu_PTV140_280_CFilterBVeto_1lep1tau':{'DSID':364177, + 'events':7410000, + 'red_eff':1, + 'sumw':5263243.42582, + 'xsec':96.277568}, + + 'Wenu_PTV140_280_BFilter_1lep1tau':{'DSID':364178, + 'events':9880900, + 'red_eff':1, + 'sumw':7327201.08884, + 'xsec':35.917295}, + + 'Wenu_PTV280_500_CVetoBVeto_1lep1tau':{'DSID':364179, + 'events':4923800, + 'red_eff':1, + 'sumw':4312357.01458, + 'xsec':38.340533}, + + 'Wenu_PTV280_500_CFilterBVeto_1lep1tau':{'DSID':364180, + 'events':2963400, + 'red_eff':1, + 'sumw':2778654.28759, + 'xsec':22.36999}, + + 'Wenu_PTV280_500_BFilter_1lep1tau':{'DSID':364181, + 'events':2958000, + 'red_eff':1, + 'sumw':2835314.68179, + 'xsec':9.586345}, + + 'Wenu_PTV500_1000_1lep1tau':{'DSID':364182, + 'events':5916800, + 'red_eff':1, + 'sumw':6003269.52809, + 'xsec':14.598599}, + + 'Wenu_PTV1000_E_CMS_1lep1tau':{'DSID':364183, + 'events':3947000, + 'red_eff':1, + 'sumw':4075236.23897, + 'xsec':1.197518}, + + 'Wtaunu_PTV0_70_CVetoBVeto_1lep1tau':{'DSID':364184, + 'events':17674000, + 'red_eff':1, + 'sumw':11929044.1188, + 'xsec':15324.887336}, + + 'Wtaunu_PTV0_70_CFilterBVeto_1lep1tau':{'DSID':364185, + 'events':9865600, + 'red_eff':1, + 'sumw':5671521.55269, + 'xsec':2443.425881}, + + 'Wtaunu_PTV0_70_BFilter_1lep1tau':{'DSID':364186, + 'events':17273200, + 'red_eff':1, + 'sumw':10498770.1084, + 'xsec':837.531038}, + + 'Wtaunu_PTV70_140_CVetoBVeto_1lep1tau':{'DSID':364187, + 'events':14808500, + 'red_eff':1, + 'sumw':5427023.47527, + 'xsec':620.166885}, + + 'Wtaunu_PTV70_140_CFilterBVeto_1lep1tau':{'DSID':364188, + 'events':9860000, + 'red_eff':1, + 'sumw':3719117.16117, + 'xsec':222.595303}, + + 'Wtaunu_PTV70_140_BFilter_1lep1tau':{'DSID':364189, + 'events':9857000, + 'red_eff':1, + 'sumw':3969118.20687, + 'xsec':95.365521}, + + 'Wtaunu_PTV140_280_CVetoBVeto_1lep1tau':{'DSID':364190, + 'events':9899000, + 'red_eff':1, + 'sumw':6166514.76606, + 'xsec':197.370776}, + + 'Wtaunu_PTV140_280_CFilterBVeto_1lep1tau':{'DSID':364191, + 'events':7175000, + 'red_eff':1, + 'sumw':5085280.31607, + 'xsec':93.808553}, + + 'Wtaunu_PTV140_280_BFilter_1lep1tau':{'DSID':364192, + 'events':9834000, + 'red_eff':1, + 'sumw':7291603.73991, + 'xsec':34.639523}, + + 'Wtaunu_PTV280_500_CVetoBVeto_1lep1tau':{'DSID':364193, + 'events':4931200, + 'red_eff':1, + 'sumw':4322848.66983, + 'xsec':38.34009}, + + 'Wtaunu_PTV280_500_CFilterBVeto_1lep1tau':{'DSID':364194, + 'events':2956400, + 'red_eff':1, + 'sumw':2772305.06916, + 'xsec':22.268425}, + + 'Wtaunu_PTV280_500_BFilter_1lep1tau':{'DSID':364195, + 'events':2954100, + 'red_eff':1, + 'sumw':2830341.62344, + 'xsec':9.490847}, + + 'Wtaunu_PTV500_1000_1lep1tau':{'DSID':364196, + 'events':5895000, + 'red_eff':1, + 'sumw':5932750.60186, + 'xsec':14.60345}, + + 'Wtaunu_PTV1000_E_CMS_1lep1tau':{'DSID':364197, + 'events':3946000, + 'red_eff':1, + 'sumw':4057477.95297, + 'xsec':1.197324}, + + 'ttbar_lep_1largeRjet1lep':{'DSID':410000, + 'events':49386600, + 'red_eff':1, + 'sumw':4938660, + 'xsec':452.693559}, + + 'single_top_tchan_1largeRjet1lep':{'DSID':410011, + 'events':4986200, + 'red_eff':1, + 'sumw':0.218165148808, + 'xsec':44.152}, + + 'single_antitop_tchan_1largeRjet1lep':{'DSID':410012, + 'events':4989800, + 'red_eff':1, + 'sumw':0.128694693283, + 'xsec':26.276}, + + 'single_top_wtchan_1largeRjet1lep':{'DSID':410013, + 'events':4985800, + 'red_eff':1, + 'sumw':4985800, + 'xsec':35.845486}, + + 'single_antitop_wtchan_1largeRjet1lep':{'DSID':410014, + 'events':4985600, + 'red_eff':1, + 'sumw':4985600, + 'xsec':35.824406}, + + 'single_top_schan_1largeRjet1lep':{'DSID':410025, + 'events':997800, + 'red_eff':1, + 'sumw':0.00204856751068, + 'xsec':2.06111}, + + 'single_antitop_schan_1largeRjet1lep':{'DSID':410026, + 'events':220000, + 'red_eff':1, + 'sumw':0.000277829987565, + 'xsec':1.288662}, + + 'Zmumu0_70CVetoBVeto_1largeRjet1lep':{'DSID':364100, + 'events':7891000, + 'red_eff':1, + 'sumw':5319367.44387, + 'xsec':1588.474174}, + + 'Zmumu0_70CFilterBVeto_1largeRjet1lep':{'DSID':364101, + 'events':4917000, + 'red_eff':1, + 'sumw':2834664.0856, + 'xsec':219.4826028}, + + 'Zmumu0_70BFilter_1largeRjet1lep':{'DSID':364102, + 'events':7902000, + 'red_eff':1, + 'sumw':4078710.85229, + 'xsec':127.1303743}, + + 'Zmumu70_140CVetoBVeto_1largeRjet1lep':{'DSID':364103, + 'events':5917000, + 'red_eff':1, + 'sumw':2143575.01278, + 'xsec':73.36940289}, + + 'Zmumu70_140CFilterBVeto_1largeRjet1lep':{'DSID':364104, + 'events':1969800, + 'red_eff':1, + 'sumw':722736.703003, + 'xsec':20.90606833}, + + 'Zmumu70_140BFilter_1largeRjet1lep':{'DSID':364105, + 'events':5900600, + 'red_eff':1, + 'sumw':2053470.59226, + 'xsec':12.50542972}, + + 'Zmumu140_280CVetoBVeto_1largeRjet1lep':{'DSID':364106, + 'events':4943000, + 'red_eff':1, + 'sumw':2940060.231, + 'xsec':23.43735064}, + + 'Zmumu140_280CFilterBVeto_1largeRjet1lep':{'DSID':364107, + 'events':2954400, + 'red_eff':1, + 'sumw':1961708.95573, + 'xsec':9.145130781}, + + 'Zmumu140_280BFilter_1largeRjet1lep':{'DSID':364108, + 'events':12339300, + 'red_eff':1, + 'sumw':8563701.72954, + 'xsec':6.076989874}, + + 'Zmumu280_500CVetoBVeto_1largeRjet1lep':{'DSID':364109, + 'events':1973000, + 'red_eff':1, + 'sumw':1705022.00352, + 'xsec':4.657367095}, + + 'Zmumu280_500CFilterBVeto_1largeRjet1lep':{'DSID':364110, + 'events':986000, + 'red_eff':1, + 'sumw':906361.047826, + 'xsec':2.214827532}, + + 'Zmumu280_500BFilter_1largeRjet1lep':{'DSID':364111, + 'events':1971400, + 'red_eff':1, + 'sumw':1854208.83636, + 'xsec':1.468357812}, + + 'Zmumu500_1000_1largeRjet1lep':{'DSID':364112, + 'events':1, + 'red_eff':1, + 'sumw':2944710.97814, + 'xsec':1.74260121}, + + 'Zmumu1000_1largeRjet1lep':{'DSID':364113, + 'events':988000, + 'red_eff':1, + 'sumw':1007977.7298, + 'xsec':0.14392476}, + + 'Zee_PTV0_70_CVetoBVeto_1largeRjet1lep':{'DSID':364114, + 'events':6850000, + 'red_eff':1, + 'sumw':5307644.52827, + 'xsec':1587.021595}, + 'Zee_PTV0_70_CFilterBVeto_1largeRjet1lep':{'DSID':364115, + 'events':4940500, + 'red_eff':1, + 'sumw':2839137.81561, + 'xsec':219.9958116}, + 'Zee_PTV0_70_BFilter_1largeRjet1lep':{'DSID':364116, + 'events':7883600, + 'red_eff':1, + 'sumw':4053053.52848, + 'xsec':127.0857614}, + 'Zee_PTV70_140_CVetoBVeto_1largeRjet1lep':{'DSID':364117, + 'events':5925000, + 'red_eff':1, + 'sumw':2164248.98844, + 'xsec':74.90381742}, + 'Zee_PTV70_140_CFilterBVeto_1largeRjet1lep':{'DSID':364118, + 'events':1972600, + 'red_eff':1, + 'sumw':715162.089738, + 'xsec':20.3159891}, + 'Zee_PTV70_140_BFilter_1largeRjet1lep':{'DSID':364119, + 'events':1, + 'red_eff':1, + 'sumw':2043192.28295, + 'xsec':12.73880801}, + 'Zee_PTV140_280_CVetoBVeto_1largeRjet1lep':{'DSID':364120, + 'events':4949000, + 'red_eff':1, + 'sumw':2966342.61469, + 'xsec':24.44184978}, + 'Zee_PTV140_280_CFilterBVeto_1largeRjet1lep':{'DSID':364121, + 'events':2962600, + 'red_eff':1, + 'sumw':1976624.57582, + 'xsec':9.237605979}, + 'Zee_PTV140_280_BFilter_1largeRjet1lep':{'DSID':364122, + 'events':4800000, + 'red_eff':1, + 'sumw':3338606.00232, + 'xsec':6.081254464}, + 'Zee_PTV280_500_CVetoBVeto_1largeRjet1lep':{'DSID':364123, + 'events':1932800, + 'red_eff':1, + 'sumw':1665734.2346, + 'xsec':4.796836771}, + 'Zee_PTV280_500_CFilterBVeto_1largeRjet1lep':{'DSID':364124, + 'events':988900, + 'red_eff':1, + 'sumw':908261.497964, + 'xsec':2.249186051}, + 'Zee_PTV280_500_BFilter_1largeRjet1lep':{'DSID':364125, + 'events':1976850, + 'red_eff':1, + 'sumw':1854184.55614, + 'xsec':1.49219843}, + 'Zee_PTV500_1000_1largeRjet1lep':{'DSID':364126, + 'events':2973000, + 'red_eff':1, + 'sumw':2942740.91362, + 'xsec':1.76415092}, + 'Zee_PTV1000_E_CMS_1largeRjet1lep':{'DSID':364127, + 'events':988000, + 'red_eff':1, + 'sumw':1004312.18015, + 'xsec':0.145046125}, + + 'Ztautau_PTV0_70_CVetoBVeto_1largeRjet1lep':{'DSID':364128, + 'events':7907000, + 'red_eff':1, + 'sumw':5322698.33479, + 'xsec':1612.531483}, + + 'Ztautau_PTV0_70_CFilterBVeto_1largeRjet1lep':{'DSID':364129, + 'events':4941000, + 'red_eff':1, + 'sumw':2848153.01809, + 'xsec':211.7088872}, + + 'Ztautau_PTV0_70_BFilter_1largeRjet1lep':{'DSID':364130, + 'events':7890600, + 'red_eff':1, + 'sumw':4060541.5209, + 'xsec':127.0915597}, + + 'Ztautau_PTV70_140_CVetoBVeto_1largeRjet1lep':{'DSID':364131, + 'events':5935500, + 'red_eff':1, + 'sumw':2168444.60741, + 'xsec':74.70740605}, + + 'Ztautau_PTV70_140_CFilterBVeto_1largeRjet1lep':{'DSID':364132, + 'events':1961200, + 'red_eff':1, + 'sumw':717613.996532, + 'xsec':20.50813626}, + + 'Ztautau_PTV70_140_BFilter_1largeRjet1lep':{'DSID':364133, + 'events':5912550, + 'red_eff':1, + 'sumw':2071490.99782, + 'xsec':11.96510571}, + + 'Ztautau_PTV140_280_CVetoBVeto_1largeRjet1lep':{'DSID':364134, + 'events':4296000, + 'red_eff':1, + 'sumw':2574043.5746, + 'xsec':24.57266372}, + + 'Ztautau_PTV140_280_CFilterBVeto_1largeRjet1lep':{'DSID':364135, + 'events':2973000, + 'red_eff':1, + 'sumw':1983172.64602, + 'xsec':9.301821784}, + + 'Ztautau_PTV140_280_BFilter_1largeRjet1lep':{'DSID':364136, + 'events':4932950, + 'red_eff':1, + 'sumw':3430451.22731, + 'xsec':6.192971739}, + + 'Ztautau_PTV280_500_CVetoBVeto_1largeRjet1lep':{'DSID':364137, + 'events':1973000, + 'red_eff':1, + 'sumw':1656090.74518, + 'xsec':4.759698353}, + + 'Ztautau_PTV280_500_CFilterBVeto_1largeRjet1lep':{'DSID':364138, + 'events':986000, + 'red_eff':1, + 'sumw':905387.206237, + 'xsec':2.236223236}, + + 'Ztautau_PTV280_500_BFilter_1largeRjet1lep':{'DSID':364139, + 'events':1974950, + 'red_eff':1, + 'sumw':1853029.9701, + 'xsec':1.491840072}, + + 'Ztautau_PTV500_1000_1largeRjet1lep':{'DSID':364140, + 'events':2944800, + 'red_eff':1, + 'sumw':2923750.21933, + 'xsec':1.76249325}, + + 'Ztautau_PTV1000_E_CMS_1largeRjet1lep':{'DSID':364141, + 'events':980000, + 'red_eff':1, + 'sumw':997974.838867, + 'xsec':0.144568326}, + + 'Wmunu_PTV0_70_CVetoBVeto_1largeRjet1lep':{'DSID':364156, + 'events':24723000, + 'red_eff':1, + 'sumw':16619290.3298, + 'xsec':15317.171239}, + 'Wmunu_PTV0_70_CFilterBVeto_1largeRjet1lep':{'DSID':364157, + 'events':9847000, + 'red_eff':1, + 'sumw':5643599.11526, + 'xsec':2431.204019}, + 'Wmunu_PTV0_70_BFilter_1largeRjet1lep':{'DSID':364158, + 'events':17226200, + 'red_eff':1, + 'sumw':10403012.6599, + 'xsec':828.465384}, + 'Wmunu_PTV70_140_CVetoBVeto_1largeRjet1lep':{'DSID':364159, + 'events':14788000, + 'red_eff':1, + 'sumw':5418398.88082, + 'xsec':617.439593}, + 'Wmunu_PTV70_140_CFilterBVeto_1largeRjet1lep':{'DSID':364160, + 'events':9853800, + 'red_eff':1, + 'sumw':3693885.78953, + 'xsec':225.006704}, + 'Wmunu_PTV70_140_BFilter_1largeRjet1lep':{'DSID':364161, + 'events':19639000, + 'red_eff':1, + 'sumw':7990084.35926, + 'xsec':76.213179}, + 'Wmunu_PTV140_280_CVetoBVeto_1largeRjet1lep':{'DSID':364162, + 'events':9882000, + 'red_eff':1, + 'sumw':6155495.28527, + 'xsec':198.635592}, + 'Wmunu_PTV140_280_CFilterBVeto_1largeRjet1lep':{'DSID':364163, + 'events':7408000, + 'red_eff':1, + 'sumw':5260811.17463, + 'xsec':96.233222}, + 'Wmunu_PTV140_280_BFilter_1largeRjet1lep':{'DSID':364164, + 'events':24585000, + 'red_eff':1, + 'sumw':18222434.0789, + 'xsec':36.348467}, + 'Wmunu_PTV280_500_CVetoBVeto_1largeRjet1lep':{'DSID':364165, + 'events':4940000, + 'red_eff':1, + 'sumw':4325283.67358, + 'xsec':38.299835}, + 'Wmunu_PTV280_500_CFilterBVeto_1largeRjet1lep':{'DSID':364166, + 'events':2958000, + 'red_eff':1, + 'sumw':2783968.68238, + 'xsec':22.395647}, + 'Wmunu_PTV280_500_BFilter_1largeRjet1lep':{'DSID':364167, + 'events':2919500, + 'red_eff':1, + 'sumw':2797023.37969, + 'xsec':8.768196}, + 'Wmunu_PTV500_1000_1largeRjet1lep':{'DSID':364168, + 'events':5910500, + 'red_eff':1, + 'sumw':5941704.99235, + 'xsec':14.558821}, + 'Wmunu_PTV1000_E_CMS_1largeRjet1lep':{'DSID':364169, + 'events':3959000, + 'red_eff':1, + 'sumw':4068015.22447, + 'xsec':1.198003}, + + 'Wenu_PTV0_70_CVetoBVeto_1largeRjet1lep':{'DSID':364170, + 'events':24740000, + 'red_eff':1, + 'sumw':16615214.8608, + 'xsec':15324.216356}, + + 'Wenu_PTV0_70_CFilterBVeto_1largeRjet1lep':{'DSID':364171, + 'events':9853500, + 'red_eff':1, + 'sumw':5647044.71225, + 'xsec':2430.656322}, + + 'Wenu_PTV0_70_BFilter_1largeRjet1lep':{'DSID':364172, + 'events':17242400, + 'red_eff':1, + 'sumw':10407897.8772, + 'xsec':832.203758}, + + 'Wenu_PTV70_140_CVetoBVeto_1largeRjet1lep':{'DSID':364173, + 'events':14660500, + 'red_eff':1, + 'sumw':5359689.22316, + 'xsec':618.6882}, + + 'Wenu_PTV70_140_CFilterBVeto_1largeRjet1lep':{'DSID':364174, + 'events':9818400, + 'red_eff':1, + 'sumw':3714792.41865, + 'xsec':223.63946}, + + 'Wenu_PTV70_140_BFilter_1largeRjet1lep':{'DSID':364175, + 'events':5401900, + 'red_eff':1, + 'sumw':2194437.53008, + 'xsec':94.875534}, + + 'Wenu_PTV140_280_CVetoBVeto_1largeRjet1lep':{'DSID':364176, + 'events':9879000, + 'red_eff':1, + 'sumw':6159276.028, + 'xsec':197.343129}, + + 'Wenu_PTV140_280_CFilterBVeto_1largeRjet1lep':{'DSID':364177, + 'events':7360000, + 'red_eff':1, + 'sumw':5227943.44514, + 'xsec':96.277568}, + + 'Wenu_PTV140_280_BFilter_1largeRjet1lep':{'DSID':364178, + 'events':24677800, + 'red_eff':1, + 'sumw':18298138.5816, + 'xsec':35.917295}, + + 'Wenu_PTV280_500_CVetoBVeto_1largeRjet1lep':{'DSID':364179, + 'events':4923800, + 'red_eff':1, + 'sumw':4312357.01458, + 'xsec':38.340533}, + + 'Wenu_PTV280_500_CFilterBVeto_1largeRjet1lep':{'DSID':364180, + 'events':2963400, + 'red_eff':1, + 'sumw':2778654.28759, + 'xsec':22.36999}, + + 'Wenu_PTV280_500_BFilter_1largeRjet1lep':{'DSID':364181, + 'events':2958000, + 'red_eff':1, + 'sumw':2835314.68179, + 'xsec':9.586345}, + + 'Wenu_PTV500_1000_1largeRjet1lep':{'DSID':364182, + 'events':5911800, + 'red_eff':1, + 'sumw':5998269.59452, + 'xsec':14.598599}, + + 'Wenu_PTV1000_E_CMS_1largeRjet1lep':{'DSID':364183, + 'events':3947000, + 'red_eff':1, + 'sumw':4075236.23897, + 'xsec':1.197518}, + + 'Wtaunu_PTV0_70_CVetoBVeto_1largeRjet1lep':{'DSID':364184, + 'events':24784000, + 'red_eff':1, + 'sumw':16726425.0218, + 'xsec':15324.887336}, + + 'Wtaunu_PTV0_70_CFilterBVeto_1largeRjet1lep':{'DSID':364185, + 'events':9865600, + 'red_eff':1, + 'sumw':5671521.55269, + 'xsec':2443.425881}, + + 'Wtaunu_PTV0_70_BFilter_1largeRjet1lep':{'DSID':364186, + 'events':17273200, + 'red_eff':1, + 'sumw':10498770.1084, + 'xsec':837.531038}, + + 'Wtaunu_PTV70_140_CVetoBVeto_1largeRjet1lep':{'DSID':364187, + 'events':14808500, + 'red_eff':1, + 'sumw':5427023.47527, + 'xsec':620.166885}, + + 'Wtaunu_PTV70_140_CFilterBVeto_1largeRjet1lep':{'DSID':364188, + 'events':9270000, + 'red_eff':1, + 'sumw':3494336.03082, + 'xsec':222.595303}, + + 'Wtaunu_PTV70_140_BFilter_1largeRjet1lep':{'DSID':364189, + 'events':9857000, + 'red_eff':1, + 'sumw':3969118.20687, + 'xsec':95.365521}, + + 'Wtaunu_PTV140_280_CVetoBVeto_1largeRjet1lep':{'DSID':364190, + 'events':9899000, + 'red_eff':1, + 'sumw':6166514.76606, + 'xsec':197.370776}, + + 'Wtaunu_PTV140_280_CFilterBVeto_1largeRjet1lep':{'DSID':364191, + 'events':7405000, + 'red_eff':1, + 'sumw':5248104.98519, + 'xsec':93.808553}, + + 'Wtaunu_PTV140_280_BFilter_1largeRjet1lep':{'DSID':364192, + 'events':24819900, + 'red_eff':1, + 'sumw':18407605.7617, + 'xsec':34.639523}, + + 'Wtaunu_PTV280_500_CVetoBVeto_1largeRjet1lep':{'DSID':364193, + 'events':4931200, + 'red_eff':1, + 'sumw':4322848.66983, + 'xsec':38.34009}, + + 'Wtaunu_PTV280_500_CFilterBVeto_1largeRjet1lep':{'DSID':364194, + 'events':2956400, + 'red_eff':1, + 'sumw':2772305.06916, + 'xsec':22.268425}, + + 'Wtaunu_PTV280_500_BFilter_1largeRjet1lep':{'DSID':364195, + 'events':2954100, + 'red_eff':1, + 'sumw':2830341.62344, + 'xsec':9.490847}, + + 'Wtaunu_PTV500_1000_1largeRjet1lep':{'DSID':364196, + 'events':5945000, + 'red_eff':1, + 'sumw':5983038.9473, + 'xsec':14.60345}, + + 'Wtaunu_PTV1000_E_CMS_1largeRjet1lep':{'DSID':364197, + 'events':3946000, + 'red_eff':1, + 'sumw':4057477.95297, + 'xsec':1.197324}, + + # gluino-gluino -> stop-stop -> tttt + DM + + 'GG_ttn1_1200_5000_1_1largeRjet1lep': {'DSID' : 370114, + 'events' : 100000, + 'red_eff' : 1, + 'sumw' : 101591.347734, + 'xsec' : 0.057037}, + + 'GG_ttn1_1200_5000_600_1largeRjet1lep': {'DSID' : 370118, + 'events' : 100000, + 'red_eff' : 1, + 'sumw' : 101591.282303, + 'xsec' : 0.057002}, + + 'GG_ttn1_1400_5000_1_1largeRjet1lep': {'DSID' : 370129, + 'events' : 100000, + 'red_eff' : 1, + 'sumw' : 101197.830825, + 'xsec' : 0.015756}, + + 'GG_ttn1_1600_5000_1_1largeRjet1lep': {'DSID' : 370144, + 'events':199000, + 'red_eff' : 1, + 'sumw' : 201048.136391, + 'xsec' : 0.004747}, + + # stop-stop -> tt + DM + + 'TT_directTT_450_1_1largeRjet1lep': {'DSID' : 388240, + 'events' : 50000, + 'red_eff' : 1, + 'sumw' : 52247.301193, + 'xsec' : 0.88424}, + + 'TT_directTT_500_1_1largeRjet1lep': {'DSID' : 387154, + 'events' : 20000, + 'red_eff' : 1, + 'sumw' : 20793.7352104, + 'xsec' : 0.46603}, + + 'TT_directTT_500_200_1largeRjet1lep': {'DSID' : 387157, + 'events' : 50000, + 'red_eff' : 1, + 'sumw' : 51998.4134001, + 'xsec' : 0.46702}, + + 'TT_directTT_600_1_1largeRjet1lep': {'DSID' : 387163, + 'events':69000, + 'red_eff' : 1, + 'sumw' : 71506.9188489, + 'xsec' : 0.15518}, + + # chargino-neutralino -> WZ(->lvll) + + 'C1N2_WZ_100p0_0p0_3L_2L7_1largeRjet1lep': {'DSID' : 392226, + 'events' : 25000, + 'red_eff' : 1, + 'sumw' : 26928.7771142, + 'xsec' : 15.82879625}, + + 'C1N2_WZ_350p0_0p0_3L_2L7_1largeRjet1lep': {'DSID' : 392220, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10346.0705611, + 'xsec' : 0.1418528975}, + + 'C1N2_WZ_400p0_0p0_3L_2L7_1largeRjet1lep': {'DSID' : 392217, + 'events' : 10000, + 'red_eff' : 1, + 'sumw' : 10327.8154224, + 'xsec' : 0.080689712}, + + 'C1N2_WZ_500p0_0p0_3L_2L7_1largeRjet1lep': {'DSID' : 392223, + 'events':15000, + 'red_eff' : 1, + 'sumw' : 15476.3430636, + 'xsec' : 0.0301334215}, + +} diff --git a/reporte/Entrenamiento BTD para identificar signal de background con 4 leptones.pdf b/reporte/Entrenamiento BTD para identificar signal de background con 4 leptones.pdf new file mode 100644 index 0000000000000000000000000000000000000000..165267a39a65ace832080fe932671932549edca4 Binary files /dev/null and b/reporte/Entrenamiento BTD para identificar signal de background con 4 leptones.pdf differ